class Window(QWidget): def __init__(self): super().__init__() self.setWindowTitle( "Pyside2 SpinBox") # Configure le titre de la fenêtre self.setGeometry(300, 300, 500, 400) # Configure la taille de la fenêtre self.setIcon() self.spinBox() def setIcon(self): appIcon = QIcon("icon.png") self.setWindowIcon(appIcon) def spinBox(self): vbox = QVBoxLayout() self.label = QLabel() self.spinbox = QDoubleSpinBox() self.spinbox.setMinimum(10) self.spinbox.setMaximum(100) self.spinbox.valueChanged.connect(self.spinValue) vbox.addWidget(self.label) vbox.addWidget(self.spinbox) self.setLayout(vbox) def spinValue(self): self.label.setText("Current Value is : " + str(self.spinbox.value()))
class Config(SignalNode.Config): """Config widget displayed for LSLInput.""" def __init__(self, parent=None): super().__init__(parent=parent) self.smoothing_factor = QDoubleSpinBox() self.smoothing_factor.setMinimum(0) self.smoothing_factor.setMaximum(1) self.smoothing_factor.setSingleStep(0.1) self.smoothing_factor.setPrefix("x") self.smoothing_factor.valueChanged.connect(self.updateModel) self.method = QComboBox() self.method.addItem("Rectification") self.method.addItem("Fourier Transform") self.method.addItem("Hilbert Transform") self.method.addItem("cFIR") self.method.currentTextChanged.connect(self.updateModel) self.smoother_type = QComboBox() for name in EnvelopeDetector.smoother_name_to_type: self.smoother_type.addItem(name) self.smoother_type.currentTextChanged.connect(self.updateModel) layout = QFormLayout() self.setLayout(layout) layout.addRow("Smoothing factor", self.smoothing_factor) layout.addRow("Method", self.method) layout.addRow("Smoother type", self.smoother_type) def updateModel(self): n = self.node() if n is None: return smoothing_factor = self.smoothing_factor.value() method = self.method.currentText() smoother_type = n.smoother_name_to_type[self.smoother_type.currentText()] n.setSmoothingFactor(smoothing_factor) n.setMethod(method) n.setSmootherType(smoother_type) def updateView(self): n = self.node() if n is None: return self.smoothing_factor.blockSignals(True) self.method.blockSignals(True) self.smoother_type.blockSignals(True) self.smoothing_factor.setValue(n.smoothingFactor()) self.method.setCurrentText(n.method()) self.smoother_type.setCurrentText(n.smoother_type_to_name[n.smootherType()]) self.smoothing_factor.blockSignals(False) self.method.blockSignals(False) self.smoother_type.blockSignals(False)
class GaussianFuzzierSetting(QFrame): def __init__(self): super().__init__() layout = QHBoxLayout() layout.setContentsMargins(0, 0, 0, 0) self.setLayout(layout) self.mean = QDoubleSpinBox() self.mean.setRange(-100, 100) self.mean.setStatusTip("The mean (mu) value for Gaussian function.") self.sd = QDoubleSpinBox() self.sd.setDecimals(3) self.sd.setValue(5) self.sd.setMinimum(0.1) self.sd.setStatusTip("The standard deviation (sigma) value for " "Gaussian function.") self.ascending = QCheckBox() self.ascending.setIcon(QIcon(':/icons/ascending_icon.png')) self.ascending.setStatusTip("Make the fuzzier strictly ascending.") self.descending = QCheckBox() self.descending.setIcon(QIcon(':/icons/descending_icon.png')) self.descending.setStatusTip("Make the fuzzier strictly descending.") layout.addWidget(QLabel("Mean")) layout.addWidget(self.mean, 1) layout.addWidget(QLabel("Standard Deviation")) layout.addWidget(self.sd, 1) layout.addWidget(self.ascending) layout.addWidget(self.descending) def get_values(self): return (self.mean.value(), self.sd.value(), self.ascending.isChecked(), self.descending.isChecked())
def generate_numeric_input(self, maximum, minimum, increment, current): sb = QDoubleSpinBox(self) sb.setMaximum(maximum) sb.setMinimum(minimum) sb.setSingleStep(increment) sb.setValue(current) return sb
def createEditor(self, parent, option, index): doubleSpinBox = QDoubleSpinBox(parent) doubleSpinBox.setDecimals(5) doubleSpinBox.setMinimum(-100000) doubleSpinBox.setMaximum(100000) self.connect(doubleSpinBox, SIGNAL("valueChanged(float)"), self, SLOT("valueChanged()")) return doubleSpinBox
def _make_double_spinbox(default, min_value, max_value, single_step): spinbox = QDoubleSpinBox() spinbox.setSingleStep(single_step) spinbox.setMaximum(max_value) spinbox.setMinimum(min_value) spinbox.setValue(default) return spinbox
class FloatField(Field): def __init__(self, property): super(FloatField, self).__init__(property) self._widget = QDoubleSpinBox() self._widget.valueChanged.connect(self.emitChanged) self._widget.setMinimum(property.min()) self._widget.setMaximum(property.max()) self._widget.setSingleStep(property.step()) def value(self): return self._widget.value() def setValue(self, value): self._widget.setValue(value) def setReadOnly(self, value): self._widget.setReadOnly(value) valueProperty = Property( float, value, Field.setValueBlocked) # C++: should be in parent class
def _gui(self): layout = QVBoxLayout() self.setLayout(layout) slider_layout = QHBoxLayout() layout.addLayout(slider_layout) slider_layout.addWidget(QLabel('Document-level adequacy')) adequacy = QDoubleSpinBox(self) adequacy.setMinimum(1) adequacy.setMaximum(5) self.adequacy = adequacy slider_layout.addWidget(adequacy) self.items = [ adequacy, ] for item in self.items: item.valueChanged.connect(self.evaluation_changed)
def _create_int_float(self, val, is_float: bool = False, key: str = None) -> QWidget: """ Creates the widget for integer or float. Parameters ---------- val : list list of type, default value, description is_float : bool, optional is the value suposed to be a float, by default False key : str, optional The variable name, by default None Returns ------- QWidget The given widget correctly set up """ default_val = val[1] if val[1] is not None else 0 if is_float: widget = QDoubleSpinBox() else: widget = QSpinBox() widget.setMinimum(-1000) widget.setMaximum(1000) # Needed to return to default if it is ever needed widget.setMinimum(-1000) widget.setMaximum(1000) widget.setValue(self._set_default(widget, default_val)) tmp_val = self.config_val.get(key, None) if isinstance(tmp_val, str): if 'None' not in tmp_val: widget.setValue(float(tmp_val)) elif tmp_val is not None: widget.setValue(float(tmp_val)) widget.setToolTip(val[2]) return widget
class Ui_MainWindow: """This class holds all the UI structral info: widgets and their organization. main_window is the parent app window, which handles hooking the GUI widgets up to the controller/model.""" def setupUi(self, main_window): main_window.setObjectName('main_window') main_window.setWindowTitle('qt_mvc Demo') main_window.resize(800, 600) self.central_widget = QWidget(main_window) self.central_widget.setObjectName('centralwidget') self.central_layout = QVBoxLayout(self.central_widget) self.central_layout.setObjectName('centrallayout') self.top_bar_layout = QHBoxLayout() self.top_bar_layout.setObjectName('top_barlayout') self.base_label = QLabel('Base: ') self.base_entry = QDoubleSpinBox() self.base_entry.setObjectName('base_entry') self.exp_label = QLabel('Exponent: ') self.exp_entry = QDoubleSpinBox() self.exp_entry.setObjectName('exp_entry') self.base_entry.setValue(1) self.base_entry.setMinimum(0.1) self.exp_entry = QDoubleSpinBox() self.exp_entry.setValue(2) for widget in [ self.base_label, self.base_entry, self.exp_label, self.exp_entry ]: self.top_bar_layout.addWidget(widget) self.central_layout.addLayout(self.top_bar_layout) self.plot = PlotWidget() self.central_layout.addWidget(self.plot) main_window.setCentralWidget(self.central_widget)
def createPointWidget(self, x, y, z): layout = QHBoxLayout() x_label = QLabel("x:") x_label.setFixedWidth(10) x_val = QDoubleSpinBox() x_val.setSingleStep(0.01) x_val.setMinimum(-100) x_val.setMaximum(100) x_val.setDecimals(5) x_val.setValue(x) x_val.valueChanged.connect(self.onCoordsChanged) y_label = QLabel("y:") y_label.setFixedWidth(10) y_val = QDoubleSpinBox() y_val.setMinimum(-100) y_val.setMaximum(100) y_val.setDecimals(5) y_val.setSingleStep(0.01) y_val.setValue(y) y_val.valueChanged.connect(self.onCoordsChanged) z_label = QLabel("z:") z_label.setFixedWidth(10) z_val = QDoubleSpinBox() z_val.setMinimum(-100) z_val.setMaximum(100) z_val.setDecimals(5) z_val.setSingleStep(0.01) z_val.setValue(z) z_val.valueChanged.connect(self.onCoordsChanged) layout.addWidget(x_label) layout.addWidget(x_val) layout.addWidget(y_label) layout.addWidget(y_val) layout.addWidget(z_label) layout.addWidget(z_val) self.widgets.append([x_val, y_val, z_val]) return layout
class MainWidget(QWidget): def __init__(self, parent=None): super(MainWidget, self).__init__(parent) self.chart = QtCharts.QChart() self.series = QtCharts.QBarSeries() self.main_layout = QGridLayout() self.button_layout = QGridLayout() self.font_layout = QFormLayout() self.font_size = QDoubleSpinBox() self.legend_posx = QDoubleSpinBox() self.legend_posy = QDoubleSpinBox() self.legend_width = QDoubleSpinBox() self.legend_height = QDoubleSpinBox() self.detach_legend_button = QPushButton("Toggle attached") self.detach_legend_button.clicked.connect(self.toggle_attached) self.button_layout.addWidget(self.detach_legend_button, 0, 0) self.add_set_button = QPushButton("add barset") self.add_set_button.clicked.connect(self.add_barset) self.button_layout.addWidget(self.add_set_button, 2, 0) self.remove_barset_button = QPushButton("remove barset") self.remove_barset_button.clicked.connect(self.remove_barset) self.button_layout.addWidget(self.remove_barset_button, 3, 0) self.align_button = QPushButton("Align (Bottom)") self.align_button.clicked.connect(self.set_legend_alignment) self.button_layout.addWidget(self.align_button, 4, 0) self.bold_button = QPushButton("Toggle bold") self.bold_button.clicked.connect(self.toggle_bold) self.button_layout.addWidget(self.bold_button, 8, 0) self.italic_button = QPushButton("Toggle italic") self.italic_button.clicked.connect(self.toggle_italic) self.button_layout.addWidget(self.italic_button, 9, 0) self.legend_posx.valueChanged.connect(self.update_legend_layout) self.legend_posy.valueChanged.connect(self.update_legend_layout) self.legend_width.valueChanged.connect(self.update_legend_layout) self.legend_height.valueChanged.connect(self.update_legend_layout) legend_layout = QFormLayout() legend_layout.addRow("HPos", self.legend_posx) legend_layout.addRow("VPos", self.legend_posy) legend_layout.addRow("Width", self.legend_width) legend_layout.addRow("Height", self.legend_height) self.legend_settings = QGroupBox("Detached legend") self.legend_settings.setLayout(legend_layout) self.button_layout.addWidget(self.legend_settings) self.legend_settings.setVisible(False) # Create chart view with the chart self.chart_view = QtCharts.QChartView(self.chart, self) # Create spinbox to modify font size self.font_size.setValue(self.chart.legend().font().pointSizeF()) self.font_size.valueChanged.connect(self.font_size_changed) self.font_layout.addRow("Legend font size", self.font_size) # Create layout for grid and detached legend self.main_layout.addLayout(self.button_layout, 0, 0) self.main_layout.addLayout(self.font_layout, 1, 0) self.main_layout.addWidget(self.chart_view, 0, 1, 3, 1) self.setLayout(self.main_layout) self.create_series() def create_series(self): self.add_barset() self.add_barset() self.add_barset() self.add_barset() self.chart.addSeries(self.series) self.chart.setTitle("Legend detach example") self.chart.createDefaultAxes() self.chart.legend().setVisible(True) self.chart.legend().setAlignment(Qt.AlignBottom) self.chart_view.setRenderHint(QPainter.Antialiasing) def show_legend_spinbox(self): self.legend_settings.setVisible(True) chart_viewrect = self.chart_view.rect() self.legend_posx.setMinimum(0) self.legend_posx.setMaximum(chart_viewrect.width()) self.legend_posx.setValue(150) self.legend_posy.setMinimum(0) self.legend_posy.setMaximum(chart_viewrect.height()) self.legend_posy.setValue(150) self.legend_width.setMinimum(0) self.legend_width.setMaximum(chart_viewrect.width()) self.legend_width.setValue(150) self.legend_height.setMinimum(0) self.legend_height.setMaximum(chart_viewrect.height()) self.legend_height.setValue(75) def hideLegendSpinbox(self): self.legend_settings.setVisible(False) def toggle_attached(self): legend = self.chart.legend() if legend.isAttachedToChart(): legend.detachFromChart() legend.setBackgroundVisible(True) legend.setBrush(QBrush(QColor(128, 128, 128, 128))) legend.setPen(QPen(QColor(192, 192, 192, 192))) self.show_legend_spinbox() self.update_legend_layout() else: legend.attachToChart() legend.setBackgroundVisible(False) self.hideLegendSpinbox() self.update() def add_barset(self): series_count = self.series.count() bar_set = QtCharts.QBarSet("set {}".format(series_count)) delta = series_count * 0.1 bar_set.append([1 + delta, 2 + delta, 3 + delta, 4 + delta]) self.series.append(bar_set) def remove_barset(self): sets = self.series.barSets() len_sets = len(sets) if len_sets > 0: self.series.remove(sets[len_sets - 1]) def set_legend_alignment(self): button = self.sender() legend = self.chart.legend() alignment = legend.alignment() if alignment == Qt.AlignTop: legend.setAlignment(Qt.AlignLeft) if button: button.setText("Align (Left)") elif alignment == Qt.AlignLeft: legend.setAlignment(Qt.AlignBottom) if button: button.setText("Align (Bottom)") elif alignment == Qt.AlignBottom: legend.setAlignment(Qt.AlignRight) if button: button.setText("Align (Right)") else: if button: button.setText("Align (Top)") legend.setAlignment(Qt.AlignTop) def toggle_bold(self): legend = self.chart.legend() font = legend.font() font.setBold(not font.bold()) legend.setFont(font) def toggle_italic(self): legend = self.chart.legend() font = legend.font() font.setItalic(not font.italic()) legend.setFont(font) def font_size_changed(self): legend = self.chart.legend() font = legend.font() font_size = self.font_size.value() if font_size < 1: font_size = 1 font.setPointSizeF(font_size) legend.setFont(font) def update_legend_layout(self): legend = self.chart.legend() rect = QRectF(self.legend_posx.value(), self.legend_posy.value(), self.legend_width.value(), self.legend_height.value()) legend.setGeometry(rect) legend.update()
class FirstAlgorithm(QDialog): executed = Signal(dict, list) defaultParameters = { 'offset filter': True, 'supply filter': True, 'LPF highcut': 3, 'BPF lowcut': 8, 'BPF highcut': 30, 'art thres': 100, 'window': 25, 'prev sec': 5, 'hmt larger': 3, 'hmt larger mean': 2, } def __init__(self, dataManager, chartManager, parent=None, inputList=None, initParam=None): QDialog.__init__(self, parent) self.dataManager = dataManager self.fs = self.dataManager.getFs() self.chartManager = chartManager self.setWindowTitle('Algorithms') self.inputList = inputList if initParam: self.parameters = initParam print('initParam') else: self.parameters = self.defaultParameters print('defaultParameters') #Setup Layouts self.mainLayout = QVBoxLayout(self) self.setupInLayout() self.setupSettings() self.setupBtnBoxLayout() def setupInLayout(self): inGroup = QGroupBox('Input to process') inLayout = QFormLayout(inGroup) self.inTree = DataSelector(self.dataManager, inputList=self.inputList) inLayout.addWidget(QLabel('Select Input')) inLayout.addWidget(self.inTree) self.mainLayout.addWidget(inGroup) def setupSettings(self): spinBoxLayout = QFormLayout() self.removeOffset = QCheckBox('Remove DC offset') self.removeOffset.setChecked(self.parameters['offset filter']) spinBoxLayout.addRow(self.removeOffset) self.removeSupply = QCheckBox('Remove 50Hz') self.removeSupply.setChecked(self.parameters['supply filter']) spinBoxLayout.addRow(self.removeSupply) ## self.lpfHighcut = QSpinBox() ## self.lpfHighcut.setMaximum(10000) ## self.lpfHighcut.setValue(self.parameters['LPF highcut']) ## spinBoxLayout.addRow('LPF highcut frequency:', self.lpfHighcut) self.bpfLowcut = QSpinBox() self.bpfLowcut.setMaximum(10000) self.bpfLowcut.setValue(self.parameters['BPF lowcut']) spinBoxLayout.addRow('BPF lowcut frequency:', self.bpfLowcut) self.bpfHighcut = QSpinBox() self.bpfHighcut.setMaximum(10000) self.bpfHighcut.setValue(self.parameters['BPF highcut']) spinBoxLayout.addRow('BPF highcut frequency:', self.bpfHighcut) ## self.ArtefactsThreshold = QSpinBox() ## self.ArtefactsThreshold.setMaximum(10000) ## self.ArtefactsThreshold.setValue(self.parameters['art thres']) ## spinBoxLayout.addRow('Artefacts Threshold:', self.ArtefactsThreshold) self.algWindowSize = QSpinBox() self.algWindowSize.setMaximum(10000) self.algWindowSize.setValue(self.parameters['window']) spinBoxLayout.addRow('Window (samples):', self.algWindowSize) self.hmtLargerMean = QDoubleSpinBox() self.hmtLargerMean.setMinimum(0.1) self.hmtLargerMean.setMaximum(10000) self.hmtLargerMean.setValue(self.parameters['hmt larger mean']) spinBoxLayout.addRow('How many times larger than mean:', self.hmtLargerMean) self.prevSeconds = QDoubleSpinBox() self.prevSeconds.setMinimum(0.1) self.prevSeconds.setMaximum(10000) self.prevSeconds.setValue(self.parameters['prev sec']) spinBoxLayout.addRow('Number of previous seconds:', self.prevSeconds) self.hmtLarger = QDoubleSpinBox() self.hmtLarger.setMinimum(0.1) self.hmtLarger.setMaximum(10000) self.hmtLarger.setValue(self.parameters['hmt larger']) spinBoxLayout.addRow('How many times larger than previous:', self.hmtLarger) gBox = QGroupBox('Settings') gBox.setLayout(spinBoxLayout) self.mainLayout.addWidget(gBox) def setupBtnBoxLayout(self): bottomLayout = QHBoxLayout() self.progBar = QProgressBar() self.progBar.setVisible(False) bottomLayout.addWidget(self.progBar) buttonBox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Close) buttonBox.accepted.connect(self.okBtnBox) buttonBox.rejected.connect(self.close) bottomLayout.addWidget(buttonBox) self.mainLayout.addLayout(bottomLayout) def okBtnBox(self): inStruct = self.inTree.getSelectedStruct() inDataStruct = self.dataManager.getData(inStruct, inv=True) self.progBar.setVisible(True) self.progBar.setValue(0) nProgres = 5 progStep = 100.0 / nProgres progress = 0 wName = list(inDataStruct.keys())[0] gName = list(inDataStruct[wName].keys())[0] ## Input inData = np.copy(inDataStruct[wName][gName]) ## Noises if self.removeOffset.isChecked(): inData = [signal.detrend(data, type='constant') for data in inData] if self.removeSupply.isChecked(): b, a = filterCalc(order=5, bandarr=[48, 52], fs=self.fs, btype='bandstop', ftype='butter') inData = [signal.lfilter(b, a, data) for data in inData] winLen = self.algWindowSize.value() ## ## Artefacts ## lpfHighcut = self.lpfHighcut.value() ## order=5 ## ## b, a = filterCalc(order, [lpfHighcut], self.fs, 'low', 'butter') ## lpfData = [] ## for data in inData: ## newData = signal.lfilter(b, a, data) ## lpfData.append(newData) ## ## ## ## segNmbr = int(np.shape(lpfData)[1]/winLen) ## artefactsThreshold = self.ArtefactsThreshold.value() ## ## lpfWinData = np.copy(lpfData) ## lpfWinData = [np.array_split(ch, segNmbr) for ch in lpfWinData] ## ## for ch in lpfWinData: ## for seg in ch: ## seg.fill(max(seg)- min(seg)) ## progress += progStep self.progBar.setValue(progress) ## #### thresLpfData = np.copy(lpfWinData) ## thresLpfData = deepcopy(lpfWinData) ## ## for x in thresLpfData: ## for y in x: ## if y[0] >= artefactsThreshold: ## y.fill(1) ## else: ## y.fill(0) ## ## lpfWinData = [np.concatenate(ch) for ch in lpfWinData] ## thresLpfData = [np.concatenate(ch) for ch in thresLpfData] ## progress += progStep self.progBar.setValue(progress) ## Spikes bpfLowcut = self.bpfLowcut.value() bpfHighcut = self.bpfHighcut.value() order = 4 b, a = filterCalc(order, [bpfLowcut, bpfHighcut], self.fs, 'band', 'butter') bpfData = [] for data in inData: newData = signal.lfilter(b, a, data) bpfData.append(newData) segNmbr = int(np.shape(bpfData)[1] / winLen) prevSeconds = self.prevSeconds.value() prevWindows = int(prevSeconds * self.fs / winLen) progress += progStep self.progBar.setValue(progress) bpfWinData = np.copy(bpfData) bpfWinData = [np.array_split(ch, segNmbr) for ch in bpfWinData] chi = 0 for ch in bpfWinData: for seg in ch: seg.fill(max(seg) - min(seg)) progress += progStep self.progBar.setValue(progress) hmtLarger = self.hmtLarger.value() hmtLargerMean = self.hmtLargerMean.value() ## thresBpfData = np.copy(bpfWinData) thresBpfData = deepcopy(bpfWinData) for ch in range(len(bpfWinData)): channelMean = self.hmtLargerMean.value() * np.mean(inData[ch]) for i in range(prevWindows, len(bpfWinData[ch])): if bpfWinData[ch][i][0] > channelMean: prev = [ bpfWinData[ch][j][0] for j in range(i - prevWindows, i) ] if bpfWinData[ch][i][0] > hmtLarger * np.mean(prev): thresBpfData[ch][i].fill(1) else: thresBpfData[ch][i].fill(0) else: thresBpfData[ch][i].fill(0) progress += progStep self.progBar.setValue(progress) for ch in thresBpfData: for i in range(prevWindows): ch[i].fill(0) bpfWinData = [np.concatenate(ch) for ch in bpfWinData] thresBpfData = [np.concatenate(ch) for ch in thresBpfData] spikeMap = [np.sum(x) / winLen for x in thresBpfData] nazwaPliku = str(winLen) + '_' + str(prevSeconds) + '_' + str( hmtLarger) + '.csv' with open(nazwaPliku, 'w', encoding='utf-8') as csvfile: csvwriter = csv.writer(csvfile) csvwriter.writerow(spikeMap) ## for ch in spikeMap ## csvwriter.writerow(spikeMap) ## Add data or replace existing swsName = 'Algorithm output' chNames = inStruct[wName][gName] if swsName not in self.dataManager.getDataGroups(): self.dataManager.createDataGroup(swsName, 'Algorithm') self.dataManager.addChannels(swsName, chNames) self.dataManager.addSignal(swsName, 'Input Signal', inData, chNames) ## self.dataManager.addSignal(swsName, 'LPF', lpfData, chNames) ## self.dataManager.addSignal(swsName, 'LPF+Window+Peak-to-peak', lpfWinData, chNames) ## self.dataManager.addSignal(swsName, 'LPF+Threshold - Artefacts', thresLpfData, chNames) self.dataManager.addSignal(swsName, 'BPF', bpfData, chNames) self.dataManager.addSignal(swsName, 'BPF+Window+Peak-to-peak', bpfWinData, chNames) self.dataManager.addSignal(swsName, 'BPF+Threshold - Spikes', thresBpfData, chNames) else: self.dataManager.silentChangeSignal(swsName, 'Input Signal', inData, chNames) ## self.dataManager.silentChangeSignal(swsName, 'LPF', lpfData, chNames) ## self.dataManager.silentChangeSignal(swsName, 'LPF+Window+P2P', lpfWinData, chNames) ## self.dataManager.silentChangeSignal(swsName, 'LPF+Threshold - Artefacts', thresLpfData, chNames) self.dataManager.silentChangeSignal(swsName, 'BPF', bpfData, chNames) self.dataManager.silentChangeSignal(swsName, 'BPF+Window+Peak-to-peak', bpfWinData, chNames) self.dataManager.silentChangeSignal(swsName, 'BPF+Threshold - Spikes', thresBpfData, chNames) self.chartManager.setMask('Algorithm output', 'BPF+Threshold - Spikes') self.chartManager.setMap(spikeMap) self.parameters = { 'offset filter': self.removeOffset.isChecked(), 'supply filter': self.removeSupply.isChecked(), ## 'LPF highcut' : lpfHighcut, 'BPF lowcut': bpfLowcut, 'BPF highcut': bpfHighcut, ## 'art thres' : artefactsThreshold, 'window': winLen, 'prev sec': prevSeconds, 'hmt larger': hmtLarger, 'hmt larger mean': hmtLargerMean, } self.executed.emit(self.parameters, self.inputList)
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
def _gui(self): layout = QVBoxLayout() self.setLayout(layout) slider_layout = QHBoxLayout() layout.addLayout(slider_layout) slider = ClickSlider(self) slider.setOrientation(Qt.Horizontal) slider.valueChanged.connect(self._slider_changed) slider_layout.addWidget(slider) self.slider = slider max_time = QLabel(self) self.max_time = max_time max_time.setText('--:--') slider_layout.addWidget(max_time) form = QFormLayout() layout.addLayout(form) time = QTimeEdit(self) time.setDisplayFormat('mm:ss.zzz') time.setAlignment(Qt.AlignRight) time.timeChanged.connect(self._edit_time_changed) self.time = time form.addRow(QLabel('Time', self),time) speed = QDoubleSpinBox(self) speed.setMinimum(0.1) speed.setMaximum(2.0) speed.setSingleStep(0.1) speed.setValue(1) speed.setAlignment(Qt.AlignRight) self.speed = speed speed.valueChanged.connect(self._speed_changed) form.addRow(QLabel('Speed', self), speed) playback = QHBoxLayout() layout.addLayout(playback) back_fast = QToolButton(self) playback.addWidget(back_fast) abf = QAction('<<', back_fast) abf.setShortcut(QKeySequence(Qt.Key_F1)) abf.triggered.connect(self.back_fast) back_fast.setDefaultAction(abf) back = QToolButton(self) playback.addWidget(back) ab = QAction('<', back) ab.setShortcut(QKeySequence(Qt.Key_F2)) ab.triggered.connect(self.back) back.setDefaultAction(ab) play = QToolButton(self) playback.addWidget(play) self.play_button = play play.setCheckable(True) play.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred) ap = QAction('Play', play) ap.setShortcut(QKeySequence(Qt.Key_F5)) ap.triggered.connect(self.play) play.setDefaultAction(ap) forward = QToolButton(self) playback.addWidget(forward) af = QAction('>', forward) af.setShortcut(QKeySequence(Qt.Key_F3)) af.triggered.connect(self.forward) forward.setDefaultAction(af) forward_fast = QToolButton(self) playback.addWidget(forward_fast) aff = QAction('>>', forward_fast) aff.setShortcut(QKeySequence(Qt.Key_F4)) aff.triggered.connect(self.forward_fast) forward_fast.setDefaultAction(aff) speed_up = QAction('Speed up', forward_fast) speed_up.setShortcut(QKeySequence(Qt.Key_F7)) speed_up.triggered.connect(self.speed.stepUp) speed_down = QAction('Speed down', forward_fast) speed_down.setShortcut(QKeySequence(Qt.Key_F6)) speed_down.triggered.connect(self.speed.stepDown) self.utils = [ slider, back_fast, back, play, forward, forward_fast, time, speed ] self.playback_actions = [abf, ab, ap, af, aff, speed_down, speed_up] self.set_enabled_utils(False) self.prevent = False self.timer = QTimer(self) self.timer.timeout.connect(self._update) self.timer.start(1) self.player = None
class SliderSpinBox(QWidget): valueChanged = Signal(float) def __init__(self, parent=None, *args, **kwargs): super(SliderSpinBox, self).__init__(parent=parent, *args, **kwargs) self._outerLayout = QHBoxLayout(self) self._outerLayout.setSpacing(0) self._outerLayout.setMargin(0) self._slider = Slider(self) self._slider.setOrientation(Qt.Horizontal) self._spinBox = QDoubleSpinBox(self) self._labelMinValue = QLabel(self) self._labelMaxValue = QLabel(self) self._labelTitle = QLabel(self) self._outerLayout.addWidget(self._labelMinValue) self._outerLayout.addWidget(self._slider) self._outerLayout.addWidget(self._labelMaxValue) self._outerLayout.addWidget(self._spinBox) self._outerLayout.addWidget(self._labelTitle) self.setMinimum(self._slider.minimum()) self.setMaximum(self._slider.maximum()) self._spinBox.setSingleStep(self._slider.getRange()/10.0) self._connect() def _connect(self): self._slider.signalValueChanged.connect(self._on_slider_value_changed) self._spinBox.valueChanged.connect(self._on_spin_box_value_changed) self._spinBox.valueChanged.connect(self.valueChanged) @Slot(float) def _on_slider_value_changed(self, value): if abs(self._spinBox.value() - value) > sys.float_info.epsilon: self._spinBox.setValue(value) @Slot(float) def _on_spin_box_value_changed(self, value): if abs(self._slider.value() - value) > sys.float_info.epsilon: self._slider.setValue(value) def setValue(self, value): self._on_spin_box_value_changed(value) def setMinimum(self, value): self._slider.setMinimum(value) self._spinBox.setMinimum(value) self._labelMinValue.setText(str(value)) self._spinBox.setSingleStep(self._slider.getRange()/10.0) def setMaximum(self, value): self._slider.setMaximum(value) self._spinBox.setMaximum(value) self._labelMaxValue.setText(str(value)) self._spinBox.setSingleStep(self._slider.getRange()/10.0) def setRange(self, values): self.setMinimum(values[0]) self.setMaximum(values[1]) def setTitle(self, value): self._labelTitle.setText(value) def setSliderFactor(self, value): self._slider.setFactor(value)
class ConfigDialog(QDialog): config_changed = Signal() def __init__(self, requester, config, parent=None): super().__init__(parent) self.requester = requester self.requester.pin_needed.connect(self.input_pin) self.requester.umi_made.connect(self.write_umi) self.requester.msg_passed.connect(self.error_msg) self.config = config self.lbl_id = QLabel('계정명') self.lbl_id.setAlignment(Qt.AlignCenter) self.lbl_pw = QLabel('비밀번호') self.lbl_pw.setAlignment(Qt.AlignCenter) self.lbl_umi = QLabel('umi 쿠키') self.lbl_umi.setAlignment(Qt.AlignCenter) self.lbl_ua = QLabel('유저 에이전트') self.lbl_ua.setAlignment(Qt.AlignCenter) self.lbl_delay = QLabel('저속 간격') self.lbl_delay.setAlignment(Qt.AlignCenter) self.lbl_msg = QLabel('') self.line_id = QLineEdit() self.line_pw = QLineEdit() self.line_pw.setEchoMode(QLineEdit.PasswordEchoOnEdit) self.line_umi = QLineEdit() self.line_umi.setPlaceholderText('로그인 시 자동 입력') self.line_ua = QLineEdit() self.line_delay = QDoubleSpinBox() self.line_delay.setMinimum(3) self.line_delay.setDecimals(1) self.line_delay.setSuffix('초') self.line_delay.setSingleStep(0.1) self.btn_save = NPButton('저장', 10, self) self.btn_save.clicked.connect(self.save) self.btn_cancel = NPButton('취소', 10, self) self.btn_cancel.clicked.connect(self.reject) self.btn_get_umi = NPButton('로그인', 10, self) self.btn_get_umi.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.MinimumExpanding) self.btn_get_umi.clicked.connect(self.get_umi) grid = QGridLayout() grid.addWidget(self.lbl_id, 0, 0, 1, 1) grid.addWidget(self.line_id, 0, 1, 1, 6) grid.addWidget(self.lbl_pw, 1, 0, 1, 1) grid.addWidget(self.line_pw, 1, 1, 1, 6) grid.addWidget(self.btn_get_umi, 0, 7, 2, 2) grid.addWidget(self.lbl_umi, 2, 0, 1, 1) grid.addWidget(self.line_umi, 2, 1, 1, 8) grid.addWidget(self.lbl_ua, 3, 0, 1, 1) grid.addWidget(self.line_ua, 3, 1, 1, 8) grid.addWidget(self.lbl_delay, 4, 0, 1, 1) grid.addWidget(self.line_delay, 4, 1, 1, 8) grid.addWidget(self.lbl_msg, 5, 0, 1, 4) grid.addWidget(self.btn_save, 5, 5, 1, 2) grid.addWidget(self.btn_cancel, 5, 7, 1, 2) self.setLayout(grid) self.input_dialog = InputDialog(self) self.input_dialog.input.setInputMask('999999') self.setWindowTitle('개인정보') self.setWindowIcon(QIcon('icon.png')) self.setStyleSheet('font: 10pt \'맑은 고딕\'') self.setWindowFlag(Qt.WindowContextHelpButtonHint, False) self.c_login, self.c_work = {}, {} @Slot(str) def error_msg(self, t): self.lbl_msg.setText(t) def load(self): self.line_id.setText(self.config.c['login']['ID']) self.line_pw.setText(self.config.c['login']['PW']) self.line_umi.setText(self.config.c['login']['UMI']) self.line_ua.setText(self.config.c['login']['UA']) self.line_ua.setCursorPosition(0) self.line_delay.setValue(float(self.config.c['work']['DELAY'])) self.lbl_msg.clear() ok = self.exec_() if ok == QDialog.Accepted: self.config_changed.emit() def save(self): self.config.save(login={ 'ID': self.line_id.text().strip(), 'PW': self.line_pw.text().strip(), 'UMI': self.line_umi.text().strip(), 'UA': self.line_ua.text().strip() }, delay=self.line_delay.value()) self.accept() def get_umi(self): self.lbl_msg.setText('로그인 시도...') self.line_umi.clear() self.input_dialog.input.clear() self.requester.init_login(self.line_id.text().strip(), self.line_pw.text().strip()) @Slot(str) def write_umi(self, umi): self.line_umi.setText(umi) @Slot(str) def input_pin(self, mail): pin, ok = self.input_dialog.get_text('로그인 PIN 입력', f'이메일({mail})로 전송된 PIN을 입력해주세요.') if ok: if pin: self.requester.typed_pin = pin else: self.requester.typed_pin = 'nothing' else: self.requester.typed_pin = 'deny'
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")
def __init_projector_widget__(self, parent=None): self.__projector_widget = QGroupBox("Projector Options", parent) # self.__projector_widget.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum) mirror_x = QCheckBox("Mirror X") mirror_x.setChecked(self.dlp_controller.is_horizontal_mirrored()) mirror_x.toggled.connect(self.dlp_controller.set_horizontal_mirroring) mirror_y = QCheckBox("Mirror Y") mirror_y.setChecked(self.dlp_controller.is_vertical_mirrored()) mirror_y.toggled.connect(self.dlp_controller.set_vertical_mirroring) start_projector_button = QPushButton("Start Projector", self.__projector_widget) start_projector_button.clicked.connect( self.dlp_controller.start_projector) project_pattern_button = QPushButton("Project Pattern", self.__projector_widget) project_pattern_button.clicked.connect( self.dlp_controller.project_calibration_pattern) print_position_button = QPushButton("Print Position", self.__projector_widget) print_position_button.clicked.connect( self.dlp_controller.print_motor_position) home_projector_button = QPushButton("Home Projector", self.__projector_widget) home_projector_button.clicked.connect( self.dlp_controller.home_projector) move_projector_button = QPushButton("Move Projector", self.__projector_widget) move_projector_button.clicked.connect( self.dlp_controller.move_projector) move_projector_edit = QDoubleSpinBox(self.__projector_widget) move_projector_edit.setSuffix("mm") move_projector_edit.setMaximum(10000) move_projector_edit.setMinimum(-10000) move_projector_edit.setDecimals(3) move_projector_edit.setSingleStep(0.001) move_projector_edit.valueChanged.connect( self.dlp_controller.update_projector_distance) set_amplitude_button = QPushButton("Set Projector Amplitude", self.__projector_widget) set_amplitude_button.clicked.connect( self.dlp_controller.set_projector_amplitude) set_amplitude_edit = QSpinBox(self.__projector_widget) set_amplitude_edit.setMaximum(1000) set_amplitude_edit.setMinimum(0) set_amplitude_edit.setValue(self.dlp_controller.projector_amplitude) set_amplitude_edit.valueChanged.connect( self.dlp_controller.update_projector_amplitude) lock_unlock_projector_button = QPushButton("Lock/Unlock Projector", self.__projector_widget) lock_unlock_projector_button.clicked.connect( self.dlp_controller.lock_unlock_projector) projector_layout = QGridLayout(self.__projector_widget) # projector_layout.addWidget(projector_label, 0, 0) projector_layout.addWidget(mirror_x, 0, 1) projector_layout.addWidget(mirror_y, 0, 2) projector_layout.addWidget(start_projector_button, 1, 0, 1, 1) projector_layout.addWidget(project_pattern_button, 1, 1, 1, 1) projector_layout.addWidget(print_position_button, 1, 2, 1, 1) projector_layout.addWidget(home_projector_button, 2, 0, 1, 1) projector_layout.addWidget(move_projector_button, 2, 1, 1, 1) projector_layout.addWidget(move_projector_edit, 2, 2) projector_layout.addWidget(set_amplitude_button, 3, 0, 1, 1) projector_layout.addWidget(set_amplitude_edit, 3, 1) projector_layout.addWidget(lock_unlock_projector_button, 3, 2, 1, 1) self.__projector_widget.setLayout(projector_layout)
def __init_features_widget__(self, parent=None): self.__features_widget = QGroupBox("Features Layers Parameters", parent) # self.__features_widget.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum) thickness_label = QLabel("Layer Thickness", self.__features_widget) self.features_thickness_edit = MyDiscreteStepsSpinBox( self.dlp_controller.get_step_length_microns(), self.__features_widget) self.features_thickness_edit.setSuffix(str('\u03BCm')) self.features_thickness_edit.setMaximum(1000000) self.features_thickness_edit.setMinimum(0) self.features_thickness_edit.setDecimals(3) self.features_thickness_edit.my_value_changed_signal.connect( self.dlp_controller.set_features_thickness) self.features_thickness_edit.setValue( self.dlp_controller.features_thickness * 1000) exposure_label = QLabel("Exposure Time", self.__features_widget) exposure_edit = QDoubleSpinBox(self.__features_widget) exposure_edit.setSuffix(str('ms')) exposure_edit.setMaximum(10000000) exposure_edit.setMinimum(0) exposure_edit.setDecimals(1) exposure_edit.setSingleStep(0.1) exposure_edit.setValue(self.dlp_controller.features_exposure) exposure_edit.valueChanged.connect( self.dlp_controller.set_features_exposure_time) amplitude_label = QLabel("Light Amplitude", self.__features_widget) amplitude_edit = QSpinBox(self.__features_widget) amplitude_edit.setMaximum(1600) amplitude_edit.setMinimum(0) amplitude_edit.setSingleStep(1) amplitude_edit.setValue(self.dlp_controller.features_amplitude) amplitude_edit.valueChanged.connect( self.dlp_controller.set_features_amplitude) burn_layers_label = QLabel("Burn Layers", self.__features_widget) burn_layers_edit = QSpinBox(self.__features_widget) burn_layers_edit.setMaximum(1000) burn_layers_edit.setMinimum(0) burn_layers_edit.setSingleStep(1) burn_layers_edit.setValue(self.dlp_controller.features_burn_layers) burn_layers_edit.valueChanged.connect( self.dlp_controller.set_features_burning_layers) burn_exposure_label = QLabel("Burn Exposure", self.__features_widget) burn_exposure_edit = QDoubleSpinBox(self.__features_widget) burn_exposure_edit.setSuffix(str('ms')) burn_exposure_edit.setMaximum(100000) burn_exposure_edit.setMinimum(0) burn_exposure_edit.setDecimals(1) burn_exposure_edit.setSingleStep(0.1) burn_exposure_edit.setValue(self.dlp_controller.features_burn_exposure) burn_exposure_edit.valueChanged.connect( self.dlp_controller.set_features_burning_exposure_time) burn_amplitude_label = QLabel("Burn Amplitude", self.__features_widget) burn_amplitude_edit = QSpinBox(self.__features_widget) burn_amplitude_edit.setMaximum(1600) burn_amplitude_edit.setMinimum(0) burn_amplitude_edit.setSingleStep(1) burn_amplitude_edit.setValue( self.dlp_controller.features_burn_amplitude) burn_amplitude_edit.valueChanged.connect( self.dlp_controller.set_features_burning_amplitude) select_layers_button = QPushButton("Select Features Images") select_layers_button.clicked.connect(self.load_features_images) features_layout = QGridLayout(self.__features_widget) features_layout.addWidget(thickness_label, 1, 0) features_layout.addWidget(self.features_thickness_edit, 1, 1) features_layout.addWidget(exposure_label, 2, 0) features_layout.addWidget(exposure_edit, 2, 1) features_layout.addWidget(amplitude_label, 3, 0) features_layout.addWidget(amplitude_edit, 3, 1) features_layout.addWidget(burn_layers_label, 4, 0) features_layout.addWidget(burn_layers_edit, 4, 1) features_layout.addWidget(burn_exposure_label, 5, 0) features_layout.addWidget(burn_exposure_edit, 5, 1) features_layout.addWidget(burn_amplitude_label, 6, 0) features_layout.addWidget(burn_amplitude_edit, 6, 1) features_layout.addWidget(select_layers_button, 7, 0, 1, 2) self.__features_widget.setLayout(features_layout)
def __init_slicer_options_widget__(self): self.__slicer_options_widget = QGroupBox("Slicer Options", self) thickness_label = QLabel("Layer Thickness", self.__slicer_options_widget) thickness_edit = QDoubleSpinBox(self.__slicer_options_widget) thickness_edit.setSuffix(str('\u03BCm')) thickness_edit.setMaximum(1000000) thickness_edit.setMinimum(0) thickness_edit.setDecimals(3) thickness_edit.setSingleStep(0.001) thickness_edit.setValue(self.dlp_controller.support_thickness * 1000) # self.__opengl_widget.set_slice_thickness(self.dlp_controller.support_thickness) thickness_edit.valueChanged.connect( self.__slicer_widget.set_slice_thickness) pixel_size_label = QLabel("Projector Pixel Size", self.__slicer_options_widget) pixel_size_edit = QDoubleSpinBox(self.__slicer_options_widget) pixel_size_edit.setSuffix(str('\u03BCm')) pixel_size_edit.setMaximum(1000000) pixel_size_edit.setMinimum(0) pixel_size_edit.setDecimals(2) pixel_size_edit.setSingleStep(0.01) pixel_size_edit.setValue(self.dlp_controller.projector_pixel_size * 1000) pixel_size_edit.valueChanged.connect( self.__slicer_widget.set_pixel_size) projector_resolution_label = QLabel("Projector Resolution", self.__slicer_options_widget) projector_resolution_edit_x = QSpinBox(self.__slicer_options_widget) projector_resolution_edit_x.setSuffix(str('W')) projector_resolution_edit_x.setMaximum(1000000) projector_resolution_edit_x.setMinimum(0) projector_resolution_edit_x.setValue( self.dlp_controller.projector_width) projector_resolution_edit_x.valueChanged.connect( self.__slicer_widget.set_projector_width) projector_resolution_edit_y = QSpinBox(self.__slicer_options_widget) projector_resolution_edit_y.setSuffix(str('H')) projector_resolution_edit_y.setMaximum(1000000) projector_resolution_edit_y.setMinimum(0) projector_resolution_edit_y.setValue( self.dlp_controller.projector_height) projector_resolution_edit_y.valueChanged.connect( self.__slicer_widget.set_projector_height) samples_per_pixel_label = QLabel("Samples per Pixel", self.__slicer_options_widget) samples_per_pixel_edit = QSpinBox(self.__slicer_options_widget) samples_per_pixel_edit.setMaximum(1000000) samples_per_pixel_edit.setMinimum(1) samples_per_pixel_edit.setValue(self.dlp_controller.samples_per_pixel) samples_per_pixel_edit.valueChanged.connect( self.__slicer_widget.set_samples_per_pixel) slice_geometry_button = QPushButton("Slice Geometry") slice_geometry_button.clicked.connect(self.start_slicing_process) slice_interrupt_button = QPushButton("Stop Slicing") slice_interrupt_button.clicked.connect( self.__slicer_widget.interrupt_slicing) self.slices_label = QLabel(f'Slicing progress: {0:.0f}/{0:.0f}', self.__info_widget) thickness_label_row = 0 pixel_size_row = 1 projector_resolution_row = 2 samples_per_pixel_row = 3 slice_button_row = 4 slices_label_row = 5 # slice_interrupt_row = slice_button_row slice_layout = QGridLayout(self.__slicer_options_widget) slice_layout.addWidget(thickness_label, thickness_label_row, 0) slice_layout.addWidget(thickness_edit, thickness_label_row, 1) slice_layout.addWidget(pixel_size_label, pixel_size_row, 0) slice_layout.addWidget(pixel_size_edit, pixel_size_row, 1) slice_layout.addWidget(projector_resolution_label, projector_resolution_row, 0) slice_layout.addWidget(projector_resolution_edit_x, projector_resolution_row, 1) slice_layout.addWidget(projector_resolution_edit_y, projector_resolution_row, 2) slice_layout.addWidget(self.slices_label, slice_button_row, 0) slice_layout.addWidget(slice_geometry_button, slice_button_row, 1) slice_layout.addWidget(slice_interrupt_button, slice_button_row, 2) slice_layout.addWidget(samples_per_pixel_label, samples_per_pixel_row, 0) slice_layout.addWidget(samples_per_pixel_edit, samples_per_pixel_row, 1) self.__slicer_options_widget.setLayout(slice_layout)
class DLPSlicerGUI(QWidget): def __init__(self, dlp_controller=None, parent=None): QWidget.__init__(self, parent) if dlp_controller: self.dlp_controller = dlp_controller self.main_layout = QVBoxLayout() self.__init_slicer_widget__() self.__init_options_widget__() self.__options_widget.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Maximum) self.main_layout.addWidget(self.__slicer_widget) self.main_layout.addWidget(self.__options_widget) self.setLayout(self.main_layout) def __init_slicer_widget__(self): self.__slicer_widget = DLPSlicer(parent=self, dlp_controller=self.dlp_controller) self.__slicer_widget.update_physical_size.connect( self.update_size_label) self.__slicer_widget.update_fps.connect(self.update_fps_label) self.__slicer_widget.update_slice_counts.connect( self.update_slices_label) def __init_options_widget__(self): self.__options_widget = QWidget(self) self.__init_info_widget__() self.__init_geometry_widget__() self.__init_slicer_options_widget__() self.__options_layout = QGridLayout() self.__options_layout.addWidget(self.__info_widget, 0, 0, 1, 3) self.__options_layout.addWidget(self.__geometry_widget, 1, 0, 1, 2) self.__options_layout.addWidget(self.__slicer_options_widget, 1, 2) self.__options_widget.setLayout(self.__options_layout) def __init_info_widget__(self): self.__info_widget = QWidget(self) current_geometry_label = QLabel("Selected Geometry:", self.__info_widget) self.current_geometry_index = -1 self.geometry_list = MyQComboBox(self.__info_widget) self.geometry_list.currentIndexChanged.connect( self.update_geometry_transformations) self.fps_label = QLabel(f'fps: {0:.2f}', self.__info_widget) self.physical_size_label = QLabel( f'Width: {0:.2f} \u03BCm, Depth: {0:.2f} \u03BCm, Height: {0:.2f} \u03BCm', self.__info_widget) info_layout = QHBoxLayout() info_layout.addWidget(current_geometry_label) info_layout.addWidget(self.geometry_list) info_layout.addWidget(self.physical_size_label) info_layout.addWidget(self.fps_label) self.__info_widget.setLayout(info_layout) self.__info_widget.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Maximum) def __init_geometry_widget__(self): self.__geometry_widget = QGroupBox("Geometry", self) load_geometry_button = QPushButton("Load Geometry") load_geometry_button.clicked.connect(self.load_geometry) remove_geometry_button = QPushButton("Remove Geometry") remove_geometry_button.clicked.connect(self.remove_geometry) rotate_x_label = QLabel("Rotate X:", self.__geometry_widget) self.rotate_x_slider = QSlider(orientation=Qt.Horizontal, parent=self.__geometry_widget) self.rotate_x_slider.setTickPosition(QSlider.TicksBothSides) self.rotate_x_slider.setTickInterval(45) self.rotate_x_slider.setRange(-180, 180) self.rotate_x_slider.setValue(0) self.rotate_x_spin = QSpinBox(self.__geometry_widget) self.rotate_x_spin.setMinimum(-180) self.rotate_x_spin.setMaximum(180) self.rotate_x_spin.setValue(0) self.rotate_x_slider.valueChanged.connect(self.rotate_x_spin.setValue) self.rotate_x_slider.valueChanged.connect( self.__slicer_widget.set_x_rotation) self.rotate_x_spin.valueChanged.connect(self.rotate_x_slider.setValue) self.rotate_x_spin.valueChanged.connect( self.__slicer_widget.set_x_rotation) rotate_y_label = QLabel("Rotate Y:", self.__geometry_widget) self.rotate_y_slider = QSlider(orientation=Qt.Horizontal, parent=self.__geometry_widget) self.rotate_y_slider.setTickPosition(QSlider.TicksBothSides) self.rotate_y_slider.setTickInterval(45) self.rotate_y_slider.setRange(-180, 180) self.rotate_y_slider.setValue(0) self.rotate_y_spin = QSpinBox(self.__geometry_widget) self.rotate_y_spin.setMinimum(-180) self.rotate_y_spin.setMaximum(180) self.rotate_y_spin.setValue(0) self.rotate_y_slider.valueChanged.connect(self.rotate_y_spin.setValue) self.rotate_y_slider.valueChanged.connect( self.__slicer_widget.set_y_rotation) self.rotate_y_spin.valueChanged.connect(self.rotate_y_slider.setValue) self.rotate_y_spin.valueChanged.connect( self.__slicer_widget.set_y_rotation) rotate_z_label = QLabel("Rotate Z:", self.__geometry_widget) self.rotate_z_slider = QSlider(orientation=Qt.Horizontal, parent=self.__geometry_widget) self.rotate_z_slider.setTickPosition(QSlider.TicksBothSides) self.rotate_z_slider.setTickInterval(45) self.rotate_z_slider.setRange(-180, 180) self.rotate_z_slider.setValue(0) self.rotate_z_spin = QSpinBox(self.__geometry_widget) self.rotate_z_spin.setMinimum(-180) self.rotate_z_spin.setMaximum(180) self.rotate_z_spin.setValue(0) self.rotate_z_slider.valueChanged.connect(self.rotate_z_spin.setValue) self.rotate_z_slider.valueChanged.connect( self.__slicer_widget.set_z_rotation) self.rotate_z_spin.valueChanged.connect(self.rotate_z_slider.setValue) self.rotate_z_spin.valueChanged.connect( self.__slicer_widget.set_z_rotation) translate_x_label = QLabel("Translate X:", self.__geometry_widget) self.translate_x_slider = QSlider(orientation=Qt.Horizontal, parent=self.__geometry_widget) self.translate_x_slider.setTickPosition(QSlider.TicksBothSides) self.translate_x_slider.setTickInterval( self.dlp_controller.projector_pixel_size) self.translate_x_slider.setRange( -self.dlp_controller.projector_width * self.dlp_controller.projector_pixel_size * 0.5, self.dlp_controller.projector_width * self.dlp_controller.projector_pixel_size * 0.5) self.translate_x_slider.setValue(0) self.translate_x_spin = QDoubleSpinBox(self.__geometry_widget) self.translate_x_spin.setMinimum( -self.dlp_controller.projector_width * self.dlp_controller.projector_pixel_size * 0.5) self.translate_x_spin.setMaximum( self.dlp_controller.projector_width * self.dlp_controller.projector_pixel_size * 0.5) self.translate_x_spin.setSingleStep( self.dlp_controller.projector_pixel_size) self.translate_x_spin.setValue(0) self.translate_x_slider.valueChanged.connect( self.translate_x_spin.setValue) self.translate_x_slider.valueChanged.connect( self.__slicer_widget.set_x_pos) self.translate_x_spin.valueChanged.connect( self.translate_x_slider.setValue) self.translate_x_spin.valueChanged.connect( self.__slicer_widget.set_x_pos) translate_z_label = QLabel("Translate Z:", self.__geometry_widget) self.translate_z_slider = QSlider(orientation=Qt.Horizontal, parent=self.__geometry_widget) self.translate_z_slider.setTickPosition(QSlider.TicksBothSides) self.translate_z_slider.setTickInterval( self.dlp_controller.projector_pixel_size) self.translate_z_slider.setRange( -self.dlp_controller.projector_height * self.dlp_controller.projector_pixel_size * 0.5, self.dlp_controller.projector_height * self.dlp_controller.projector_pixel_size * 0.5) self.translate_z_slider.setValue(0) self.translate_z_spin = QDoubleSpinBox(self.__geometry_widget) self.translate_z_spin.setMinimum( -self.dlp_controller.projector_height * self.dlp_controller.projector_pixel_size * 0.5) self.translate_z_spin.setMaximum( self.dlp_controller.projector_height * self.dlp_controller.projector_pixel_size * 0.5) self.translate_z_spin.setSingleStep( self.dlp_controller.projector_pixel_size) self.translate_z_spin.setValue(0) self.translate_z_slider.valueChanged.connect( self.translate_z_spin.setValue) self.translate_z_slider.valueChanged.connect( self.__slicer_widget.set_z_pos) self.translate_z_spin.valueChanged.connect( self.translate_z_slider.setValue) self.translate_z_spin.valueChanged.connect( self.__slicer_widget.set_z_pos) scale_x_label = QLabel("Scale X:", self.__geometry_widget) self.scale_x_spin = QDoubleSpinBox(self.__geometry_widget) self.scale_x_spin.setMinimum(-1000) self.scale_x_spin.setMaximum(1000) self.scale_x_spin.setDecimals(2) self.scale_x_spin.setValue(1) self.scale_x_spin.setSingleStep(0.01) self.scale_x_spin.setObjectName("scale_x_spin") self.scale_x_spin.valueChanged.connect(self.set_scaling) scale_y_label = QLabel("Scale Y:", self.__geometry_widget) self.scale_y_spin = QDoubleSpinBox(self.__geometry_widget) self.scale_y_spin.setMinimum(-1000) self.scale_y_spin.setMaximum(1000) self.scale_y_spin.setDecimals(2) self.scale_y_spin.setValue(1) self.scale_y_spin.setSingleStep(0.01) self.scale_y_spin.setObjectName("scale_y_spin") self.scale_y_spin.valueChanged.connect(self.set_scaling) scale_z_label = QLabel("Scale Z:", self.__geometry_widget) self.scale_z_spin = QDoubleSpinBox(self.__geometry_widget) self.scale_z_spin.setMinimum(-1000) self.scale_z_spin.setMaximum(1000) self.scale_z_spin.setDecimals(2) self.scale_z_spin.setValue(1) self.scale_z_spin.setSingleStep(0.01) self.scale_z_spin.setObjectName("scale_z_spin") self.scale_z_spin.valueChanged.connect(self.set_scaling) self.uniform_scaling = QCheckBox("Uniform Scaling", self.__geometry_widget) self.uniform_scaling.setChecked(True) # self.uniform_scaling.setLayoutDirection(Qt.RightToLeft) list_of_measures = ('\u03BCm', 'mm', 'cm', 'dm', 'm') self.list_of_measures_coefficients = [0.001, 1, 10, 100, 1000] unit_of_measure_label = QLabel("Unit of Measure", self.__geometry_widget) self.unit_of_measure_combo = QComboBox(self.__geometry_widget) for measure in list_of_measures: self.unit_of_measure_combo.addItem(measure) self.unit_of_measure_combo.setCurrentIndex(1) self.unit_of_measure_combo.currentIndexChanged.connect( self.update_unit_of_measure) rotate_x_row = 0 rotate_y_row = rotate_x_row + 1 rotate_z_row = rotate_y_row + 1 translate_x_row = rotate_z_row + 1 translate_z_row = translate_x_row + 1 scale_x_row = translate_z_row + 1 scale_y_row = scale_x_row + 1 scale_z_row = scale_y_row + 1 uniform_scaling_row = scale_x_row unit_of_measure_row = scale_y_row load_geometry_row = scale_z_row + 1 remove_geometry_row = load_geometry_row geometry_layout = QGridLayout(self.__geometry_widget) geometry_layout.addWidget(load_geometry_button, load_geometry_row, 1, 1, 2) geometry_layout.addWidget(remove_geometry_button, remove_geometry_row, 3, 1, 2) geometry_layout.addWidget(rotate_x_label, rotate_x_row, 0) geometry_layout.addWidget(self.rotate_x_slider, rotate_x_row, 1, 1, 4) geometry_layout.addWidget(self.rotate_x_spin, rotate_x_row, 5) geometry_layout.addWidget(rotate_y_label, rotate_y_row, 0) geometry_layout.addWidget(self.rotate_y_slider, rotate_y_row, 1, 1, 4) geometry_layout.addWidget(self.rotate_y_spin, rotate_y_row, 5) geometry_layout.addWidget(rotate_z_label, rotate_z_row, 0) geometry_layout.addWidget(self.rotate_z_slider, rotate_z_row, 1, 1, 4) geometry_layout.addWidget(self.rotate_z_spin, rotate_z_row, 5) geometry_layout.addWidget(translate_x_label, translate_x_row, 0) geometry_layout.addWidget(self.translate_x_slider, translate_x_row, 1, 1, 4) geometry_layout.addWidget(self.translate_x_spin, translate_x_row, 5) geometry_layout.addWidget(translate_z_label, translate_z_row, 0) geometry_layout.addWidget(self.translate_z_slider, translate_z_row, 1, 1, 4) geometry_layout.addWidget(self.translate_z_spin, translate_z_row, 5) geometry_layout.addWidget(scale_x_label, scale_x_row, 0) geometry_layout.addWidget(self.scale_x_spin, scale_x_row, 1) geometry_layout.addWidget(scale_y_label, scale_y_row, 0) geometry_layout.addWidget(self.scale_y_spin, scale_y_row, 1) geometry_layout.addWidget(scale_z_label, scale_z_row, 0) geometry_layout.addWidget(self.scale_z_spin, scale_z_row, 1) geometry_layout.addWidget(self.uniform_scaling, uniform_scaling_row, 3, 1, 2) geometry_layout.addWidget(unit_of_measure_label, unit_of_measure_row, 4) geometry_layout.addWidget(self.unit_of_measure_combo, unit_of_measure_row, 3) self.__geometry_widget.setLayout(geometry_layout) def __init_slicer_options_widget__(self): self.__slicer_options_widget = QGroupBox("Slicer Options", self) thickness_label = QLabel("Layer Thickness", self.__slicer_options_widget) thickness_edit = QDoubleSpinBox(self.__slicer_options_widget) thickness_edit.setSuffix(str('\u03BCm')) thickness_edit.setMaximum(1000000) thickness_edit.setMinimum(0) thickness_edit.setDecimals(3) thickness_edit.setSingleStep(0.001) thickness_edit.setValue(self.dlp_controller.support_thickness * 1000) # self.__opengl_widget.set_slice_thickness(self.dlp_controller.support_thickness) thickness_edit.valueChanged.connect( self.__slicer_widget.set_slice_thickness) pixel_size_label = QLabel("Projector Pixel Size", self.__slicer_options_widget) pixel_size_edit = QDoubleSpinBox(self.__slicer_options_widget) pixel_size_edit.setSuffix(str('\u03BCm')) pixel_size_edit.setMaximum(1000000) pixel_size_edit.setMinimum(0) pixel_size_edit.setDecimals(2) pixel_size_edit.setSingleStep(0.01) pixel_size_edit.setValue(self.dlp_controller.projector_pixel_size * 1000) pixel_size_edit.valueChanged.connect( self.__slicer_widget.set_pixel_size) projector_resolution_label = QLabel("Projector Resolution", self.__slicer_options_widget) projector_resolution_edit_x = QSpinBox(self.__slicer_options_widget) projector_resolution_edit_x.setSuffix(str('W')) projector_resolution_edit_x.setMaximum(1000000) projector_resolution_edit_x.setMinimum(0) projector_resolution_edit_x.setValue( self.dlp_controller.projector_width) projector_resolution_edit_x.valueChanged.connect( self.__slicer_widget.set_projector_width) projector_resolution_edit_y = QSpinBox(self.__slicer_options_widget) projector_resolution_edit_y.setSuffix(str('H')) projector_resolution_edit_y.setMaximum(1000000) projector_resolution_edit_y.setMinimum(0) projector_resolution_edit_y.setValue( self.dlp_controller.projector_height) projector_resolution_edit_y.valueChanged.connect( self.__slicer_widget.set_projector_height) samples_per_pixel_label = QLabel("Samples per Pixel", self.__slicer_options_widget) samples_per_pixel_edit = QSpinBox(self.__slicer_options_widget) samples_per_pixel_edit.setMaximum(1000000) samples_per_pixel_edit.setMinimum(1) samples_per_pixel_edit.setValue(self.dlp_controller.samples_per_pixel) samples_per_pixel_edit.valueChanged.connect( self.__slicer_widget.set_samples_per_pixel) slice_geometry_button = QPushButton("Slice Geometry") slice_geometry_button.clicked.connect(self.start_slicing_process) slice_interrupt_button = QPushButton("Stop Slicing") slice_interrupt_button.clicked.connect( self.__slicer_widget.interrupt_slicing) self.slices_label = QLabel(f'Slicing progress: {0:.0f}/{0:.0f}', self.__info_widget) thickness_label_row = 0 pixel_size_row = 1 projector_resolution_row = 2 samples_per_pixel_row = 3 slice_button_row = 4 slices_label_row = 5 # slice_interrupt_row = slice_button_row slice_layout = QGridLayout(self.__slicer_options_widget) slice_layout.addWidget(thickness_label, thickness_label_row, 0) slice_layout.addWidget(thickness_edit, thickness_label_row, 1) slice_layout.addWidget(pixel_size_label, pixel_size_row, 0) slice_layout.addWidget(pixel_size_edit, pixel_size_row, 1) slice_layout.addWidget(projector_resolution_label, projector_resolution_row, 0) slice_layout.addWidget(projector_resolution_edit_x, projector_resolution_row, 1) slice_layout.addWidget(projector_resolution_edit_y, projector_resolution_row, 2) slice_layout.addWidget(self.slices_label, slice_button_row, 0) slice_layout.addWidget(slice_geometry_button, slice_button_row, 1) slice_layout.addWidget(slice_interrupt_button, slice_button_row, 2) slice_layout.addWidget(samples_per_pixel_label, samples_per_pixel_row, 0) slice_layout.addWidget(samples_per_pixel_edit, samples_per_pixel_row, 1) self.__slicer_options_widget.setLayout(slice_layout) @Slot(float) def set_scaling(self, value): if self.uniform_scaling.isChecked(): self.__slicer_widget.set_x_scale(value) self.__slicer_widget.set_y_scale(value) self.__slicer_widget.set_z_scale(value) self.scale_x_spin.setValue(value) self.scale_y_spin.setValue(value) self.scale_z_spin.setValue(value) else: self.__slicer_widget.set_x_scale(self.scale_x_spin.value()) self.__slicer_widget.set_y_scale(self.scale_y_spin.value()) self.__slicer_widget.set_z_scale(self.scale_z_spin.value()) @Slot() def load_geometry(self): file_names = QFileDialog.getOpenFileNames(caption='Select Geometry', dir='../', filter="Files (*.obj *.stl)", parent=self) loading_dialog = QMessageBox() loading_dialog.setText("Loading Geometry...") loading_dialog.setWindowTitle("AMLab Software") loading_dialog.setStandardButtons(QMessageBox.NoButton) loading_dialog.open() QGuiApplication.processEvents() swapyz = True for file_name in file_names[0]: if self.__slicer_widget.load_geometry(file_name, swapyz): self.geometry_list.addItem( self.__slicer_widget.geometry_name_list[ self.__slicer_widget.geometries_loaded - 1]) self.geometry_list.setCurrentIndex(self.geometry_list.count() - 1) QGuiApplication.processEvents() @Slot() def remove_geometry(self): self.__slicer_widget.remove_geometry() self.geometry_list.removeItem(self.geometry_list.currentIndex()) @Slot() def start_slicing_process(self): directory_name = QFileDialog.getExistingDirectory( caption='Select Directory', dir='../', parent=self) if len(directory_name) > 0: self.__slicer_widget.prepare_for_slicing(directory=directory_name) @Slot(float, float, float) def update_size_label(self, width, depth, height): self.physical_size_label.setText( f'Width: {width:.3f} mm, Depth: {depth:.3f} mm, Height: {height:.3f} mm' ) @Slot(float) def update_fps_label(self, fps): self.fps_label.setText(f'fps: {fps:.2f}') @Slot(float, float) def update_slices_label(self, slice, total_slices): self.slices_label.setText( f'Slicing progress: {slice:.0f}/{total_slices:.0f}') @Slot(int) def update_unit_of_measure(self, index): self.__slicer_widget.set_unit_of_measurement( self.list_of_measures_coefficients[index]) @Slot(int) def update_geometry_transformations(self, index): if index >= 0: self.__slicer_widget.current_geometry_idx = index x_rot = self.__slicer_widget.get_x_rot() y_rot = self.__slicer_widget.get_y_rot() z_rot = self.__slicer_widget.get_z_rot() x_scale = self.__slicer_widget.get_x_scale() y_scale = self.__slicer_widget.get_y_scale() z_scale = self.__slicer_widget.get_z_scale() x_pos = self.__slicer_widget.get_x_pos() z_pos = self.__slicer_widget.get_z_pos() unit_measurement = self.__slicer_widget.get_unit_of_measurement() self.__geometry_widget.blockSignals(True) self.rotate_x_slider.setValue(x_rot) self.rotate_x_spin.setValue(x_rot) self.rotate_y_slider.setValue(y_rot) self.rotate_y_spin.setValue(y_rot) self.rotate_z_slider.setValue(z_rot) self.rotate_z_spin.setValue(z_rot) self.translate_x_slider.setValue(x_pos) self.translate_x_spin.setValue(x_pos) self.translate_z_slider.setValue(z_pos) self.translate_z_spin.setValue(z_pos) self.scale_x_spin.setValue(x_scale) self.scale_y_spin.setValue(y_scale) self.scale_z_spin.setValue(z_scale) self.unit_of_measure_combo.setCurrentIndex( self.list_of_measures_coefficients.index(unit_measurement)) self.__geometry_widget.blockSignals(False)
class NifBatchTools(MainWindow): def __init__(self): super().__init__("HTools - NifBatchTools") log.info("Opening NifBatchTools window") self.source_folder = CONFIG.get("DEFAULT", "SourceFolder") self.keywords = list( map(lambda x: x.encode("ascii"), CONFIG.get("NIF", "keywords").replace(" ", "").split(","))) self.nif_files = set( ) # improve performance (better to check in a set rather than in a QListWidget self.ignored_nif_files = set( ) # improve performance (better to check in a set rather than in a QListWidget self.setSize(QSize(700, 600)) self.processed_files = itertools.count() log.info("Source folder : " + self.source_folder) log.info("Keywords : " + str(self.keywords)) self.init_ui() def init_ui(self): main_splitter = QSplitter(self, Qt.Horizontal) left_pane = QWidget(self) left_pane.setMaximumWidth(370) left_v_box = QVBoxLayout(self) left_pane.setLayout(left_v_box) right_pane = QWidget(self) right_v_box = QVBoxLayout(self) right_pane.setLayout(right_v_box) main_splitter.addWidget(left_pane) main_splitter.addWidget(right_pane) # ===== Details ===== self.group_box_details = QuickyGui.create_group_box(self, "Details") nif_files_loaded = QuickyGui.create_label(self, ".nif files loaded") self.lcd_nif_files_loaded = QuickyGui.create_lcd(self) nif_files_ignored = QuickyGui.create_label(self, ".nif files ignored") self.lcd_nif_files_ignored = QuickyGui.create_lcd(self) self.nif_files_list_widget = NifList(self) self.ignored_nif_files_list_widget = NifList(self) self.update_nif_files() self.group_box_legends = QuickyGui.create_group_box(self, "Legends") instructions_4 = QuickyGui.create_label( self, "Green - File correctly processed\n") instructions_4.setStyleSheet( "QLabel { color : darkGreen; font-weight : bold }") instructions_5 = QuickyGui.create_label(self, "Blue - File is processing\n") instructions_5.setStyleSheet( "QLabel { color : darkBlue; font-weight : bold }") instructions_6 = QuickyGui.create_label( self, "Red - File ignored/with errors.") instructions_6.setStyleSheet( "QLabel { color : darkRed; font-weight : bold }") instructions_7 = QuickyGui.create_label( self, "Reasons : " "\n * Check log to see if there is an error concerning this file, or try to open it with NifSkope" "\n * Otherwise it couldn't find a NiTriShape block whose name is specified in provided keywords. It may be normal, if there is no body part. But if there is and you want this file to be processed by the tool, then you must add the corresponding NiTriShape block's name (use nikskope to find it) to the list of keywords, located in the .ini file, situated alongside the executable." " If you have Nikskope, you can open the file by double-clicking on in, in the list view, or from your explorer. Restart the tool to load the new .ini file." ) instructions_7.setStyleSheet("QLabel { color : darkRed}") vbox = QVBoxLayout() vbox.setSpacing(5) vbox.addWidget(instructions_4) vbox.addWidget(instructions_5) vbox.addWidget(instructions_6) vbox.addWidget(instructions_7) self.group_box_legends.setLayout(vbox) vbox = QVBoxLayout(self) hbox = QHBoxLayout(self) hbox.addWidget(nif_files_loaded) hbox.addWidget(self.lcd_nif_files_loaded) vbox.addItem(hbox) vbox.addWidget(self.nif_files_list_widget) hbox = QHBoxLayout(self) hbox.addWidget(nif_files_ignored) hbox.addWidget(self.lcd_nif_files_ignored) vbox.addItem(hbox) vbox.addWidget(self.ignored_nif_files_list_widget) vbox.addWidget(self.group_box_legends) self.group_box_details.setLayout(vbox) right_v_box.addWidget(self.group_box_details) # ===== STEP 0 - Instructions ===== self.group_box_instructions = QuickyGui.create_group_box( self, "Instructions") instructions_1 = QuickyGui.create_label( self, "I. By clicking on \"Scan Folder\", all .nif contained in this folder (subfolders and so on), will be added to the set of files to be processed. You can scan multiple folder, by clicking again. All files not already present will be added." ) instructions_2 = QuickyGui.create_label( self, "II. Once your desired parameters are set, click on \"Apply\". Bewary, the process is quite slow (just opening the file is quite consuming somehow)" ) vbox = QVBoxLayout() vbox.setSpacing(5) vbox.addWidget(instructions_1) vbox.addWidget(instructions_2) self.group_box_instructions.setLayout(vbox) left_v_box.addWidget(self.group_box_instructions) # ===== STEP I - Load Files ===== self.group_box_load_files = QuickyGui.create_group_box( self, "STEP I - Load .nif files") button_load_files = QuickyGui.create_button(self, "Scan Folder", self.action_load_files) button_clear_files = QuickyGui.create_button(self, "Clear loaded files", self.action_clear_files) hbox = QHBoxLayout() hbox.addWidget(button_load_files) hbox.addWidget(button_clear_files) self.group_box_load_files.setLayout(hbox) left_v_box.addWidget(self.group_box_load_files) # ===== STEP II - Set parameters ===== self.group_box_parameters = QuickyGui.create_group_box( self, "STEP II - Set parameters") vbox = QVBoxLayout() # Glossiness label_glossiness = QuickyGui.create_label(self, "Glossiness") self.spin_box_glossiness = QDoubleSpinBox() self.spin_box_glossiness.setMinimum(0) self.spin_box_glossiness.setMaximum(1000) self.spin_box_glossiness.setValue(CONFIG.getfloat("NIF", "Glossiness")) log.info("Glossiness target : " + str(self.spin_box_glossiness.value())) hbox = QHBoxLayout() hbox.addWidget(label_glossiness) hbox.addWidget(self.spin_box_glossiness) vbox.addItem(hbox) # Specular Strength label_specular_strength = QuickyGui.create_label( self, "Specular Strength") self.spin_box_specular_strength = QDoubleSpinBox() self.spin_box_specular_strength.setMinimum(0) self.spin_box_specular_strength.setMaximum(1000) self.spin_box_specular_strength.setValue( CONFIG.getfloat("NIF", "SpecularStrength")) log.info("Specular Strength target : " + str(self.spin_box_specular_strength.value())) hbox = QHBoxLayout() hbox.addWidget(label_specular_strength) hbox.addWidget(self.spin_box_specular_strength) vbox.addItem(hbox) self.group_box_parameters.setLayout(vbox) left_v_box.addWidget(self.group_box_parameters) # ===== STEP III - Apply ===== self.group_box_apply = QuickyGui.create_group_box( self, "STEP III - Apply") button_load_files = QuickyGui.create_button(self, "Apply", self.action_apply) hbox = QHBoxLayout() hbox.addWidget(button_load_files) self.group_box_apply.setLayout(hbox) left_v_box.addWidget(self.group_box_apply) # ===== Finalizing ===== self.progress_bar = QProgressBar(self) left_v_box.addWidget(self.progress_bar) left_v_box.setSpacing(10) self.mainLayout.addWidget(main_splitter) def toggle(self, value): self.group_box_parameters.setEnabled(value) self.group_box_load_files.setEnabled(value) self.group_box_apply.setEnabled(value) def update_nif_files(self, value=0): self.lcd_nif_files_loaded.display(self.nif_files_list_widget.count()) self.lcd_nif_files_ignored.display( self.ignored_nif_files_list_widget.count()) self.nif_files_list_widget.sortItems() self.ignored_nif_files_list_widget.sortItems() def finish_action(self): self.progress_bar.setMinimum(0) self.progress_bar.setMaximum(max(1, self.nif_files_list_widget.count())) self.progress_bar.setValue(self.nif_files_list_widget.count()) self.toggle(True) log.info("Done !") def finish_load_action(self, result): self.finish_action() QMessageBox.information( self, "Results", "Done !\n\n" + str(self.nif_files_list_widget.count()) + " .nif file(s) loaded.\n" + str(result) + " .nif files ignored.") def start_apply_action(self, index): item = self.nif_files_list_widget.item(index) item.setForeground(Qt.blue) def result_apply_action(self, index, result): item = self.nif_files_list_widget.item(index) if result: item.setForeground(Qt.darkGreen) else: item.setForeground(Qt.darkRed) self.progress_bar.setValue(next(self.processed_files) + 1) def finish_apply_action(self): if self.progress_bar.value() == self.nif_files_list_widget.count(): self.finish_action() QMessageBox.information( self, "Results", "Done !\n\n" + str(self.progress_bar.value()) + " .nif file(s) loaded.\n") def action_clear_files(self): log.info("Clearing loaded .nif files ...") self.nif_files_list_widget.clear() self.ignored_nif_files_list_widget.clear() self.nif_files.clear() self.ignored_nif_files.clear() self.update_nif_files() self.progress_bar.reset() def action_load_files(self): log.info("Loading .nif files ...") self.toggle(False) self.progress_bar.setMinimum(0) self.progress_bar.setMaximum(0) file_dialog = QFileDialog() file_dialog.setFileMode(QFileDialog.DirectoryOnly) file_dialog.setDirectory(self.source_folder) if file_dialog.exec_(): scan_dirs = file_dialog.selectedFiles() if len(scan_dirs) >= 1: self.source_folder = scan_dirs[0] else: self.source_folder = file_dialog.directory() if self.source_folder: log.info("Scanning directory : " + self.source_folder) CONFIG.set("DEFAULT", "SourceFolder", self.source_folder), save_config() worker = Worker(self.load_files) worker.signals.progress.connect(self.update_nif_files) worker.signals.result.connect(self.finish_load_action) QThreadPool.globalInstance().start(worker) def load_files(self, progress_callback): """ Traverse folder to find .nif files """ ignored_files = 0 for root, dirs, files in os.walk(self.source_folder): for file in files: path = root + "/" + file if file.endswith( ".nif" ) and path not in self.nif_files and path not in self.ignored_nif_files: stream = open(path, "rb") data = NifFormat.Data() success = False add_to_ignored_list = False try: data.inspect(stream) if "NiNode".encode( 'ascii') == data.header.block_types[0]: if any(keyword in self.keywords for keyword in data.header.strings): success = True else: add_to_ignored_list = True except ValueError: log.exception("[" + file + "] - Too Big to inspect - skipping") except Exception: log.exception("[" + file + "] - Error") finally: if success: self.nif_files.add(path) self.nif_files_list_widget.addItem(path) elif add_to_ignored_list: item = QListWidgetItem( path, self.ignored_nif_files_list_widget) item.setForeground(Qt.darkRed) ignored_files += 1 progress_callback.emit(0) # emit parameter is not used return ignored_files def action_apply(self): """ Apply parameters to relevant .nif files """ if self.nif_files_list_widget.count() == 0: QMessageBox.warning(self, "No .nif files loaded", "Don't forget to load .nif files !") return if self.nif_files_list_widget.count() >= get_config().getint( "DEFAULT", "softLimit"): box = QMessageBox() box.setIcon(QMessageBox.Question) box.setWindowTitle('Are you sure ?') box.setText( "The tool may struggle with more than 100 .nif files at once. We advise you to process small batches.\n\nAre you sure you wish to continue ?" ) box.setStandardButtons(QMessageBox.Yes | QMessageBox.No) buttonY = box.button(QMessageBox.Yes) buttonY.setText('Yes') buttonN = box.button(QMessageBox.No) buttonN.setText('No') box.exec_() if box.clickedButton() == buttonN: return log.info("Applying parameters to " + str(self.nif_files_list_widget.count()) + " files ...") self.toggle(False) self.progress_bar.setValue(0) self.processed_files = itertools.count() CONFIG.set("NIF", "Glossiness", str(self.spin_box_glossiness.value())), CONFIG.set("NIF", "SpecularStrength", str(self.spin_box_specular_strength.value())), save_config() QMessageBox.warning( self, "Attention !", "The process is quite slow.\n\nThe gui will be mostly unresponsive to your input. Don't close the application, unless the completion pourcentage has not been updated in a long time (several minutes).\nIt took me 13 minutes to process 100 files for example." ) #for indices in chunkify(range(self.nif_files_list_widget.count()), QThreadPool.globalInstance().maxThreadCount()-1): QThreadPool.globalInstance().setExpiryTimeout(-1) for index in range(self.nif_files_list_widget.count()): item = self.nif_files_list_widget.item(index) worker = NifProcessWorker( index=index, path=item.text(), keywords=self.keywords, glossiness=self.spin_box_glossiness.value(), specular_strength=self.spin_box_specular_strength.value()) worker.signals.start.connect(self.start_apply_action) worker.signals.result.connect(self.result_apply_action) worker.signals.finished.connect(self.finish_apply_action) QThreadPool.globalInstance().start(worker)
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 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 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)
def __init_advanced_features_widget__(self, parent=None): self.__advanced_widget = QGroupBox("Advanced Features Options", parent) fixed_layer_check = QCheckBox("Fixed Layer", self.__advanced_widget) fixed_layer_check.setChecked(self.dlp_controller.fixed_layer) fixed_layer_check.toggled.connect(self.dlp_controller.set_fixed_layer) incremental_amplitude_check = QCheckBox("Incremental Amplitude", self.__advanced_widget) incremental_amplitude_check.setChecked( self.dlp_controller.incremental_amplitude) incremental_amplitude_check.toggled.connect( self.dlp_controller.set_incremental_amplitude) starting_amplitude_label = QLabel("Starting Amplitude", self.__advanced_widget) starting_amplitude_edit = QSpinBox(self.__advanced_widget) starting_amplitude_edit.setMaximum(1000) starting_amplitude_edit.setMinimum(0) starting_amplitude_edit.setSingleStep(1) starting_amplitude_edit.setValue( self.dlp_controller.starting_incremental_amplitude) starting_amplitude_edit.valueChanged.connect( self.dlp_controller.set_starting_incremental_amplitude) amplitude_step_label = QLabel("Step Size", self.__advanced_widget) amplitude_step_edit = QSpinBox(self.__advanced_widget) amplitude_step_edit.setMaximum(1000) amplitude_step_edit.setMinimum(0) amplitude_step_edit.setSingleStep(1) amplitude_step_edit.setValue( self.dlp_controller.incremental_step_amplitude) amplitude_step_edit.valueChanged.connect( self.dlp_controller.set_incremental_step_amplitude) incremental_exposure_check = QCheckBox("Incremental Exposure", self.__advanced_widget) incremental_exposure_check.setChecked( self.dlp_controller.incremental_exposure) incremental_exposure_check.toggled.connect( self.dlp_controller.set_incremental_exposure) starting_exposure_label = QLabel("Starting Exposure", self.__advanced_widget) starting_exposure_edit = QDoubleSpinBox(self.__advanced_widget) starting_exposure_edit.setSuffix(str('ms')) starting_exposure_edit.setMaximum(100000) starting_exposure_edit.setMinimum(0) starting_exposure_edit.setDecimals(1) starting_exposure_edit.setSingleStep(0.1) starting_exposure_edit.valueChanged.connect( self.dlp_controller.set_starting_incremental_exposure) starting_exposure_edit.setValue( self.dlp_controller.starting_incremental_exposure) exposure_step_label = QLabel("Step Size", self.__advanced_widget) exposure_step_edit = QDoubleSpinBox(self.__advanced_widget) exposure_step_edit.setSuffix(str('ms')) exposure_step_edit.setMaximum(100000) exposure_step_edit.setMinimum(0) exposure_step_edit.setDecimals(1) exposure_step_edit.setSingleStep(0.1) exposure_step_edit.valueChanged.connect( self.dlp_controller.set_incremental_step_exposure) exposure_step_edit.setValue( self.dlp_controller.incremental_step_exposure) incremental_thickness_check = QCheckBox("Incremental Thickness", self.__advanced_widget) incremental_thickness_check.setChecked( self.dlp_controller.incremental_thickness) incremental_thickness_check.toggled.connect( self.dlp_controller.set_incremental_thickness) thickness_label = QLabel("Starting Thickness", self.__features_widget) self.starting_thickness_edit = MyDiscreteStepsSpinBox( self.dlp_controller.get_step_length_microns(), self.__features_widget) self.starting_thickness_edit.setSuffix(str('\u03BCm')) self.starting_thickness_edit.setMaximum(1000000) self.starting_thickness_edit.setMinimum(0) self.starting_thickness_edit.setDecimals(3) self.starting_thickness_edit.my_value_changed_signal.connect( self.dlp_controller.set_starting_incremental_thickness) self.starting_thickness_edit.setValue( self.dlp_controller.starting_incremental_thickness * 1000) thickness_step_label = QLabel("Step Size", self.__features_widget) self.thickness_step_edit = MyDiscreteStepsSpinBox( self.dlp_controller.get_step_length_microns(), self.__features_widget) self.thickness_step_edit.setSuffix(str('\u03BCm')) self.thickness_step_edit.setMaximum(1000000) self.thickness_step_edit.setMinimum(0) self.thickness_step_edit.setDecimals(3) self.thickness_step_edit.my_value_changed_signal.connect( self.dlp_controller.set_incremental_step_thickness) self.thickness_step_edit.setValue( self.dlp_controller.incremental_step_thickness * 1000) apply_grayscale_correction_check = QCheckBox("Grayscale Correction", self.__advanced_widget) apply_grayscale_correction_check.setChecked( self.dlp_controller.grayscale_correction) apply_grayscale_correction_check.toggled.connect( self.dlp_controller.set_grayscale_correction) grayscale_parameters_widget = QWidget(self.__features_widget) a_parameter_label = QLabel("\u03B1", grayscale_parameters_widget) alpha_parameter_edit = QDoubleSpinBox(grayscale_parameters_widget) alpha_parameter_edit.setMaximum(1000) alpha_parameter_edit.setMinimum(0) alpha_parameter_edit.setDecimals(3) alpha_parameter_edit.setSingleStep(0.001) alpha_parameter_edit.valueChanged.connect( self.dlp_controller.set_grayscale_alpha) alpha_parameter_edit.setValue(self.dlp_controller.grayscale_alpha) beta_parameter_label = QLabel("\u03B2", grayscale_parameters_widget) beta_parameter_edit = QDoubleSpinBox(grayscale_parameters_widget) beta_parameter_edit.setMaximum(1000) beta_parameter_edit.setMinimum(0) beta_parameter_edit.setDecimals(3) beta_parameter_edit.setSingleStep(0.001) beta_parameter_edit.valueChanged.connect( self.dlp_controller.set_grayscale_beta) beta_parameter_edit.setValue(self.dlp_controller.grayscale_beta) gamma_parameter_label = QLabel("\u03B3", grayscale_parameters_widget) gamma_parameter_edit = QDoubleSpinBox(grayscale_parameters_widget) gamma_parameter_edit.setMaximum(1000) gamma_parameter_edit.setMinimum(0) gamma_parameter_edit.setDecimals(3) gamma_parameter_edit.setSingleStep(0.001) gamma_parameter_edit.valueChanged.connect( self.dlp_controller.set_grayscale_gamma) gamma_parameter_edit.setValue(self.dlp_controller.grayscale_gamma) grayscale_parameters_layout = QHBoxLayout(grayscale_parameters_widget) grayscale_parameters_layout.addWidget(a_parameter_label) grayscale_parameters_layout.addWidget(alpha_parameter_edit) grayscale_parameters_layout.addWidget(beta_parameter_label) grayscale_parameters_layout.addWidget(beta_parameter_edit) grayscale_parameters_layout.addWidget(gamma_parameter_label) grayscale_parameters_layout.addWidget(gamma_parameter_edit) grayscale_parameters_widget.setLayout(grayscale_parameters_layout) advanced_features_layout = QGridLayout(self.__advanced_widget) advanced_features_layout.addWidget(incremental_amplitude_check, 1, 0, 1, 2) advanced_features_layout.addWidget(fixed_layer_check, 1, 3) advanced_features_layout.addWidget(starting_amplitude_label, 2, 0) advanced_features_layout.addWidget(starting_amplitude_edit, 2, 1) advanced_features_layout.addWidget(amplitude_step_label, 2, 2) advanced_features_layout.addWidget(amplitude_step_edit, 2, 3) advanced_features_layout.addWidget(incremental_exposure_check, 3, 0, 1, 2) advanced_features_layout.addWidget(starting_exposure_label, 4, 0) advanced_features_layout.addWidget(starting_exposure_edit, 4, 1) advanced_features_layout.addWidget(exposure_step_label, 4, 2) advanced_features_layout.addWidget(exposure_step_edit, 4, 3) advanced_features_layout.addWidget(incremental_thickness_check, 5, 0, 1, 2) advanced_features_layout.addWidget(thickness_label, 6, 0) advanced_features_layout.addWidget(self.starting_thickness_edit, 6, 1) advanced_features_layout.addWidget(thickness_step_label, 6, 2) advanced_features_layout.addWidget(self.thickness_step_edit, 6, 3) advanced_features_layout.addWidget(apply_grayscale_correction_check, 7, 0, 1, 2) advanced_features_layout.addWidget(grayscale_parameters_widget, 8, 0, 1, 4) self.__advanced_widget.setLayout(advanced_features_layout)
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 App(QMainWindow): def __init__(self): super().__init__() self.init_ui() self.attach_event() self.setAcceptDrops(True) def init_ui(self): # Define & Configure Components normal_button_size = QSize(80, 24) icon_button_size = QSize(24, 24) icon_size = QSize(18, 18) self.central_widget = QWidget() self.central_layout = QGridLayout() self.central_widget.setLayout(self.central_layout) self.tab_group_widget = QTabWidget() self.tab_group_widget.setMinimumSize(400, 0) self.tab_group_widget.setFixedHeight(150) self.tab1_name = '스폰서 변환' self.tab2_name = '싱크 조절(초)' self.tab3_name = '싱크 조절(%)' self.tab_page_1 = QWidget() self.tab_grid_1 = QGridLayout() self.tab1_search_label = QLabel('검색 텍스트') self.tab1_search = QLineEdit() self.tab1_sponsor = QWidget() self.tab1_sponsor_layout = QHBoxLayout() self.tab1_sponsor_layout.setContentsMargins(0, 0, 0, 0) self.tab1_sponsor_label = QLabel('스폰서 영상 길이') self.tab1_sponsor_value = QDoubleSpinBox() self.tab1_sponsor_value.setFixedWidth(60) self.tab1_sponsor_value.setMinimum(-1000000000) self.tab1_sponsor_value.setValue(10) self.tab1_offset = QWidget() self.tab1_offset_layout = QHBoxLayout() self.tab1_offset_layout.setContentsMargins(0, 0, 0, 0) self.tab1_offset_label = QLabel('라인 오프셋') self.tab1_offset_value = QSpinBox() self.tab1_offset_value.setMinimum(-1000000000) self.tab1_offset_value.setValue(2) self.tab1_offset_value.setFixedWidth(50) self.tab1_ignore = QWidget() self.tab1_ignore_layout = QHBoxLayout() self.tab1_ignore_layout.setContentsMargins(0, 0, 0, 0) self.tab1_ignore_label1 = QLabel('시작부터') self.tab1_ignore_value = QSpinBox() self.tab1_ignore_value.setFixedWidth(50) self.tab1_ignore_value.setValue(5) self.tab1_ignore_label2 = QLabel('줄 ') self.tab1_ignore_sec = QSpinBox() self.tab1_ignore_sec.setFixedWidth(60) self.tab1_ignore_sec.setMaximum(1000) self.tab1_ignore_sec.setValue(90) self.tab1_ignore_label3 = QLabel('초 무시하기') self.tab1_add_button = QPushButton('추가하기') self.tab_page_2 = QWidget() self.tab_grid_2 = QGridLayout() self.tab2_shift = QWidget() self.tab2_shift_layout = QHBoxLayout() self.tab2_shift_layout.setContentsMargins(0, 0, 0, 0) self.tab2_shift_label1 = QLabel('자막 싱크') self.tab2_shift_value = QDoubleSpinBox() self.tab2_shift_value.setFixedWidth(60) self.tab2_shift_label2 = QLabel('초 ') self.tab2_slow_radio = QRadioButton('느리게') self.tab2_slow_radio.setChecked(True) self.tab2_fast_radio = QRadioButton('빠르게') self.tab2_add_button = QPushButton('추가하기') self.tab_page_3 = QWidget() self.tab_grid_3 = QGridLayout() self.tab3_speed_label1 = QLabel('자막 싱크') self.tab3_speed_value = QSpinBox() self.tab3_speed_value.setFixedWidth(70) self.tab3_speed_value.setRange(1, 1000) self.tab3_speed_value.setValue(100) self.tab3_speed_label2 = QLabel('%') self.tab3_add_button = QPushButton('추가하기') self.que_label = QLabel('작업 목록') self.que_label.setFixedHeight(24) self.que_widget = QWidget() self.que_widget.setFixedHeight(114) self.que_layout = QGridLayout() self.que_layout.setContentsMargins(0, 0, 0, 0) self.que_list = QTreeWidget() self.que_list.setHeaderLabels(['작업', '옵션']) self.que_delete_button = QPushButton(QIcon(':/remove.png'), '') self.que_delete_button.setFixedSize(icon_button_size) self.que_delete_button.setIconSize(icon_size) self.que_delete_button.setToolTip('목록 삭제') self.que_up_button = QPushButton(QIcon(':/up.png'), '') self.que_up_button.setIconSize(icon_size) self.que_up_button.setFixedSize(icon_button_size) self.que_up_button.setToolTip('위로') self.que_down_button = QPushButton(QIcon(':/down.png'), '') self.que_down_button.setIconSize(icon_size) self.que_down_button.setFixedSize(icon_button_size) self.que_down_button.setToolTip('아래로') self.que_clear_button = QPushButton(QIcon(':/clear.png'), '') self.que_clear_button.setIconSize(icon_size) self.que_clear_button.setFixedSize(icon_button_size) self.que_clear_button.setToolTip('비우기') self.file_label = QLabel('파일 목록') self.file_label.setFixedHeight(24) self.file_widget = QWidget() self.file_layout = QGridLayout() self.file_layout.setContentsMargins(0, 0, 0, 0) self.file_list = QTreeWidget() self.file_list.setAcceptDrops(True) self.file_list.setHeaderLabels(['이름', '경로']) self.file_file_open = QPushButton(QIcon(':/file.png'), '') self.file_file_open.setFixedSize(icon_button_size) self.file_file_open.setIconSize(icon_size) self.file_file_open.setToolTip('파일 열기') self.file_dir_open = QPushButton(QIcon(':/folder.png'), '') self.file_dir_open.setFixedSize(icon_button_size) self.file_dir_open.setIconSize(icon_size) self.file_dir_open.setToolTip('폴더 열기') self.file_delete = QPushButton(QIcon(':/remove.png'), '') self.file_delete.setFixedSize(icon_button_size) self.file_delete.setIconSize(icon_size) self.file_delete.setToolTip('목록 삭제') self.file_clear = QPushButton(QIcon(':/clear.png'), '') self.file_clear.setFixedSize(icon_button_size) self.file_clear.setIconSize(icon_size) self.file_clear.setToolTip('비우기') self.file_encode = QPushButton(QIcon(':/encode.png'), '') self.file_encode.setFixedSize(icon_button_size) self.file_encode.setIconSize(icon_size) self.file_encode.setToolTip('인코딩 설정') self.save_widget = QGroupBox('저장 옵션') self.save_widget.setMinimumSize(400, 0) self.save_widget.setFixedHeight(82) self.save_layout = QGridLayout() self.save_orig_radio = QRadioButton('원본 위치에 저장') self.save_orig_radio.setChecked(True) self.save_strip = QCheckBox('싱크 꼬임 무시') self.save_strip.setToolTip('싱크 꼬임을 무시하고 모든 자막을 보존합니다.') self.save_dir_radio = QRadioButton('다른 위치에 저장') self.save_dir_line = QLineEdit() self.save_dir_find = QPushButton('...') self.save_dir_find.setFixedWidth(40) self.ok_button = QPushButton('적용') self.ok_button.setFixedSize(normal_button_size) self.cancel_button = QPushButton('취소') self.cancel_button.setFixedSize(normal_button_size) # Display GUI Components self.central_layout.addWidget(self.tab_group_widget, 0, 0, 1, 3) self.central_layout.addWidget(self.que_label, 1, 0, 1, 3) self.central_layout.addWidget(self.que_widget, 2, 0, 1, 3) self.central_layout.addWidget(self.file_label, 3, 0, 1, 3) self.central_layout.addWidget(self.file_widget, 4, 0, 1, 3) self.central_layout.addWidget(self.save_widget, 5, 0, 1, 3) self.central_layout.addWidget(self.ok_button, 6, 1, 1, 1) self.central_layout.addWidget(self.cancel_button, 6, 2, 1, 1) self.tab_group_widget.addTab(self.tab_page_1, QIcon(), self.tab1_name) self.tab_group_widget.addTab(self.tab_page_2, QIcon(), self.tab2_name) self.tab_group_widget.addTab(self.tab_page_3, QIcon(), self.tab3_name) self.tab_page_1.setLayout(self.tab_grid_1) self.tab_grid_1.addWidget(self.tab1_search_label, 0, 0, 1, 1) self.tab_grid_1.addWidget(self.tab1_search, 0, 1, 1, 2) self.tab_grid_1.addWidget(self.tab1_sponsor, 1, 1, 1, 1) self.tab_grid_1.addWidget(self.tab1_offset, 1, 2, 1, 1) self.tab_grid_1.addWidget(self.tab1_ignore, 2, 1, 1, 2) self.tab_grid_1.addWidget(self.tab1_add_button, 3, 0, 1, 3) self.tab1_sponsor.setLayout(self.tab1_sponsor_layout) self.tab1_sponsor_layout.addWidget(self.tab1_sponsor_label) self.tab1_sponsor_layout.addWidget(self.tab1_sponsor_value) self.tab1_sponsor_layout.addStretch(1) self.tab1_offset.setLayout(self.tab1_offset_layout) self.tab1_offset_layout.addWidget(self.tab1_offset_label) self.tab1_offset_layout.addWidget(self.tab1_offset_value) self.tab1_offset_layout.addStretch(1) self.tab1_ignore.setLayout(self.tab1_ignore_layout) self.tab1_ignore_layout.addWidget(self.tab1_ignore_label1) self.tab1_ignore_layout.addWidget(self.tab1_ignore_value) self.tab1_ignore_layout.addWidget(self.tab1_ignore_label2) self.tab1_ignore_layout.addWidget(self.tab1_ignore_sec) self.tab1_ignore_layout.addWidget(self.tab1_ignore_label3) self.tab1_ignore_layout.addStretch(1) self.tab_page_2.setLayout(self.tab_grid_2) self.tab_grid_2.setRowStretch(0, 1) self.tab_grid_2.addWidget(self.tab2_shift, 1, 0, 2, 1) self.tab_grid_2.addWidget(self.tab2_slow_radio, 1, 1, 1, 1) self.tab_grid_2.addWidget(self.tab2_fast_radio, 2, 1, 1, 1) self.tab_grid_2.setColumnStretch(2, 1) self.tab_grid_2.setRowStretch(3, 1) self.tab_grid_2.addWidget(self.tab2_add_button, 4, 0, 1, 3) self.tab2_shift.setLayout(self.tab2_shift_layout) self.tab2_shift_layout.addWidget(self.tab2_shift_label1) self.tab2_shift_layout.addWidget(self.tab2_shift_value) self.tab2_shift_layout.addWidget(self.tab2_shift_label2) self.tab_page_3.setLayout(self.tab_grid_3) self.tab_grid_3.setRowStretch(0, 1) self.tab_grid_3.addWidget(self.tab3_speed_label1, 1, 0, 1, 1) self.tab_grid_3.addWidget(self.tab3_speed_value, 1, 1, 1, 1) self.tab_grid_3.addWidget(self.tab3_speed_label2, 1, 2, 1, 1) self.tab_grid_3.setColumnStretch(3, 1) self.tab_grid_3.setRowStretch(2, 1) self.tab_grid_3.addWidget(self.tab3_add_button, 3, 0, 1, 4) self.que_widget.setLayout(self.que_layout) self.que_layout.addWidget(self.que_list, 0, 0, 4, 1) self.que_layout.addWidget(self.que_delete_button, 0, 1, 1, 1) self.que_layout.addWidget(self.que_up_button, 1, 1, 1, 1) self.que_layout.addWidget(self.que_down_button, 2, 1, 1, 1) self.que_layout.addWidget(self.que_clear_button, 3, 1, 1, 1) self.file_widget.setLayout(self.file_layout) self.file_layout.addWidget(self.file_list, 0, 0, 6, 1) self.file_layout.addWidget(self.file_file_open, 0, 1, 1, 1) self.file_layout.addWidget(self.file_dir_open, 1, 1, 1, 1) self.file_layout.addWidget(self.file_delete, 2, 1, 1, 1) self.file_layout.addWidget(self.file_clear, 3, 1, 1, 1) self.file_layout.addWidget(self.file_encode, 5, 1, 1, 1) self.save_widget.setLayout(self.save_layout) self.save_layout.addWidget(self.save_orig_radio, 0, 0, 1, 1) self.save_layout.setColumnStretch(1, 1) self.save_layout.addWidget(self.save_strip, 0, 2, 1, 2) self.save_layout.addWidget(self.save_dir_radio, 1, 0, 1, 1) self.save_layout.addWidget(self.save_dir_line, 1, 1, 1, 2) self.save_layout.addWidget(self.save_dir_find, 1, 3, 1, 1) self.setWindowTitle('Batch SAMI Sync v0.2') self.setCentralWidget(self.central_widget) self.adjustSize() def attach_event(self): # Default encoding hack self.encoding = '자동' # Define and Connect event handlers def tab1_add(): sponsor_text = self.tab1_search.text() sponsor_time = self.tab1_sponsor_value.value() line_offset = self.tab1_offset_value.value() line_ignore = self.tab1_ignore_value.value() time_ignore = self.tab1_ignore_sec.value() data = [1, sponsor_time, sponsor_text, line_offset, line_ignore, time_ignore] item = QTreeWidgetItem(self.que_list, [self.tab1_name, '스폰서 영상 시간 : ' + str(sponsor_time) + '초, 오프셋 : ' + str(line_offset) + '줄, 시작부터 ' + str(line_ignore) + '번째 줄, ' + str(time_ignore) + '초 무시 - 검색어 : ' + sponsor_text]) item.setData(2, 2, data) def tab2_add(): shift_time = self.tab2_shift_value.value() shift_direction = self.tab2_fast_radio.isChecked() direction_text = '빠르게' if shift_direction else '느리게' data = [2, shift_time, shift_direction] item = QTreeWidgetItem(self.que_list, [self.tab2_name, '자막 싱크 ' + str(shift_time) + '초 ' + direction_text]) item.setData(2, 2, data) def tab3_add(): speed_rate = self.tab3_speed_value.value() data = [3, speed_rate] item = QTreeWidgetItem(self.que_list, [self.tab3_name, '자막 속도 ' + str(speed_rate) + '%']) item.setData(2, 2, data) def file_open(): selected = QFileDialog.getOpenFileNames(self, "자막 파일 선택", "", "SAMI Files (*.smi);;All Files (*)") for file in selected[0]: name = ntpath.basename(file) Utils.insert_list(self.file_list, name, file) def dir_open(): selected = QFileDialog.getExistingDirectory(self, "자막 폴더 선택") for paths, subdirs, files in os.walk(selected): for file in files: if fnmatch(file, '*.smi'): name = ntpath.basename(file) Utils.insert_list(self.file_list, name, file) def open_encode_dialog(): self.dialog = QInputDialog(self) self.dialog.setWindowTitle('인코딩 설정') self.dialog.setLabelText('텍스트 인코딩 설정') self.dialog.setComboBoxItems(['자동', 'EUC-KR', 'UTF-8', 'UTF-16LE', 'UTF-16BE', '직접 입력']) self.dialog.show() self.dialog.textValueChanged.connect(type_encode) self.dialog.textValueSelected.connect(set_encode) def type_encode(text): if text == '직접 입력': self.dialog.setComboBoxItems([]) self.dialog.setComboBoxEditable(True) def set_encode(text): self.encoding = text def save_dir(): selected = QFileDialog.getExistingDirectory(self, "저장 위치 선택") self.save_dir_line.setText(selected) def apply(): self.ok_button.setEnabled(False) ques = Utils.read_list(self.que_list, False) files = Utils.read_list(self.file_list, False) strip = False if self.save_strip.isChecked() else True log = [] for file in files: try: text = Utils.launch_que(file[1], ques, self.encoding, strip) if len(text): if self.save_orig_radio.isChecked(): savepath = file[1] else: savepath = self.save_dir_line.text() + '/' + file[0] Utils.save_file(savepath, text) except Exception as e: log.append(file[0] + ' 처리 오류 : ' + str(e)) if log: ScrollMessageBox(QMessageBox.Warning, 'Batch SAMI Sync', "\n".join(log)) else: QMessageBox.information(self, 'Batch SAMI Sync', '변환 완료!') self.ok_button.setEnabled(True) self.tab1_add_button.clicked.connect(tab1_add) self.tab2_add_button.clicked.connect(tab2_add) self.tab3_add_button.clicked.connect(tab3_add) self.que_delete_button.clicked.connect(lambda: Utils.delete_list(self.que_list)) self.que_clear_button.clicked.connect(lambda: Utils.clear_list(self.que_list)) self.que_up_button.clicked.connect(lambda: Utils.up_list(self.que_list)) self.que_down_button.clicked.connect(lambda: Utils.down_list(self.que_list)) self.file_file_open.clicked.connect(file_open) self.file_dir_open.clicked.connect(dir_open) self.file_delete.clicked.connect(lambda: Utils.delete_list(self.file_list)) self.file_clear.clicked.connect(lambda: Utils.clear_list(self.file_list)) self.file_encode.clicked.connect(open_encode_dialog) self.save_dir_find.clicked.connect(save_dir) self.ok_button.clicked.connect(apply) self.cancel_button.clicked.connect(sys.exit) def dragEnterEvent(self, event): if event.mimeData().hasUrls: event.accept() else: event.ignore() def dragMoveEvent(self, event): if event.mimeData().hasUrls(): event.setDropAction(Qt.CopyAction) event.accept() else: event.ignore() def dropEvent(self, event): if event.mimeData().hasUrls(): event.setDropAction(Qt.CopyAction) event.accept() for url in event.mimeData().urls(): if url.isLocalFile(): file = str(url.toLocalFile()) if fnmatch(file, '*.smi'): name = ntpath.basename(file) Utils.insert_list(self.file_list, name, file) elif not fnmatch(file, '*.*'): for paths, subdirs, files in os.walk(file): for file in files: if fnmatch(file, '*.smi'): name = ntpath.basename(file) Utils.insert_list(self.file_list, name, file) else: event.ignore()