class Slider(): def update_offset(self, pos): offset = round(pos, 2) return offset def __init__(self, tool, text, tooltip, precision, minimal, maximal, interval): self.tool = tool self.scale = precision self.name_label = QLabel(text) self.name_label.setAlignment(Qt.AlignLeft) if not tooltip == None: self.name_label.setToolTip(tooltip) self.offset_edit = QDoubleSpinBox() self.offset_edit.setRange(minimal, maximal) self.offset_edit.setSingleStep(precision) self.offset_edit.setDecimals(2) self.offset_edit.setAlignment(Qt.AlignRight) self.offset_edit.valueChanged.connect( lambda pos: self.slider.setSliderPosition( self.update_offset(pos) / self.scale)) self.slider = QSlider(Qt.Horizontal) self.slider.setRange(minimal / self.scale, maximal) self.slider.setTickInterval(interval / self.scale) self.slider.setTickPosition(QSlider.TicksAbove) self.slider.valueChanged.connect(lambda pos: self.offset_edit.setValue( self.update_offset(pos * self.scale))) self.update_offset(0)
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 createEditor(self, parent: QWidget, option: QStyleOptionViewItem, index: QModelIndex) -> QWidget: editor = QDoubleSpinBox(parent) editor.setFrame(False) editor.setRange(self.__min, self.__max) editor.setDecimals(self.__decimals) return editor
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 change_n_components(self, n_components: int): for widget in self.control_widgets: self.control_layout.removeWidget(widget) widget.hide() self.control_widgets.clear() self.input_widgets.clear() widgets = [] slider_range = (0, 1000) input_widgets = [] mean_range = (-5, 15) std_range = (0.0, 10) weight_range = (0, 10) names = [self.tr("Mean"), self.tr("STD"), self.tr("Weight")] ranges = [mean_range, std_range, weight_range] slider_values = [500, 100, 100] input_values = [0.0, 1.0, 1.0] for i in range(n_components): group = QGroupBox(f"C{i+1}") group.setMinimumWidth(200) group_layout = QGridLayout(group) inputs = [] for j, (name, range_, slider_value, input_value) in enumerate( zip(names, ranges, slider_values, input_values)): label = QLabel(name) slider = QSlider() slider.setRange(*slider_range) slider.setValue(slider_value) slider.setOrientation(Qt.Horizontal) input_ = QDoubleSpinBox() input_.setRange(*range_) input_.setDecimals(3) input_.setSingleStep(0.01) input_.setValue(input_value) slider.valueChanged.connect(self.on_value_changed) input_.valueChanged.connect(self.on_value_changed) slider.valueChanged.connect( lambda x, input_=input_, range_=range_: input_.setValue( x / 1000 * (range_[-1] - range_[0]) + range_[0])) input_.valueChanged.connect( lambda x, slider=slider, range_=range_: slider.setValue( (x - range_[0]) / (range_[-1] - range_[0]) * 1000)) group_layout.addWidget(label, j, 0) group_layout.addWidget(slider, j, 1) group_layout.addWidget(input_, j, 2) inputs.append(input_) self.control_layout.addWidget(group, i + 5, 0, 1, 4) widgets.append(group) input_widgets.append(inputs) self.control_widgets = widgets self.input_widgets = input_widgets
def init_font_size_layout(text_item): font_size_input = QDoubleSpinBox() font_size_input.setDecimals(2) font_size_input.setRange(0.5, 900.) font_size_input.setValue(text_item.font().pointSizeF()) font_size_input.valueChanged.connect(lambda: set_font_size( font_size_input.value(), text_item)) font_size_layout = QHBoxLayout() font_size_layout.addWidget(font_size_input) font_size_layout.addWidget(QLabel("pt")) return font_size_layout
def get_settings_window(self, parent=None): gcodesender_settings = QGroupBox("GCodeSender Settings:", parent) buildplate_label = QLabel("Buildplate Motor:", gcodesender_settings) nodes = [str(item) for item in self.__g_code_sender.get_motor_nodes_id_list()] self.buildplate_combo_box = MyQComboBox(gcodesender_settings) self.buildplate_combo_box.addItems(nodes) self.buildplate_combo_box.setCurrentIndex(self.__g_code_sender.get_buildplate_node()) self.buildplate_combo_box.combo_box_clicked.connect(self.__update_nodes_list) self.buildplate_combo_box.currentIndexChanged.connect(self.__set_buildplate_node) wiper_label = QLabel("Wiper Motor:", gcodesender_settings) self.wiper_combo_box = MyQComboBox(gcodesender_settings) self.wiper_combo_box.addItems(nodes) self.wiper_combo_box.setCurrentIndex(self.__g_code_sender.get_wiper_node()) self.wiper_combo_box.combo_box_clicked.connect(self.__update_nodes_list) self.wiper_combo_box.currentIndexChanged.connect(self.__set_wiper_node) buildplate_recoat_offset_label = QLabel("Buildplate recoating offset (mm):", gcodesender_settings) buildplate_recoat_offset_spin = QDoubleSpinBox(gcodesender_settings) buildplate_recoat_offset_spin.setRange(0, 99999) buildplate_recoat_offset_spin.setDecimals(3) buildplate_recoat_offset_spin.setSingleStep(0.001) buildplate_recoat_offset_spin.setValue(self.__g_code_sender.get_building_plate_recoating_offset()) buildplate_recoat_offset_spin.valueChanged.connect(self.__g_code_sender.set_building_plate_recoat_offset) buildplate_recoat_feedrate_label = QLabel("Buildplate recoating feedrate (mm/min):", gcodesender_settings) buildplate_recoat_feedrate_spin = QDoubleSpinBox(gcodesender_settings) buildplate_recoat_feedrate_spin.setRange(0, 99999) buildplate_recoat_feedrate_spin.setDecimals(3) buildplate_recoat_feedrate_spin.setSingleStep(0.001) buildplate_recoat_feedrate_spin.setValue(self.__g_code_sender.get_building_plate_recoating_feedrate()) buildplate_recoat_feedrate_spin.valueChanged.connect(self.__g_code_sender.set_building_plate_recoat_feedrate) wiper_recoat_offset_label = QLabel("Wiper recoating offset: (mm)", gcodesender_settings) wiper_recoat_offset_spin = QDoubleSpinBox(gcodesender_settings) wiper_recoat_offset_spin.setRange(0, 99999) wiper_recoat_offset_spin.setDecimals(3) wiper_recoat_offset_spin.setSingleStep(0.001) wiper_recoat_offset_spin.setValue(self.__g_code_sender.get_wiper_recoating_offset()) wiper_recoat_offset_spin.valueChanged.connect(self.__g_code_sender.set_wiper_recoat_offset) wiper_recoat_feedrate_label = QLabel("Wiper recoating feedrate (mm/min):", gcodesender_settings) wiper_recoat_feedrate_spin = QDoubleSpinBox(gcodesender_settings) wiper_recoat_feedrate_spin.setRange(0, 99999) wiper_recoat_feedrate_spin.setDecimals(3) wiper_recoat_feedrate_spin.setSingleStep(0.001) wiper_recoat_feedrate_spin.setValue(self.__g_code_sender.get_wiper_recoating_feedrate()) wiper_recoat_feedrate_spin.valueChanged.connect(self.__g_code_sender.set_wiper_recoat_feedrate) motor_layout = QGridLayout(gcodesender_settings) motor_layout.addWidget(buildplate_label, 0, 0) motor_layout.addWidget(self.buildplate_combo_box, 0, 1) motor_layout.addWidget(buildplate_recoat_offset_label, 1, 0) motor_layout.addWidget(buildplate_recoat_offset_spin, 1, 1) motor_layout.addWidget(buildplate_recoat_feedrate_label, 2, 0) motor_layout.addWidget(buildplate_recoat_feedrate_spin, 2, 1) motor_layout.addWidget(wiper_label, 3, 0) motor_layout.addWidget(self.wiper_combo_box, 3, 1) motor_layout.addWidget(wiper_recoat_offset_label, 4, 0) motor_layout.addWidget(wiper_recoat_offset_spin, 4, 1) motor_layout.addWidget(wiper_recoat_feedrate_label, 5, 0) motor_layout.addWidget(wiper_recoat_feedrate_spin, 5, 1) return gcodesender_settings
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 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_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_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 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)
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)
class WidgetConfig(QGroupBox): def __init__(self): super(WidgetConfig, self).__init__() HEIGHT = 40 grid = QGridLayout() # 使用默认摄像头复选框 self.check_camera = QCheckBox('Use default camera') self.check_camera.setChecked(False) self.check_camera.stateChanged.connect(self.slot_check_camera) grid.addWidget(self.check_camera, 0, 0, 1, 3) # 一行三列 # 选择视频文件 label_video = QLabel('Detect File') self.line_video = QLineEdit() if 'video' in GLOBAL.config: self.line_video.setText(GLOBAL.config['video']) self.line_video.setFixedHeight(HEIGHT) self.line_video.setEnabled(False) self.line_video.editingFinished.connect( lambda: GLOBAL.record_config({'video': self.line_video.text()})) self.btn_video = QPushButton('Choose') self.btn_video.setFixedHeight(HEIGHT) self.btn_video.setEnabled(False) self.btn_video.clicked.connect(self.choose_video_file) self.slot_check_camera() grid.addWidget(label_video, 1, 0) grid.addWidget(self.line_video, 1, 1) grid.addWidget(self.btn_video, 1, 2) # 选择权重文件 label_weights = QLabel('Weights File') self.line_weights = QLineEdit() if 'weights' in GLOBAL.config: self.line_weights.setText(GLOBAL.config['weights']) self.line_weights.setFixedHeight(HEIGHT) self.line_weights.editingFinished.connect(lambda: GLOBAL.record_config( {'weights': self.line_weights.text()})) self.btn_weights = QPushButton('Choose') self.btn_weights.setFixedHeight(HEIGHT) self.btn_weights.clicked.connect(self.choose_weights_file) grid.addWidget(label_weights, 2, 0) grid.addWidget(self.line_weights, 2, 1) grid.addWidget(self.btn_weights, 2, 2) # 是否使用GPU label_device = QLabel('CUDA device') self.line_device = QLineEdit('gpu') if 'device' in GLOBAL.config: self.line_device.setText(GLOBAL.config['device']) else: self.line_device.setText('cpu') self.line_device.setPlaceholderText('cpu or 0 or 0,1,2,3') self.line_device.setFixedHeight(HEIGHT) self.line_device.editingFinished.connect( lambda: GLOBAL.record_config({'device': self.line_device.text()})) grid.addWidget(label_device, 3, 0) grid.addWidget(self.line_device, 3, 1, 1, 2) # 设置图像大小 label_size = QLabel('Img Size') self.combo_size = QComboBox() self.combo_size.setFixedHeight(HEIGHT) self.combo_size.setStyleSheet( 'QAbstractItemView::item {height: 40px;}') self.combo_size.setView(QListView()) self.combo_size.addItem('320', 320) self.combo_size.addItem('416', 416) self.combo_size.addItem('480', 480) self.combo_size.addItem('544', 544) self.combo_size.addItem('640', 640) self.combo_size.setCurrentIndex(2) self.combo_size.currentIndexChanged.connect( lambda: GLOBAL.record_config( {'img_size': self.combo_size.currentData()})) grid.addWidget(label_size, 4, 0) grid.addWidget(self.combo_size, 4, 1, 1, 2) #choose net camera label_stream = QLabel('NetVedioStream') self.combo_stream = QComboBox() self.combo_stream.setFixedHeight(HEIGHT) self.combo_stream.setStyleSheet( 'QAbstractItemView::item {height: 40px;}') self.combo_stream.setView(QListView()) self.combo_stream.addItem('rtsp://*****:*****@192.168.0.65/', 'rtsp://*****:*****@192.168.0.65/') self.combo_stream.addItem('rtsp://*****:*****@192.168.0.66/', 'rtsp://*****:*****@192.168.0.66/') self.combo_stream.addItem('rtsp://*****:*****@192.168.0.67/', 'rtsp://*****:*****@192.168.0.67/') self.combo_stream.addItem('rtsp://*****:*****@192.168.0.68/', 'rtsp://*****:*****@192.168.0.68/') self.combo_stream.addItem('rtsp://*****:*****@192.168.0.65/', 'rtsp://*****:*****@192.168.0.65/') self.combo_stream.setCurrentIndex(0) self.combo_stream.currentIndexChanged.connect( lambda: GLOBAL.record_config( {'netstreamvedio': self.combo_stream.currentData()})) grid.addWidget(label_stream, 5, 0) grid.addWidget(self.combo_stream, 5, 1, 1, 2) # 设置置信度阈值 label_conf = QLabel('Confidence') self.spin_conf = QDoubleSpinBox() self.spin_conf.setFixedHeight(HEIGHT) self.spin_conf.setDecimals(1) self.spin_conf.setRange(0.1, 0.9) self.spin_conf.setSingleStep(0.1) if 'conf_thresh' in GLOBAL.config: self.spin_conf.setValue(GLOBAL.config['conf_thresh']) else: self.spin_conf.setValue(0.4) # 默认值 GLOBAL.record_config({'conf_thresh': 0.4}) self.spin_conf.valueChanged.connect(lambda: GLOBAL.record_config( {'conf_thresh': round(self.spin_conf.value(), 1)})) grid.addWidget(label_conf, 6, 0) grid.addWidget(self.spin_conf, 6, 1, 1, 2) # 设置IOU阈值 label_iou = QLabel('IOU') self.spin_iou = QDoubleSpinBox() self.spin_iou.setFixedHeight(HEIGHT) self.spin_iou.setDecimals(1) self.spin_iou.setRange(0.1, 0.9) self.spin_iou.setSingleStep(0.1) if 'iou_thresh' in GLOBAL.config: self.spin_iou.setValue(GLOBAL.config['iou_thresh']) else: self.spin_iou.setValue(0.5) # 默认值 GLOBAL.record_config({'iou_thresh': 0.5}) self.spin_iou.valueChanged.connect(lambda: GLOBAL.record_config( {'iou_thresh': round(self.spin_iou.value(), 1)})) grid.addWidget(label_iou, 7, 0) grid.addWidget(self.spin_iou, 7, 1, 1, 2) # class-agnostic NMS self.check_agnostic = QCheckBox('Agnostic') if 'agnostic' in GLOBAL.config: self.check_agnostic.setChecked(GLOBAL.config['agnostic']) else: self.check_agnostic.setChecked(True) self.check_agnostic.stateChanged.connect(lambda: GLOBAL.record_config( {'agnostic': self.check_agnostic.isChecked()})) grid.addWidget(self.check_agnostic, 8, 0, 1, 3) # 一行三列 # augmented inference self.check_augment = QCheckBox('Augment') if 'augment' in GLOBAL.config: self.check_augment.setChecked(GLOBAL.config['augment']) else: self.check_augment.setChecked(True) self.check_augment.stateChanged.connect(lambda: GLOBAL.record_config( {'augment': self.check_augment.isChecked()})) grid.addWidget(self.check_augment, 9, 0, 1, 3) # 一行三列 self.setLayout(grid) # 设置布局 def slot_check_camera(self): check = self.check_camera.isChecked() GLOBAL.record_config({'use_camera': check}) # 保存配置 if check: self.line_video.setEnabled(False) self.btn_video.setEnabled(False) else: self.line_video.setEnabled(True) self.btn_video.setEnabled(True) def choose_weights_file(self): """从系统中选择权重文件""" file = QFileDialog.getOpenFileName( self, "Pre-trained YOLOv5 Weights", "./", "Weights Files (*.pt);;All Files (*)") if file[0] != '': self.line_weights.setText(file[0]) GLOBAL.record_config({'weights': file[0]}) def choose_video_file(self): """从系统中选择视频文件""" file = QFileDialog.getOpenFileName(self, "Video Files", "./", "Video Files (*)") if file[0] != '': self.line_video.setText(file[0]) GLOBAL.record_config({'video': file[0]}) def save_config(self): """保存当前的配置到配置文件""" config = { 'use_camera': self.check_camera.isChecked(), 'video': self.line_video.text(), 'weights': self.line_weights.text(), 'device': self.line_device.text(), 'img_size': self.combo_size.currentData(), 'conf_thresh': round(self.spin_conf.value(), 1), 'iou_thresh': round(self.spin_iou.value(), 1), 'agnostic': self.check_agnostic.isChecked(), 'augment': self.check_augment.isChecked(), 'netstreamvedio': self.combo_stream.currentData() } GLOBAL.record_config(config)
class DomainDock(PlotterDock): """ Domain options dock """ def __init__(self, model, font_metric, parent=None): super().__init__(model, font_metric, parent) self.setAllowedAreas(QtCore.Qt.LeftDockWidgetArea) # Create Controls self._createOriginBox() self._createOptionsBox() self._createResolutionBox() # Create submit button self.applyButton = QPushButton("Apply Changes") # Mac bug fix self.applyButton.setMinimumHeight(self.font_metric.height() * 1.6) self.applyButton.clicked.connect(self.main_window.applyChanges) # Create Zoom box self.zoomBox = QSpinBox() self.zoomBox.setSuffix(' %') self.zoomBox.setRange(25, 2000) self.zoomBox.setValue(100) self.zoomBox.setSingleStep(25) self.zoomBox.valueChanged.connect(self.main_window.editZoom) self.zoomLayout = QHBoxLayout() self.zoomLayout.addWidget(QLabel('Zoom:')) self.zoomLayout.addWidget(self.zoomBox) self.zoomLayout.setContentsMargins(0, 0, 0, 0) self.zoomWidget = QWidget() self.zoomWidget.setLayout(self.zoomLayout) # Create Layout self.dockLayout = QVBoxLayout() self.dockLayout.addWidget(QLabel("Geometry/Properties")) self.dockLayout.addWidget(HorizontalLine()) self.dockLayout.addWidget(self.originGroupBox) self.dockLayout.addWidget(self.optionsGroupBox) self.dockLayout.addWidget(self.resGroupBox) self.dockLayout.addWidget(HorizontalLine()) self.dockLayout.addWidget(self.zoomWidget) self.dockLayout.addWidget(HorizontalLine()) self.dockLayout.addStretch() self.dockLayout.addWidget(self.applyButton) self.dockLayout.addWidget(HorizontalLine()) self.optionsWidget = QWidget() self.optionsWidget.setLayout(self.dockLayout) self.setWidget(self.optionsWidget) def _createOriginBox(self): # X Origin self.xOrBox = QDoubleSpinBox() self.xOrBox.setDecimals(9) self.xOrBox.setRange(-99999, 99999) xbox_connector = partial(self.main_window.editSingleOrigin, dimension=0) self.xOrBox.valueChanged.connect(xbox_connector) # Y Origin self.yOrBox = QDoubleSpinBox() self.yOrBox.setDecimals(9) self.yOrBox.setRange(-99999, 99999) ybox_connector = partial(self.main_window.editSingleOrigin, dimension=1) self.yOrBox.valueChanged.connect(ybox_connector) # Z Origin self.zOrBox = QDoubleSpinBox() self.zOrBox.setDecimals(9) self.zOrBox.setRange(-99999, 99999) zbox_connector = partial(self.main_window.editSingleOrigin, dimension=2) self.zOrBox.valueChanged.connect(zbox_connector) # Origin Form Layout self.orLayout = QFormLayout() self.orLayout.addRow('X:', self.xOrBox) self.orLayout.addRow('Y:', self.yOrBox) self.orLayout.addRow('Z:', self.zOrBox) self.orLayout.setLabelAlignment(QtCore.Qt.AlignLeft) self.orLayout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow) # Origin Group Box self.originGroupBox = QGroupBox('Origin') self.originGroupBox.setLayout(self.orLayout) def _createOptionsBox(self): # Width self.widthBox = QDoubleSpinBox(self) self.widthBox.setRange(.1, 99999) self.widthBox.setDecimals(9) self.widthBox.valueChanged.connect(self.main_window.editWidth) # Height self.heightBox = QDoubleSpinBox(self) self.heightBox.setRange(.1, 99999) self.heightBox.setDecimals(9) self.heightBox.valueChanged.connect(self.main_window.editHeight) # ColorBy self.colorbyBox = QComboBox(self) self.colorbyBox.addItem("material") self.colorbyBox.addItem("cell") self.colorbyBox.addItem("temperature") self.colorbyBox.addItem("density") self.colorbyBox.currentTextChanged[str].connect( self.main_window.editColorBy) # Universe level (applies to cell coloring only) self.universeLevelBox = QComboBox(self) self.universeLevelBox.addItem('all') for i in range(self.model.max_universe_levels): self.universeLevelBox.addItem(str(i)) self.universeLevelBox.currentTextChanged[str].connect( self.main_window.editUniverseLevel) # Alpha self.domainAlphaBox = QDoubleSpinBox(self) self.domainAlphaBox.setValue(self.model.activeView.domainAlpha) self.domainAlphaBox.setSingleStep(0.05) self.domainAlphaBox.setDecimals(2) self.domainAlphaBox.setRange(0.0, 1.0) self.domainAlphaBox.valueChanged.connect(self.main_window.editPlotAlpha) # Visibility self.visibilityBox = QCheckBox(self) self.visibilityBox.stateChanged.connect( self.main_window.editPlotVisibility) # Outlines self.outlinesBox = QCheckBox(self) self.outlinesBox.stateChanged.connect(self.main_window.toggleOutlines) # Basis self.basisBox = QComboBox(self) self.basisBox.addItem("xy") self.basisBox.addItem("xz") self.basisBox.addItem("yz") self.basisBox.currentTextChanged.connect(self.main_window.editBasis) # Advanced Color Options self.colorOptionsButton = QPushButton('Color Options...') self.colorOptionsButton.setMinimumHeight(self.font_metric.height() * 1.6) self.colorOptionsButton.clicked.connect(self.main_window.showColorDialog) # Options Form Layout self.opLayout = QFormLayout() self.opLayout.addRow('Width:', self.widthBox) self.opLayout.addRow('Height:', self.heightBox) self.opLayout.addRow('Basis:', self.basisBox) self.opLayout.addRow('Color By:', self.colorbyBox) self.opLayout.addRow('Universe Level:', self.universeLevelBox) self.opLayout.addRow('Plot alpha:', self.domainAlphaBox) self.opLayout.addRow('Visible:', self.visibilityBox) self.opLayout.addRow('Outlines:', self.outlinesBox) self.opLayout.addRow(self.colorOptionsButton) self.opLayout.setLabelAlignment(QtCore.Qt.AlignLeft) self.opLayout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow) # Options Group Box self.optionsGroupBox = QGroupBox('Options') self.optionsGroupBox.setLayout(self.opLayout) def _createResolutionBox(self): # Horizontal Resolution self.hResBox = QSpinBox(self) self.hResBox.setRange(1, 99999) self.hResBox.setSingleStep(25) self.hResBox.setSuffix(' px') self.hResBox.valueChanged.connect(self.main_window.editHRes) # Vertical Resolution self.vResLabel = QLabel('Pixel Height:') self.vResBox = QSpinBox(self) self.vResBox.setRange(1, 99999) self.vResBox.setSingleStep(25) self.vResBox.setSuffix(' px') self.vResBox.valueChanged.connect(self.main_window.editVRes) # Ratio checkbox self.ratioCheck = QCheckBox("Fixed Aspect Ratio", self) self.ratioCheck.stateChanged.connect(self.main_window.toggleAspectLock) # Resolution Form Layout self.resLayout = QFormLayout() self.resLayout.addRow(self.ratioCheck) self.resLayout.addRow('Pixel Width:', self.hResBox) self.resLayout.addRow(self.vResLabel, self.vResBox) self.resLayout.setLabelAlignment(QtCore.Qt.AlignLeft) self.resLayout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow) # Resolution Group Box self.resGroupBox = QGroupBox("Resolution") self.resGroupBox.setLayout(self.resLayout) def updateDock(self): self.updateOrigin() self.updateWidth() self.updateHeight() self.updateColorBy() self.updateUniverseLevel() self.updatePlotAlpha() self.updatePlotVisibility() self.updateOutlines() self.updateBasis() self.updateAspectLock() self.updateHRes() self.updateVRes() def updateOrigin(self): self.xOrBox.setValue(self.model.activeView.origin[0]) self.yOrBox.setValue(self.model.activeView.origin[1]) self.zOrBox.setValue(self.model.activeView.origin[2]) def updateWidth(self): self.widthBox.setValue(self.model.activeView.width) def updateHeight(self): self.heightBox.setValue(self.model.activeView.height) def updateColorBy(self): self.colorbyBox.setCurrentText(self.model.activeView.colorby) if self.model.activeView.colorby != 'cell': self.universeLevelBox.setEnabled(False) else: self.universeLevelBox.setEnabled(True) def updateUniverseLevel(self): self.universeLevelBox.setCurrentIndex(self.model.activeView.level + 1) def updatePlotAlpha(self): self.domainAlphaBox.setValue(self.model.activeView.domainAlpha) def updatePlotVisibility(self): self.visibilityBox.setChecked(self.model.activeView.domainVisible) def updateOutlines(self): self.outlinesBox.setChecked(self.model.activeView.outlines) def updateBasis(self): self.basisBox.setCurrentText(self.model.activeView.basis) def updateAspectLock(self): aspect_lock = bool(self.model.activeView.aspectLock) self.ratioCheck.setChecked(aspect_lock) self.vResBox.setDisabled(aspect_lock) self.vResLabel.setDisabled(aspect_lock) def updateHRes(self): self.hResBox.setValue(self.model.activeView.h_res) def updateVRes(self): self.vResBox.setValue(self.model.activeView.v_res) def revertToCurrent(self): cv = self.model.currentView self.xOrBox.setValue(cv.origin[0]) self.yOrBox.setValue(cv.origin[1]) self.zOrBox.setValue(cv.origin[2]) self.widthBox.setValue(cv.width) self.heightBox.setValue(cv.height) def resizeEvent(self, event): self.main_window.resizeEvent(event) hideEvent = showEvent = moveEvent = resizeEvent
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 AddRecipeWidget(QWidget): def __init__(self, database, parent): QWidget.__init__(self) self.recipe_ingredients = 0 self.add_recipe_win = QWidget() self.add_recipe_win.setFixedWidth(400) self.add_recipe_win.setWindowTitle("Add Recipe") add_rec_main_layout = QVBoxLayout() self.meal_planner_db = database self.setParent(parent) self.rec_name_input = QLineEdit() self.rec_desc_input = QLineEdit() self.rec_source_input = QLineEdit() rec_form_layout = QFormLayout() rec_form_layout.addRow(QLabel("Recipe Name"), self.rec_name_input) rec_form_layout.addRow(QLabel("Recipe Desc"), self.rec_desc_input) rec_form_layout.addRow(QLabel("Recipe Source"), self.rec_source_input) add_rec_main_layout.addLayout(rec_form_layout) rec_info_layout = QHBoxLayout() difficulty_layout = QVBoxLayout() self.difficulty_spinbox = QSpinBox() self.difficulty_spinbox.setRange(1, 5) self.difficulty_spinbox.setValue(3) difficulty_layout.addWidget(QLabel("Difficulty")) difficulty_layout.addWidget(self.difficulty_spinbox) prep_time_layout = QVBoxLayout() self.prep_time_spinbox = QSpinBox() self.prep_time_spinbox.setRange(0, 600) self.prep_time_spinbox.setValue(30) prep_time_layout.addWidget(QLabel("Prep. Time (min.)")) prep_time_layout.addWidget(self.prep_time_spinbox) rating_layout = QVBoxLayout() self.rating_spinbox = QSpinBox() self.rating_spinbox.setRange(1, 5) self.rating_spinbox.setValue(3) rating_layout.addWidget(QLabel("Rating")) rating_layout.addWidget(self.rating_spinbox) rec_info_layout.addLayout(difficulty_layout) rec_info_layout.addLayout(prep_time_layout) rec_info_layout.addLayout(rating_layout) add_rec_main_layout.addLayout(rec_info_layout) rec_tags_layout = QHBoxLayout() rec_cuisine_layout = QVBoxLayout() cuisines = [ "Mexican", "Swedish", "Austrian", "Italian", "Spanish", "American", "British", "Thai", "Greek", "Vietnamese", "Caribbean", "Japanese", "Chinese", "Indian", "French", "Swiss", "Portuguese", "Korean", "Turkish", "Moroccan", "Russian", "Malaysian", "Philippines", "Ethiopian", "Lebanese", "Arab", "Peruvian", "Brazilian", "Asian", "Middle Eastern", "South American", "African", "-" ] cuisines.sort() self.tag_cuisine = QComboBox() self.tag_cuisine.addItems(cuisines) rec_cuisine_layout.addWidget(QLabel("Cuisine")) rec_cuisine_layout.addWidget(self.tag_cuisine) rec_tags_layout.addLayout(rec_cuisine_layout) rec_category_layout = QVBoxLayout() categories = [ "Beef & Calf", "Chicken & Poultry", "Lamb", "Pork", "Preservation", "Salad", "Sandwich", "Soup", "Stew", "Pasta", "Rice", "Grain & Beans", "Fish & Seafood", "Vegetables", "Eggs & Cheese", "BBQ", "Fruits", "Cake & Pie (Sweet)", "Pie", "Bread", "Beverage", "Cookies & Sweets", "Sauce", "-" ] categories.sort() self.tag_category = QComboBox() self.tag_category.addItems(categories) rec_category_layout.addWidget(QLabel("Category")) rec_category_layout.addWidget(self.tag_category) rec_tags_layout.addLayout(rec_category_layout) rec_meal_type_layout = QVBoxLayout() meal_types = [ "Breakfast", "Brunch", "Lunch", "Dinner", "Dessert", "Starter", "Side", "Buffet", "Snack", "-" ] meal_types.sort() self.tag_meal_types = QComboBox() self.tag_meal_types.addItems(meal_types) rec_meal_type_layout.addWidget(QLabel("Meal Type")) rec_meal_type_layout.addWidget(self.tag_meal_types) rec_tags_layout.addLayout(rec_meal_type_layout) add_rec_main_layout.addLayout(rec_tags_layout) self.ingredient_name_input = QLineEdit() self.ingredient_qty_input = QDoubleSpinBox() self.ingredient_qty_input.setValue(1.0) self.ingredient_qty_input.setMaximum(1000) self.ingredient_qty_input.setDecimals(2) self.ingredient_unit_input = QComboBox() self.ingredient_unit_input.addItems( ["g", "ml", "dl", "l", "msk", "tsk", "st", "-"]) add_ingredient_btn = QPushButton("Create ingredient") add_ingredient_btn.clicked.connect(self.create_ingredient) add_ingredient_layout = QHBoxLayout() add_rec_main_layout.addWidget(QLabel("Ingredient")) add_ingredient_layout.addWidget(self.ingredient_name_input) add_ingredient_layout.addWidget(self.ingredient_qty_input) add_ingredient_layout.addWidget(self.ingredient_unit_input) add_ingredient_layout.addWidget(add_ingredient_btn) add_rec_main_layout.addLayout(add_ingredient_layout) btn_layout = QHBoxLayout() add_ingredient_to_recipe_btn = QPushButton("Add ingredient") add_ingredient_to_recipe_btn.clicked.connect( self.add_ingredient_to_recipe) del_ingredient_from_recipe_btn = QPushButton("Remove ingredient") del_ingredient_from_recipe_btn.clicked.connect( self.del_ingredient_from_recipe) btn_layout.addWidget(add_ingredient_to_recipe_btn) btn_layout.addWidget(del_ingredient_from_recipe_btn) add_rec_main_layout.addLayout(btn_layout) self.rec_ingredient_table = QTableWidget() self.rec_ingredient_table.setColumnCount(3) self.rec_ingredient_table.setHorizontalHeaderLabels( ["Amount", "Unit", "Ingredient"]) header = self.rec_ingredient_table.horizontalHeader() header.setSectionResizeMode(0, QtWidgets.QHeaderView.ResizeToContents) header.setSectionResizeMode(1, QtWidgets.QHeaderView.ResizeToContents) header.setSectionResizeMode(2, QtWidgets.QHeaderView.Stretch) add_rec_main_layout.addWidget(self.rec_ingredient_table) self.step_count = 0 self.add_recipe_step_btn = QPushButton("Add recipe instruction") add_rec_main_layout.addWidget(self.add_recipe_step_btn) self.add_recipe_step_btn.clicked.connect(self.add_recipe_step_win) self.rec_step_table = QTableWidget() self.rec_step_table.setColumnCount(1) self.rec_step_table.setHorizontalHeaderLabels(["Instructions"]) self.rec_step_table.setWordWrap(True) header = self.rec_step_table.horizontalHeader() header.setSectionResizeMode(0, QtWidgets.QHeaderView.Stretch) add_rec_main_layout.addWidget(self.rec_step_table) bottom_btn_layout = QHBoxLayout() self.add_rec_btn = QPushButton("Add recipe") self.add_rec_btn.clicked.connect(self.add_recipe_to_db) self.back_btn = QPushButton("Cancel") self.back_btn.clicked.connect(self.add_recipe_win.close) bottom_btn_layout.addWidget(self.add_rec_btn) bottom_btn_layout.addWidget(self.back_btn) add_rec_main_layout.addLayout(bottom_btn_layout) self.add_recipe_win.setLayout(add_rec_main_layout) self.add_recipe_win.show() @Slot() def add_recipe_step_win(self): self.rec_step_table.insertRow(self.step_count) self.step_count += 1 @Slot() def create_ingredient(self): self.add_ingredient_widget = AddIngredientWidget( self.meal_planner_db, self, self.ingredient_name_input.text()) @Slot() def add_ingredient_to_recipe(self): if self.meal_planner_db.ingredient_exists( self.ingredient_name_input.text()): self.rec_ingredient_table.insertRow(self.recipe_ingredients) self.rec_ingredient_table.setItem( self.recipe_ingredients, 0, QTableWidgetItem(str(self.ingredient_qty_input.value()))) self.rec_ingredient_table.setItem( self.recipe_ingredients, 1, QTableWidgetItem(self.ingredient_unit_input.currentText())) self.rec_ingredient_table.setItem( self.recipe_ingredients, 2, QTableWidgetItem(self.ingredient_name_input.text())) self.recipe_ingredients += 1 self.ingredient_name_input.clear() self.ingredient_qty_input.setValue(1.0) self.ingredient_unit_input.setCurrentIndex(0) else: print("Ingredient does not exist in database, please add it first") @Slot() def del_ingredient_from_recipe(self): recipe = self.rec_name_input.text() ingredient = self.rec_ingredient_table.currentItem().text() self.rec_ingredient_table.removeRow( self.rec_ingredient_table.currentRow()) self.meal_planner_db.del_recipe_ingredient(recipe, ingredient) @Slot() def add_recipe_to_db(self): rec_id = self.meal_planner_db.get_table_len("recipes") self.meal_planner_db.add_recipe(rec_id, self.rec_name_input.text(), self.rec_desc_input.text(), self.rec_source_input.text(), self.difficulty_spinbox.value(), self.prep_time_spinbox.value(), self.rating_spinbox.value(), "2000-01-01", 0) for row in range(self.rec_ingredient_table.rowCount()): qty_id = self.meal_planner_db.get_table_len("measurement_qty") qty_id = self.meal_planner_db.add_qty( qty_id, self.rec_ingredient_table.item(row, 0).text()) unit_id = self.meal_planner_db.get_table_len("measurement_units") unit_id = self.meal_planner_db.add_measurement( unit_id, self.rec_ingredient_table.item(row, 1).text()) ing_id = self.meal_planner_db.get_ingredient_id( self.rec_ingredient_table.item(row, 2).text()) if ing_id == -1: print("INGREDIENT DOES NOT EXIST! WE F****D UP!") break self.meal_planner_db.add_recipe_ingredient(rec_id, ing_id, unit_id, qty_id) for row in range(self.step_count): print(row, self.rec_step_table.item(row, 0).text()) self.meal_planner_db.add_step( rec_id, row, self.rec_step_table.item(row, 0).text()) # Cuisine tag tag_id = self.meal_planner_db.get_table_len("tags") tag_id = self.meal_planner_db.add_tag(tag_id, self.tag_cuisine.currentText()) self.meal_planner_db.add_recipe_tag(tag_id, rec_id) # Category tag tag_id = self.meal_planner_db.get_table_len("tags") tag_id = self.meal_planner_db.add_tag(tag_id, self.tag_category.currentText()) self.meal_planner_db.add_recipe_tag(tag_id, rec_id) # Meal type tag tag_id = self.meal_planner_db.get_table_len("tags") tag_id = self.meal_planner_db.add_tag( tag_id, self.tag_meal_types.currentText()) self.meal_planner_db.add_recipe_tag(tag_id, rec_id) self.rec_name_input.clear() self.rec_desc_input.clear() self.rec_ingredient_table.setRowCount(0) self.rec_step_table.setRowCount(0) self.step_count = 0 self.parent().update_recipe_table()
def __init__(self, prefs, icon=None): super().__init__() self.prefs = prefs self.hotkey_format_regex = r'^\<ctrl\>\+\<alt\>(\+\<shift\>)?\+[a-zA-Z0-9]$' if icon: self.setWindowIcon(icon) # checkbox: Include Minimized include_minimized = QCheckBox() include_minimized.setFixedWidth(35) include_minimized.setChecked(self.prefs["include_minimized"]["value"]) include_minimized.stateChanged.connect( lambda: self.include_minimized(include_minimized.isChecked())) include_minimized_descr = QLabel( self.prefs["include_minimized"]["description"]) include_minimized_descr.setWordWrap(True) include_minimized_layout = QHBoxLayout() include_minimized_layout.addWidget(include_minimized) include_minimized_layout.addWidget(include_minimized_descr) include_minimized_groupbox = QGroupBox("Include Minimized") include_minimized_groupbox.setLayout(include_minimized_layout) # checkbox: snap to grid snap_to_grid = QCheckBox() snap_to_grid.setFixedWidth(35) snap_to_grid.setChecked(self.prefs["snap_to_grid"]["value"]) snap_to_grid.stateChanged.connect( lambda: self.snap_to_grid(snap_to_grid.isChecked())) snap_to_grid_descr = QLabel(self.prefs["snap_to_grid"]["description"]) snap_to_grid_descr.setWordWrap(True) snap_to_grid_layout = QHBoxLayout() snap_to_grid_layout.addWidget(snap_to_grid) snap_to_grid_layout.addWidget(snap_to_grid_descr) snap_to_grid_groupbox = QGroupBox("Snap To Grid") snap_to_grid_groupbox.setLayout(snap_to_grid_layout) # checkbox: fit into screen fit_into_screen = QCheckBox() fit_into_screen.setFixedWidth(35) fit_into_screen.setChecked(self.prefs["fit_into_screen"]["value"]) fit_into_screen.stateChanged.connect( lambda: self.fit_into_screen(fit_into_screen.isChecked())) fit_into_screen_descr = QLabel( self.prefs["fit_into_screen"]["description"]) fit_into_screen_descr.setWordWrap(True) fit_into_screen_layout = QHBoxLayout() fit_into_screen_layout.addWidget(fit_into_screen) fit_into_screen_layout.addWidget(fit_into_screen_descr) fit_into_screen_groupbox = QGroupBox("Fit Into Screen") fit_into_screen_groupbox.setLayout(fit_into_screen_layout) # doublespinBox: match cutoff match_cutoff = QDoubleSpinBox() match_cutoff.setFixedWidth(35) match_cutoff.setValue(self.prefs["match_cutoff"]["value"]) match_cutoff.setRange(0.1, 1.0) match_cutoff.setSingleStep(0.1) match_cutoff.setDecimals(1) match_cutoff.valueChanged.connect( lambda: self.match_cutoff(match_cutoff.value())) match_cutoff_descr = QLabel(self.prefs["match_cutoff"]["description"]) match_cutoff_descr.setWordWrap(True) match_cutoff_layout = QHBoxLayout() match_cutoff_layout.addWidget(match_cutoff) match_cutoff_layout.addWidget(match_cutoff_descr) match_cutoff_groupbox = QGroupBox("Match Cutoff") match_cutoff_groupbox.setLayout(match_cutoff_layout) # checkbox: enable hotkeys enable_hotkeys = QCheckBox() enable_hotkeys.setFixedWidth(35) enable_hotkeys.setChecked(self.prefs["enable_hotkeys"]["value"]) enable_hotkeys.stateChanged.connect( lambda: self.enable_hotkeys(enable_hotkeys.isChecked())) enable_hotkeys_descr = QLabel( self.prefs["enable_hotkeys"]["description"]) enable_hotkeys_descr.setWordWrap(True) enable_hotkeys_layout = QHBoxLayout() enable_hotkeys_layout.addWidget(enable_hotkeys) enable_hotkeys_layout.addWidget(enable_hotkeys_descr) # lineedit: hotkeys shortcuts hotkey_freeze_new_name = QLabel("Freeze New:") hotkey_freeze_new_name.setFixedWidth(75) self.hotkey_freeze_new_status = QLabel() self.hotkey_freeze_new = QLineEdit( self.prefs["hotkeys"]["value"]["freeze_new"]) self.hotkey_freeze_new.setFixedWidth(140) self.hotkey_freeze_new.editingFinished.connect( lambda: self.hotkey_freeze_new_update(self.hotkey_freeze_new.text( ))) self.hotkey_freeze_new.cursorPositionChanged.connect( self.hotkey_freeze_new_status.clear) hotkey_freeze_new_layout = QHBoxLayout() hotkey_freeze_new_layout.addWidget(hotkey_freeze_new_name) hotkey_freeze_new_layout.addWidget(self.hotkey_freeze_new) hotkey_freeze_new_layout.addWidget(self.hotkey_freeze_new_status) hotkey_freeze_all_name = QLabel("Freeze All:") hotkey_freeze_all_name.setFixedWidth(75) self.hotkey_freeze_all_status = QLabel() self.hotkey_freeze_all = QLineEdit( self.prefs["hotkeys"]["value"]["freeze_all"]) self.hotkey_freeze_all.setFixedWidth(140) self.hotkey_freeze_all.editingFinished.connect( lambda: self.hotkey_freeze_all_update(self.hotkey_freeze_all.text( ))) self.hotkey_freeze_all.cursorPositionChanged.connect( self.hotkey_freeze_all_status.clear) hotkey_freeze_all_layout = QHBoxLayout() hotkey_freeze_all_layout.addWidget(hotkey_freeze_all_name) hotkey_freeze_all_layout.addWidget(self.hotkey_freeze_all) hotkey_freeze_all_layout.addWidget(self.hotkey_freeze_all_status) hotkey_restore_name = QLabel("Restore:") hotkey_restore_name.setFixedWidth(75) self.hotkey_restore_status = QLabel() self.hotkey_restore = QLineEdit( self.prefs["hotkeys"]["value"]["restore"]) self.hotkey_restore.setFixedWidth(140) self.hotkey_restore.editingFinished.connect( lambda: self.hotkey_restore_update(self.hotkey_restore.text())) self.hotkey_restore.cursorPositionChanged.connect( self.hotkey_restore_status.clear) hotkey_restore_layout = QHBoxLayout() hotkey_restore_layout.addWidget(hotkey_restore_name) hotkey_restore_layout.addWidget(self.hotkey_restore) hotkey_restore_layout.addWidget(self.hotkey_restore_status) self.hotkeys_statusbar = QLabel() self.hotkeys_statusbar.setWordWrap(True) self.hotkeys_statusbar.setText(hotkeys_statusbar_map[ self.prefs['enable_hotkeys']['value']]['text']) self.hotkeys_statusbar.setStyleSheet(hotkeys_statusbar_map[ self.prefs['enable_hotkeys']['value']]['style']) close_button = QPushButton("Close") close_button.setMaximumWidth(75) close_button.clicked.connect(self.close) hotkeys_statusbar_layout = QHBoxLayout() hotkeys_statusbar_layout.addWidget(self.hotkeys_statusbar) hotkeys_statusbar_layout.addWidget(close_button) hotkeys_layout = QVBoxLayout() hotkeys_layout.addLayout(hotkey_freeze_new_layout) hotkeys_layout.addLayout(hotkey_freeze_all_layout) hotkeys_layout.addLayout(hotkey_restore_layout) self.hotkeys_groupbox = QGroupBox() self.hotkeys_groupbox.setFlat(True) self.hotkeys_groupbox.setDisabled( not self.prefs["enable_hotkeys"]["value"]) self.hotkeys_groupbox.setLayout(hotkeys_layout) enable_hotkeys_outer_layout = QVBoxLayout() enable_hotkeys_outer_layout.addLayout(enable_hotkeys_layout) enable_hotkeys_outer_layout.addWidget(self.hotkeys_groupbox) enable_hotkeys_groupbox = QGroupBox("Enable Hotkeys") enable_hotkeys_groupbox.setLayout(enable_hotkeys_outer_layout) # Create main layout and add widgets main_layout = QVBoxLayout() main_layout.addWidget(include_minimized_groupbox) main_layout.addWidget(snap_to_grid_groupbox) main_layout.addWidget(fit_into_screen_groupbox) main_layout.addWidget(match_cutoff_groupbox) main_layout.addWidget(enable_hotkeys_groupbox) main_layout.addWidget(self.hotkeys_groupbox) #main_layout.addWidget(hotkeys_statusbar_groupbox) main_layout.addLayout(hotkeys_statusbar_layout) self.setLayout(main_layout)
def addArrowsBox(title, indexOffset, scale): layout = QGridLayout() deltaSB = QDoubleSpinBox() deltaSB.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.MinimumExpanding) if title == "Translation": deltaSB.setRange(-7, 7) deltaSB.setDecimals(3) deltaSB.setValue(1.0) else: deltaSB.setRange(-60, 60) deltaSB.setDecimals(2) deltaSB.setValue(10.0) setattr(self, "delta_" + title, deltaSB) deltaF = QFormLayout() deltaF.addRow("Delta", deltaSB) layout.addLayout(deltaF, 0, 0, 1, 3) layout.addWidget( positionButton( style.standardIcon(QStyle.SP_ArrowUp), "X+", 0 + indexOffset, deltaSB, scale, ), 1, 1, ) layout.addWidget( positionButton( style.standardIcon(QStyle.SP_ArrowDown), "X-", 0 + indexOffset, deltaSB, -scale, ), 3, 1, ) layout.addWidget( positionButton( style.standardIcon(QStyle.SP_ArrowLeft), "Y-", 1 + indexOffset, deltaSB, -scale, ), 2, 0, ) layout.addWidget( positionButton( style.standardIcon(QStyle.SP_ArrowRight), "Y+", 1 + indexOffset, deltaSB, scale, ), 2, 2, ) layout.addWidget( positionButton( style.standardIcon(QStyle.SP_ArrowUp), "Z+", 2 + indexOffset, deltaSB, scale, ), 1, 4, ) layout.addWidget( positionButton( style.standardIcon(QStyle.SP_ArrowDown), "Z-", 2 + indexOffset, deltaSB, -scale, ), 3, 4, ) ret = QGroupBox(title) ret.setLayout(layout) return ret
class SSUTypicalComponentChart(QDialog): def __init__(self, parent=None, toolbar=False): flags = Qt.Window | Qt.WindowTitleHint | Qt.CustomizeWindowHint | Qt.WindowCloseButtonHint super().__init__(parent=parent, f=flags) self.setWindowTitle(self.tr("SSU Typical Component Chart")) self.figure = plt.figure(figsize=(6, 3)) self.clustering_axes = self.figure.add_subplot(1, 2, 1) self.component_axes = self.figure.add_subplot(1, 2, 2) self.canvas = FigureCanvas(self.figure) self.toolbar = NavigationToolbar(self.canvas, self) self.main_layout = QGridLayout(self) self.main_layout.addWidget(self.toolbar, 0, 0, 1, 4) self.main_layout.addWidget(self.canvas, 1, 0, 1, 4) if not toolbar: self.toolbar.hide() self.supported_scales = [("log-linear", self.tr("Log-linear")), ("log", self.tr("Log")), ("phi", self.tr("φ")), ("linear", self.tr("Linear"))] self.AXIS_LIST = [ self.tr("Mean [φ]"), self.tr("Standard deviation [φ]"), self.tr("Skewness"), self.tr("Kurtosis") ] self.x_axis_label = QLabel(self.tr("X Axis")) self.x_axis_combo_box = QComboBox() self.x_axis_combo_box.addItems(self.AXIS_LIST) self.y_axis_label = QLabel(self.tr("Y Axis")) self.y_axis_combo_box = QComboBox() self.y_axis_combo_box.addItems(self.AXIS_LIST) self.y_axis_combo_box.setCurrentIndex(1) self.main_layout.addWidget(self.x_axis_label, 2, 0) self.main_layout.addWidget(self.x_axis_combo_box, 2, 1) self.main_layout.addWidget(self.y_axis_label, 3, 0) self.main_layout.addWidget(self.y_axis_combo_box, 3, 1) self.scale_label = QLabel(self.tr("Scale")) self.scale_combo_box = QComboBox() self.scale_combo_box.addItems( [name for key, name in self.supported_scales]) self.main_layout.addWidget(self.scale_label, 2, 2) self.main_layout.addWidget(self.scale_combo_box, 2, 3) self.min_samples_label = QLabel(self.tr("Minimum Samples")) self.min_samples_input = QDoubleSpinBox() self.min_samples_input.setRange(0.0001, 0.9999) self.min_samples_input.setDecimals(4) self.min_samples_input.setSingleStep(0.001) self.min_samples_input.setValue(0.03) self.min_cluster_size_label = QLabel(self.tr("Minimum Cluster Size")) self.min_cluster_size_input = QDoubleSpinBox() self.min_cluster_size_input.setRange(0.0001, 0.9999) self.min_cluster_size_input.setDecimals(4) self.min_cluster_size_input.setSingleStep(0.001) self.min_cluster_size_input.setValue(0.1) self.xi_label = QLabel(self.tr("xi")) self.xi_input = QDoubleSpinBox() self.xi_input.setRange(0.0001, 0.9999) self.xi_input.setDecimals(4) self.xi_input.setSingleStep(0.001) self.xi_input.setValue(0.05) self.main_layout.addWidget(self.min_samples_label, 3, 2) self.main_layout.addWidget(self.min_samples_input, 3, 3) self.main_layout.addWidget(self.min_cluster_size_label, 4, 0) self.main_layout.addWidget(self.min_cluster_size_input, 4, 1) self.main_layout.addWidget(self.xi_label, 4, 2) self.main_layout.addWidget(self.xi_input, 4, 3) self.update_chart_button = QPushButton(self.tr("Update Chart")) self.update_chart_button.clicked.connect(self.update_chart) self.save_typical_button = QPushButton(self.tr("Save Typical")) self.save_typical_button.setEnabled(False) self.save_typical_button.clicked.connect(self.on_save_clicked) self.main_layout.addWidget(self.update_chart_button, 5, 0, 1, 2) self.main_layout.addWidget(self.save_typical_button, 5, 2, 1, 2) self.last_results = None # type: list[SSUResult] self.data_to_clustering = None self.stacked_components = None self.normal_msg = QMessageBox(self) self.file_dialog = QFileDialog(parent=self) @property def scale(self) -> str: index = self.scale_combo_box.currentIndex() key, name = self.supported_scales[index] return key @property def transfer(self) -> typing.Callable: if self.scale == "log-linear": return lambda classes_φ: convert_φ_to_μm(classes_φ) elif self.scale == "log": return lambda classes_φ: np.log(convert_φ_to_μm(classes_φ)) elif self.scale == "phi": return lambda classes_φ: classes_φ elif self.scale == "linear": return lambda classes_φ: convert_φ_to_μm(classes_φ) @property def xlabel(self) -> str: if self.scale == "log-linear": return self.tr("Grain-size [μm]") elif self.scale == "log": return self.tr("Ln(grain-size in μm)") elif self.scale == "phi": return self.tr("Grain-size [φ]") elif self.scale == "linear": return self.tr("Grain-size [μm]") @property def ylabel(self) -> str: return self.tr("Frequency") @property def xlog(self) -> bool: if self.scale == "log-linear": return True else: return False def show_message(self, title: str, message: str): self.normal_msg.setWindowTitle(title) self.normal_msg.setText(message) self.normal_msg.exec_() def show_info(self, message: str): self.show_message(self.tr("Info"), message) def show_warning(self, message: str): self.show_message(self.tr("Warning"), message) def show_error(self, message: str): self.show_message(self.tr("Error"), message) def update_chart(self): if self.last_results is None: return x = self.transfer(self.last_results[0].classes_φ) self.save_typical_button.setEnabled(True) cluster = OPTICS(min_samples=self.min_samples_input.value(), min_cluster_size=self.min_cluster_size_input.value(), xi=self.xi_input.value()) flags = cluster.fit_predict(self.data_to_clustering) cmap = plt.get_cmap() self.clustering_axes.clear() flag_set = set(flags) for flag in flag_set: key = np.equal(flags, flag) if flag == -1: c = "#7a7374" label = self.tr("Not clustered") else: c = cmap(flag) label = self.tr("EM{0}").format(flag + 1) self.clustering_axes.plot(self.data_to_clustering[key] [:, self.x_axis_combo_box.currentIndex()], self.data_to_clustering[key] [:, self.y_axis_combo_box.currentIndex()], c="#ffffff00", marker=".", ms=8, mfc=c, mew=0.0, zorder=flag, label=label) if len(flag_set) < 6: self.clustering_axes.legend(loc="upper left") self.clustering_axes.set_xlabel(self.x_axis_combo_box.currentText()) self.clustering_axes.set_ylabel(self.y_axis_combo_box.currentText()) self.clustering_axes.set_title(self.tr("Clustering of end-members")) self.component_axes.clear() if self.xlog: self.component_axes.set_xscale("log") for flag in flag_set: if flag == -1: c = "#7a7374" else: c = cmap(flag) key = np.equal(flags, flag) for distribution in self.stacked_components[key]: self.component_axes.plot(x, distribution, c=c, zorder=flag) if flag != -1: typical = np.mean(self.stacked_components[key], axis=0) self.component_axes.plot(x, typical, c="black", zorder=1e10, ls="--", linewidth=1) self.component_axes.set_title(self.tr("Typical end-members")) self.component_axes.set_xlabel(self.xlabel) self.component_axes.set_ylabel(self.ylabel) self.component_axes.set_xlim(x[0], x[-1]) self.component_axes.set_ylim(0, None) self.figure.tight_layout() self.canvas.draw() def show_typical(self, results: typing.Iterable[GrainSizeSample]): if len(results) == 0: return keys_to_clustering = ["mean", "std", "skewness", "kurtosis"] data_to_clustering = [] stacked_components = [] for result in results: for component in result.components: has_nan = False for key in keys_to_clustering: if np.isnan( component.logarithmic_moments[key]) or np.isinf( component.logarithmic_moments[key]): has_nan = True break if has_nan: continue data_to_clustering.append([ component.logarithmic_moments[key] for key in keys_to_clustering ]) stacked_components.append(component.distribution) # convert to numpy array data_to_clustering = np.array(data_to_clustering) stacked_components = np.array(stacked_components) self.last_results = results self.data_to_clustering = data_to_clustering self.stacked_components = stacked_components self.update_chart() def save_typical(self, filename): assert self.last_results is not None if len(self.last_results) == 0: return cluster = OPTICS(min_samples=self.min_samples_input.value(), min_cluster_size=self.min_cluster_size_input.value(), xi=self.xi_input.value()) classes_μm = self.last_results[0].classes_μm flags = cluster.fit_predict(self.data_to_clustering) flag_set = set(flags) typicals = [] for flag in flag_set: if flag != -1: key = np.equal(flags, flag) typical = np.mean(self.stacked_components[key], axis=0) typicals.append(typical) wb = openpyxl.Workbook() prepare_styles(wb) ws = wb.active ws.title = self.tr("README") description = \ """ This Excel file was generated by QGrain ({0}). Please cite: Liu, Y., Liu, X., Sun, Y., 2021. QGrain: An open-source and easy-to-use software for the comprehensive analysis of grain size distributions. Sedimentary Geology 423, 105980. https://doi.org/10.1016/j.sedgeo.2021.105980 It contanins 2 + N_clusters sheets: 1. The first sheet is the sum distributions of all component clusters. 2. The second sheet is used to put the component distributions that not in any cluster. 3. The left sheet is the component distributions of each cluster, separately. The clustering algorithm is OPTICS, implemented by scikit-learn. https://scikit-learn.org/stable/modules/generated/sklearn.cluster.OPTICS.html Clustering algorithm details min_samples={1} min_cluster_size={2} xi={3} others=default """.format(QGRAIN_VERSION, self.min_samples_input.value(), self.min_cluster_size_input.value(), self.xi_input.value()) def write(row, col, value, style="normal_light"): cell = ws.cell(row + 1, col + 1, value=value) cell.style = style lines_of_desc = description.split("\n") for row, line in enumerate(lines_of_desc): write(row, 0, line, style="description") ws.column_dimensions[column_to_char(0)].width = 200 ws = wb.create_sheet(self.tr("Typical Components")) write(0, 0, self.tr("Typical Component"), style="header") ws.column_dimensions[column_to_char(0)].width = 16 for col, value in enumerate(classes_μm, 1): write(0, col, value, style="header") ws.column_dimensions[column_to_char(col)].width = 10 for row, distribution in enumerate(typicals, 1): if row % 2 == 0: style = "normal_dark" else: style = "normal_light" write(row, 0, self.tr("Component{0}").format(row), style=style) for col, value in enumerate(distribution, 1): write(row, col, value, style=style) QCoreApplication.processEvents() for flag in flag_set: if flag == -1: ws = wb.create_sheet(self.tr("Not Clustered"), 2) else: ws = wb.create_sheet(self.tr("Cluster{0}").format(flag + 1)) write(0, 0, self.tr("Index"), style="header") ws.column_dimensions[column_to_char(0)].width = 16 for col, value in enumerate(classes_μm, 1): write(0, col, value, style="header") ws.column_dimensions[column_to_char(col)].width = 10 key = np.equal(flags, flag) for row, component in enumerate(self.stacked_components[key], 1): if row % 2 == 0: style = "normal_dark" else: style = "normal_light" write(row, 0, str(row), style=style) for col, value in enumerate(component, 1): write(row, col, value, style=style) QCoreApplication.processEvents() wb.save(filename) wb.close() def on_save_clicked(self): if len(self.last_results) == 0: self.show_warning(self.tr("There is not an SSU result.")) return filename, _ = self.file_dialog.getSaveFileName( self, self. tr("Choose a filename to save the typical components of SSU results" ), None, f"{self.tr('Microsoft Excel')} (*.xlsx)") if filename is None or filename == "": return try: self.save_typical(filename) self.show_info(self.tr("The typical components have been saved.")) except Exception as e: self.show_error( self.tr("Error raised while saving it to Excel file.\n {0}" ).format(e.__str__())) return
class OptionsDock(QDockWidget): def __init__(self, model, FM, parent=None): super(OptionsDock, self).__init__(parent) self.model = model self.FM = FM self.mw = parent self.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding) # Doesn't work? self.setAllowedAreas(QtCore.Qt.LeftDockWidgetArea | QtCore.Qt.RightDockWidgetArea) # Create Controls self.createOriginBox() self.createOptionsBox() self.createResolutionBox() # Create submit button self.applyButton = QPushButton("Apply Changes") self.applyButton.setMinimumHeight(self.FM.height() * 1.6) # Mac bug fix self.applyButton.clicked.connect(self.mw.applyChanges) # Create Zoom box self.zoomBox = QSpinBox() self.zoomBox.setSuffix(' %') self.zoomBox.setRange(25, 2000) self.zoomBox.setValue(100) self.zoomBox.setSingleStep(25) self.zoomBox.valueChanged.connect(self.mw.editZoom) self.zoomLayout = QHBoxLayout() self.zoomLayout.addWidget(QLabel('Zoom:')) self.zoomLayout.addWidget(self.zoomBox) self.zoomLayout.setContentsMargins(0, 0, 0, 0) self.zoomWidget = QWidget() self.zoomWidget.setLayout(self.zoomLayout) # Create Layout self.dockLayout = QVBoxLayout() self.dockLayout.addWidget(self.originGroupBox) self.dockLayout.addWidget(self.optionsGroupBox) self.dockLayout.addWidget(self.resGroupBox) self.dockLayout.addWidget(self.applyButton) self.dockLayout.addStretch() self.dockLayout.addWidget(HorizontalLine()) self.dockLayout.addWidget(self.zoomWidget) self.optionsWidget = QWidget() self.optionsWidget.setLayout(self.dockLayout) self.setWidget(self.optionsWidget) def createOriginBox(self): # X Origin self.xOrBox = QDoubleSpinBox() self.xOrBox.setDecimals(9) self.xOrBox.setRange(-99999, 99999) self.xOrBox.valueChanged.connect( lambda value: self.mw.editSingleOrigin(value, 0)) # Y Origin self.yOrBox = QDoubleSpinBox() self.yOrBox.setDecimals(9) self.yOrBox.setRange(-99999, 99999) self.yOrBox.valueChanged.connect( lambda value: self.mw.editSingleOrigin(value, 1)) # Z Origin self.zOrBox = QDoubleSpinBox() self.zOrBox.setDecimals(9) self.zOrBox.setRange(-99999, 99999) self.zOrBox.valueChanged.connect( lambda value: self.mw.editSingleOrigin(value, 2)) # Origin Form Layout self.orLayout = QFormLayout() self.orLayout.addRow('X:', self.xOrBox) self.orLayout.addRow('Y:', self.yOrBox) self.orLayout.addRow('Z:', self.zOrBox) #self.orLayout.setVerticalSpacing(4) self.orLayout.setLabelAlignment(QtCore.Qt.AlignLeft) self.orLayout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow) # Origin Group Box self.originGroupBox = QGroupBox('Origin') self.originGroupBox.setLayout(self.orLayout) def createOptionsBox(self): # Width self.widthBox = QDoubleSpinBox(self) self.widthBox.setRange(.1, 99999) self.widthBox.valueChanged.connect(self.mw.editWidth) # Height self.heightBox = QDoubleSpinBox(self) self.heightBox.setRange(.1, 99999) self.heightBox.valueChanged.connect(self.mw.editHeight) # ColorBy self.colorbyBox = QComboBox(self) self.colorbyBox.addItem("material") self.colorbyBox.addItem("cell") self.colorbyBox.currentTextChanged[str].connect(self.mw.editColorBy) # Alpha self.plotAlphaBox = QDoubleSpinBox(self) self.plotAlphaBox.setValue(self.model.activeView.plotAlpha) self.plotAlphaBox.setSingleStep(0.05) self.plotAlphaBox.setDecimals(2) self.plotAlphaBox.setRange(0.0, 1.0) self.plotAlphaBox.valueChanged.connect(self.mw.editPlotAlpha) # Basis self.basisBox = QComboBox(self) self.basisBox.addItem("xy") self.basisBox.addItem("xz") self.basisBox.addItem("yz") self.basisBox.currentTextChanged.connect(self.mw.editBasis) # Advanced Color Options self.colorOptionsButton = QPushButton('Color Options...') self.colorOptionsButton.setMinimumHeight(self.FM.height() * 1.6) self.colorOptionsButton.clicked.connect(self.mw.showColorDialog) # Options Form Layout self.opLayout = QFormLayout() self.opLayout.addRow('Width:', self.widthBox) self.opLayout.addRow('Height:', self.heightBox) self.opLayout.addRow('Basis:', self.basisBox) self.opLayout.addRow('Color By:', self.colorbyBox) self.opLayout.addRow('Plot alpha:', self.plotAlphaBox) self.opLayout.addRow(self.colorOptionsButton) self.opLayout.setLabelAlignment(QtCore.Qt.AlignLeft) self.opLayout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow) # Options Group Box self.optionsGroupBox = QGroupBox('Options') self.optionsGroupBox.setLayout(self.opLayout) def createResolutionBox(self): # Horizontal Resolution self.hResBox = QSpinBox(self) self.hResBox.setRange(1, 99999) self.hResBox.setSingleStep(25) self.hResBox.setSuffix(' px') self.hResBox.valueChanged.connect(self.mw.editHRes) # Vertical Resolution self.vResLabel = QLabel('Pixel Height:') self.vResBox = QSpinBox(self) self.vResBox.setRange(1, 99999) self.vResBox.setSingleStep(25) self.vResBox.setSuffix(' px') self.vResBox.valueChanged.connect(self.mw.editVRes) # Ratio checkbox self.ratioCheck = QCheckBox("Fixed Aspect Ratio", self) self.ratioCheck.stateChanged.connect(self.mw.toggleAspectLock) # Resolution Form Layout self.resLayout = QFormLayout() self.resLayout.addRow(self.ratioCheck) self.resLayout.addRow('Pixel Width:', self.hResBox) self.resLayout.addRow(self.vResLabel, self.vResBox) self.resLayout.setLabelAlignment(QtCore.Qt.AlignLeft) self.resLayout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow) # Resolution Group Box self.resGroupBox = QGroupBox("Resolution") self.resGroupBox.setLayout(self.resLayout) def updateDock(self): self.updateOrigin() self.updateWidth() self.updateHeight() self.updateColorBy() self.updatePlotAlpha() self.updateBasis() self.updateAspectLock() self.updateHRes() self.updateVRes() def updateOrigin(self): self.xOrBox.setValue(self.model.activeView.origin[0]) self.yOrBox.setValue(self.model.activeView.origin[1]) self.zOrBox.setValue(self.model.activeView.origin[2]) def updateWidth(self): self.widthBox.setValue(self.model.activeView.width) def updateHeight(self): self.heightBox.setValue(self.model.activeView.height) def updateColorBy(self): self.colorbyBox.setCurrentText(self.model.activeView.colorby) def updatePlotAlpha(self): self.plotAlphaBox.setValue(self.model.activeView.plotAlpha) def updateBasis(self): self.basisBox.setCurrentText(self.model.activeView.basis) def updateAspectLock(self): if self.model.activeView.aspectLock: self.ratioCheck.setChecked(True) self.vResBox.setDisabled(True) self.vResLabel.setDisabled(True) else: self.ratioCheck.setChecked(False) self.vResBox.setDisabled(False) self.vResLabel.setDisabled(False) def updateHRes(self): self.hResBox.setValue(self.model.activeView.h_res) def updateVRes(self): self.vResBox.setValue(self.model.activeView.v_res) def revertToCurrent(self): cv = self.model.currentView self.xOrBox.setValue(cv.origin[0]) self.yOrBox.setValue(cv.origin[1]) self.zOrBox.setValue(cv.origin[2]) self.widthBox.setValue(cv.width) self.heightBox.setValue(cv.height) def resizeEvent(self, event): self.mw.resizeEvent(event) def hideEvent(self, event): self.mw.resizeEvent(event) def showEvent(self, event): self.mw.resizeEvent(event) def moveEvent(self, event): self.mw.resizeEvent(event)
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_()
def createDoubleSpinBox(): spinbox = QDoubleSpinBox() spinbox.setDecimals(3) spinbox.setValue(0.000) spinbox.setAlignment(Qt.AlignCenter) return spinbox
class PlotsWidget(ToolWidget): def __init__(self, image, parent=None): super(PlotsWidget, self).__init__(parent) choices = ['Red', 'Green', 'Blue', 'Hue', 'Saturation', 'Value'] self.xaxis_combo = QComboBox() self.xaxis_combo.addItems(choices) self.xaxis_combo.setCurrentIndex(3) self.yaxis_combo = QComboBox() self.yaxis_combo.addItems(choices) self.yaxis_combo.setCurrentIndex(4) self.sampling_spin = QSpinBox() levels = int(np.log2(min(image.shape[:-1]))) self.sampling_spin.setRange(0, levels) self.sampling_spin.setSpecialValueText(self.tr('Off')) self.sampling_spin.setValue(1) self.sampling_spin.setSuffix(self.tr(' level(s)')) self.size_spin = QSpinBox() self.size_spin.setRange(1, 10) self.size_spin.setValue(2) self.size_spin.setSuffix(self.tr(' pt')) self.style_combo = QComboBox() self.markers = [ ',', '.', 'o', '8', 's', 'p', 'P', '*', 'h', 'H', 'X', 'D' ] self.style_combo.addItems([ 'pixel', 'point', 'circle', 'octa', 'square', 'penta', 'plus', 'star', 'hexa1', 'hexa2', 'cross', 'diamond' ]) self.alpha_spin = QDoubleSpinBox() self.alpha_spin.setRange(0, 1) self.alpha_spin.setDecimals(2) self.alpha_spin.setSingleStep(0.05) self.alpha_spin.setValue(1) self.colors_check = QCheckBox(self.tr('Show colors')) self.grid_check = QCheckBox(self.tr('Show grid')) self.norm_check = QCheckBox(self.tr('Normalized')) self.total_label = QLabel() img = np.copy(image) self.colors = [None] * (levels + 1) for scale in range(levels + 1): rgb = cv.cvtColor(img.astype(np.float32) / 255, cv.COLOR_BGR2RGB) hsv = cv.cvtColor(rgb, cv.COLOR_RGB2HSV) hsv[:, :, 0] /= 360 shape = (img.shape[0] * img.shape[1], img.shape[2]) self.colors[scale] = np.concatenate( (np.reshape(rgb, shape), np.reshape(hsv, shape)), axis=1) img = cv.pyrDown(img) figure = Figure() plot_canvas = FigureCanvas(figure) self.axes = plot_canvas.figure.subplots() self.redraw() figure.set_tight_layout(True) self.xaxis_combo.currentIndexChanged.connect(self.redraw) self.yaxis_combo.currentIndexChanged.connect(self.redraw) self.sampling_spin.valueChanged.connect(self.redraw) self.size_spin.valueChanged.connect(self.redraw) self.style_combo.currentIndexChanged.connect(self.redraw) self.alpha_spin.valueChanged.connect(self.redraw) self.colors_check.stateChanged.connect(self.redraw) self.grid_check.stateChanged.connect(self.redraw) self.norm_check.stateChanged.connect(self.redraw) bottom_layout = QGridLayout() bottom_layout.addWidget(NavigationToolbar(plot_canvas, self), 0, 0, 1, 5) bottom_layout.addWidget(QLabel(self.tr('X axis:')), 1, 0) bottom_layout.addWidget(self.xaxis_combo, 1, 1) bottom_layout.addWidget(QLabel(self.tr('Y Axis:')), 2, 0) bottom_layout.addWidget(self.yaxis_combo, 2, 1) bottom_layout.addWidget(QLabel(self.tr('Subsampling:')), 3, 0) bottom_layout.addWidget(self.sampling_spin, 3, 1) bottom_layout.addWidget(QLabel(self.tr('Point size:')), 1, 2) bottom_layout.addWidget(self.size_spin, 1, 3) bottom_layout.addWidget(QLabel(self.tr('Point style:')), 2, 2) bottom_layout.addWidget(self.style_combo, 2, 3) bottom_layout.addWidget(QLabel(self.tr('Point alpha:')), 3, 2) bottom_layout.addWidget(self.alpha_spin, 3, 3) bottom_layout.addWidget(self.colors_check, 1, 4) bottom_layout.addWidget(self.grid_check, 2, 4) bottom_layout.addWidget(self.total_label, 3, 4) main_layout = QVBoxLayout() main_layout.addWidget(plot_canvas) main_layout.addLayout(bottom_layout) self.setLayout(main_layout) def redraw(self): start = time() v = self.sampling_spin.value() x = self.colors[v][:, self.xaxis_combo.currentIndex()] y = self.colors[v][:, self.yaxis_combo.currentIndex()] xlim = self.axes.get_xlim() ylim = self.axes.get_ylim() s = self.size_spin.value()**2 c = None if not self.colors_check.isChecked( ) else self.colors[v][:, :3] a = self.alpha_spin.value() m = self.markers[self.style_combo.currentIndex()] self.axes.clear() self.axes.set_facecolor([0.5] * 3 if c is not None else [1.0] * 3) self.axes.scatter(x, y, s, c, m, alpha=a) self.axes.set_xlabel(self.xaxis_combo.currentText()) self.axes.set_ylabel(self.yaxis_combo.currentText()) self.axes.grid(self.grid_check.isChecked(), which='both') self.axes.set_xlim(xlim) self.axes.set_ylim(ylim) self.axes.figure.canvas.draw() self.total_label.setText(self.tr('[{} points]'.format(len(x)))) self.info_message.emit('Plot redraw = {}'.format(elapsed_time(start)))
class NGL_HKLViewer(QWidget): def __init__(self, parent=None): super(NGL_HKLViewer, self).__init__(parent) self.verbose = 0 self.UseOSbrowser = False self.jscriptfname = "" self.devmode = False for e in sys.argv: if "verbose" in e: self.verbose = e.split("verbose=")[1] if "UseOSbrowser" in e: self.UseOSbrowser = e.split("UseOSbrowser=")[1] if "jscriptfname" in e: self.jscriptfname = e.split("jscriptfname=")[1] if "devmode" in e: self.devmode = True self.zmq_context = None self.bufsize = 20000 self.originalPalette = QApplication.palette() self.openFileNameButton = QPushButton("Load reflection file") self.openFileNameButton.setDefault(True) self.openFileNameButton.clicked.connect(self.OpenReflectionsFile) self.debugbutton = QPushButton("Debug") self.debugbutton.clicked.connect(self.DebugInteractively) self.settingsbtn = QPushButton("Settings") self.settingsbtn.clicked.connect(self.SettingsDialog) self.mousemoveslider = QSlider(Qt.Horizontal) self.mousemoveslider.setMinimum(0) self.mousemoveslider.setMaximum(300) self.mousemoveslider.setValue(0) self.mousemoveslider.sliderReleased.connect( self.onFinalMouseSensitivity) self.mousemoveslider.valueChanged.connect(self.onMouseSensitivity) self.mousesensitxtbox = QLineEdit('') self.mousesensitxtbox.setReadOnly(True) self.fontspinBox = QDoubleSpinBox() self.fontspinBox.setSingleStep(1) self.fontspinBox.setRange(4, 50) self.font = QFont() self.font.setFamily(self.font.defaultFamily()) self.fontspinBox.setValue(self.font.pointSize()) #self.fontspinBox.setValue(self.font.pixelSize()) self.fontspinBox.valueChanged.connect(self.onFontsizeChanged) self.Fontsize_labeltxt = QLabel() self.Fontsize_labeltxt.setText("Font size:") self.cameraPerspectCheckBox = QCheckBox() self.cameraPerspectCheckBox.setText("Perspective camera") self.cameraPerspectCheckBox.clicked.connect(self.onCameraPerspect) self.cameraPerspectCheckBox.setCheckState(Qt.Unchecked) self.settingsform = SettingsForm(self) self.MillerComboBox = QComboBox() self.MillerComboBox.activated.connect(self.onMillerComboSelchange) #self.MillerComboBox.setSizeAdjustPolicy(QComboBox.AdjustToContents) self.MillerLabel = QLabel() self.MillerLabel.setText("Selected HKL Scene") self.HKLnameedit = QLineEdit('') self.HKLnameedit.setReadOnly(True) self.textInfo = QTextEdit() self.textInfo.setLineWrapMode(QTextEdit.NoWrap) self.textInfo.setReadOnly(True) labels = [ "Label", "Type", "no. of HKLs", "Span of HKLs", "Min Max data", "Min Max sigmas", "d_min, d_max", "Symmetry unique", "Anomalous" ] self.millertable = QTableWidget(0, len(labels)) self.millertable.setHorizontalHeaderLabels(labels) self.millertable.horizontalHeader().setDefaultAlignment(Qt.AlignLeft) # don't allow editing this table self.millertable.setEditTriggers(QTableWidget.NoEditTriggers) self.createExpansionBox() self.createFileInfoBox() self.CreateSliceTabs() self.createRadiiScaleGroupBox() self.createBinsBox() self.CreateFunctionTabs() mainLayout = QGridLayout() mainLayout.addWidget(self.FileInfoBox, 0, 0) mainLayout.addWidget(self.MillerLabel, 1, 0) mainLayout.addWidget(self.MillerComboBox, 2, 0) mainLayout.addWidget(self.functionTabWidget, 3, 0) mainLayout.addWidget(self.settingsbtn, 4, 0, 1, 1) #import code, traceback; code.interact(local=locals(), banner="".join( traceback.format_stack(limit=10) ) ) if self.UseOSbrowser == False: self.BrowserBox = QWebEngineView() mainLayout.addWidget(self.BrowserBox, 0, 1, 5, 3) self.BrowserBox.setUrl("https://cctbx.github.io/") #self.BrowserBox.setUrl("https://webglreport.com/") #self.BrowserBox.loadFinished.connect(self.onLoadFinished) mainLayout.setColumnStretch(2, 1) mainLayout.setRowStretch(0, 1) mainLayout.setRowStretch(1, 0) mainLayout.setRowStretch(2, 1) mainLayout.setRowStretch(3, 1) mainLayout.setColumnStretch(4, 0) self.setLayout(mainLayout) self.setWindowTitle("HKL-Viewer") self.cctbxproc = None self.LaunchCCTBXPython() self.out = None self.err = None self.comboviewwidth = 0 self.hklscenes_arrays = [] self.array_infotpls = [] self.matching_arrays = [] self.bin_infotpls = None self.bin_opacities = None self.html_url = "" self.spacegroups = [] self.info = [] self.infostr = "" self.fileisvalid = False self.NewFileLoaded = False self.NewHKLscenes = False self.updatingNbins = False self.binstableitemchanges = False self.show() def SettingsDialog(self): self.settingsform.show() def update(self): if self.cctbxproc: if self.cctbxproc.stdout: print(self.cctbxproc.stdout.read().decode("utf-8")) if self.cctbxproc.stderr: print(self.cctbxproc.stderr.read().decode("utf-8")) if self.out: print(self.out.decode("utf-8")) if self.err: print(self.err.decode("utf-8")) if self.zmq_context: try: msg = self.socket.recv( flags=zmq.NOBLOCK ) #To empty the socket from previous messages msgstr = msg.decode() self.infodict = eval(msgstr) #print("received from cctbx: " + str(self.infodict)) if self.infodict: if self.infodict.get("hklscenes_arrays"): self.hklscenes_arrays = self.infodict.get( "hklscenes_arrays", []) if self.infodict.get("array_infotpls"): self.array_infotpls = self.infodict.get( "array_infotpls", []) if self.infodict.get("bin_data_label"): self.BinDataComboBox.setCurrentText( self.infodict["bin_data_label"]) if self.infodict.get("bin_infotpls"): self.bin_infotpls = self.infodict["bin_infotpls"] self.nbins = len(self.bin_infotpls) self.updatingNbins = True self.Nbins_spinBox.setValue(self.nbins) self.updatingNbins = False self.binstable.clearContents() self.binstable.setRowCount(self.nbins) for row, bin_infotpl in enumerate(self.bin_infotpls): for col, elm in enumerate(bin_infotpl): # only allow changing the last column with opacity values if col != 3: item = QTableWidgetItem(str(elm)) else: item = QTableWidgetItem() item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled) item.setCheckState(Qt.Checked) item.setFlags(item.flags() ^ Qt.ItemIsEditable) self.binstable.setItem(row, col, item) if self.bin_opacities: self.update_table_opacities() if self.infodict.get("bin_opacities"): self.bin_opacities = self.infodict["bin_opacities"] if self.binstable.rowCount() > 0: self.update_table_opacities() if self.infodict.get("html_url"): self.html_url = self.infodict["html_url"] if self.UseOSbrowser == False: self.BrowserBox.setUrl(self.html_url) # workaround for background colour bug in chromium # https://bugreports.qt.io/browse/QTBUG-41960 self.BrowserBox.page().setBackgroundColor( QColor(100, 100, 100, 1.0)) if self.infodict.get("spacegroups"): self.spacegroups = self.infodict.get("spacegroups", []) self.SpaceGroupComboBox.clear() self.SpaceGroupComboBox.addItems(self.spacegroups) if self.infodict.get("merge_data"): self.mergedata = self.infodict["merge_data"] currentinfostr = "" if self.infodict.get("info"): currentinfostr = self.infodict.get("info", []) if self.infodict.get("NewFileLoaded"): self.NewFileLoaded = self.infodict.get( "NewFileLoaded", False) if self.infodict.get("NewHKLscenes"): self.NewHKLscenes = self.infodict.get( "NewHKLscenes", False) self.fileisvalid = True #print("ngl_hkl_infodict: " + str(ngl_hkl_infodict)) if currentinfostr: #print(currentinfostr) self.infostr += currentinfostr + "\n" # display no more than self.bufsize bytes of text self.infostr = self.infostr[-self.bufsize:] self.textInfo.setPlainText(self.infostr) self.textInfo.verticalScrollBar().setValue( self.textInfo.verticalScrollBar().maximum()) if self.NewFileLoaded and self.NewHKLscenes: #if self.mergedata == True : val = Qt.CheckState.Checked #if self.mergedata == None : val = Qt.CheckState.PartiallyChecked #if self.mergedata == False : val = Qt.CheckState.Unchecked #self.mergecheckbox.setCheckState(val ) #print("got hklscenes: " + str(self.hklscenes_arrays)) self.MillerComboBox.clear() self.MillerComboBox.addItems( [e[3] for e in self.hklscenes_arrays]) self.MillerComboBox.setCurrentIndex( -1) # unselect the first item in the list self.comboviewwidth = 0 for e in self.hklscenes_arrays: self.comboviewwidth = max( self.comboviewwidth, self.MillerComboBox.fontMetrics().width(e[3])) self.MillerComboBox.view().setMinimumWidth( self.comboviewwidth) self.millertable.clearContents() self.millertable.setRowCount(len( self.hklscenes_arrays)) for n, millarr in enumerate(self.array_infotpls): for m, elm in enumerate(millarr): self.millertable.setItem( n, m, QTableWidgetItem(str(elm))) self.functionTabWidget.setDisabled(True) self.NewFileLoaded = False if self.NewHKLscenes: self.BinDataComboBox.clear() self.BinDataComboBox.addItems( ["Resolution"] + [e[3] for e in self.hklscenes_arrays]) self.BinDataComboBox.view().setMinimumWidth( self.comboviewwidth) #self.BinDataComboBox.setCurrentIndex(-1) # unselect the first item in the list self.NewHKLscenes = False except Exception as e: errmsg = str(e) if "Resource temporarily unavailable" not in errmsg: print(errmsg + traceback.format_exc(limit=10)) pass def onFinalMouseSensitivity(self): val = self.mousemoveslider.value() / 100.0 self.NGL_HKL_command( 'NGL_HKLviewer.viewer.NGL.mouse_sensitivity = %f' % val) def onMouseSensitivity(self): val = self.mousemoveslider.value() / 100.0 self.mousesensitxtbox.setText("%2.2f" % val) def onFontsizeChanged(self, val): font = app.font() font.setPointSize(val) app.setFont(font) self.settingsform.setFixedSize(self.settingsform.sizeHint()) def onCameraPerspect(self, val): if self.cameraPerspectCheckBox.isChecked(): self.NGL_HKL_command("NGL_HKLviewer.camera_type = perspective") else: self.NGL_HKL_command("NGL_HKLviewer.camera_type = orthographic") def MergeData(self): if self.mergecheckbox.checkState() == Qt.CheckState.Checked: self.NGL_HKL_command('NGL_HKLviewer.mergedata = True') if self.mergecheckbox.checkState() == Qt.CheckState.PartiallyChecked: self.NGL_HKL_command('NGL_HKLviewer.mergedata = None') if self.mergecheckbox.checkState() == Qt.CheckState.Unchecked: self.NGL_HKL_command('NGL_HKLviewer.mergedata = False') def ExpandToP1(self): if self.expandP1checkbox.isChecked(): self.NGL_HKL_command('NGL_HKLviewer.viewer.expand_to_p1 = True') else: self.NGL_HKL_command('NGL_HKLviewer.viewer.expand_to_p1 = False') def ExpandAnomalous(self): if self.expandAnomalouscheckbox.isChecked(): self.NGL_HKL_command( 'NGL_HKLviewer.viewer.expand_anomalous = True') else: self.NGL_HKL_command( 'NGL_HKLviewer.viewer.expand_anomalous = False') def showSysAbsent(self): if self.sysabsentcheckbox.isChecked(): self.NGL_HKL_command( 'NGL_HKLviewer.viewer.show_systematic_absences = True') else: self.NGL_HKL_command( 'NGL_HKLviewer.viewer.show_systematic_absences = False') def showMissing(self): if self.missingcheckbox.isChecked(): self.NGL_HKL_command('NGL_HKLviewer.viewer.show_missing = True') else: self.NGL_HKL_command('NGL_HKLviewer.viewer.show_missing = False') def showOnlyMissing(self): if self.onlymissingcheckbox.isChecked(): self.NGL_HKL_command( 'NGL_HKLviewer.viewer.show_only_missing = True') else: self.NGL_HKL_command( 'NGL_HKLviewer.viewer.show_only_missing = False') def showSlice(self): if self.showslicecheckbox.isChecked(): self.NGL_HKL_command('NGL_HKLviewer.viewer.slice_mode = True') if self.expandP1checkbox.isChecked(): self.NGL_HKL_command("""NGL_HKLviewer.viewer { expand_to_p1 = True inbrowser = False } """) if self.expandAnomalouscheckbox.isChecked(): self.NGL_HKL_command("""NGL_HKLviewer.viewer { expand_anomalous = True inbrowser = False } """) else: self.NGL_HKL_command("""NGL_HKLviewer.viewer { slice_mode = False inbrowser = True } """) def onSliceComboSelchange(self, i): rmin = self.array_infotpls[self.MillerComboBox.currentIndex()][3][0][i] rmax = self.array_infotpls[self.MillerComboBox.currentIndex()][3][1][i] self.sliceindexspinBox.setRange(rmin, rmax) self.NGL_HKL_command("NGL_HKLviewer.viewer.slice_axis = %s" % self.sliceaxis[i]) def onSliceIndexChanged(self, val): self.sliceindex = val self.NGL_HKL_command("NGL_HKLviewer.viewer.slice_index = %d" % self.sliceindex) def onBindataComboSelchange(self, i): if self.BinDataComboBox.currentText(): if self.BinDataComboBox.currentIndex() > 0: bin_scene_label = str(self.BinDataComboBox.currentIndex() - 1) else: bin_scene_label = "Resolution" self.NGL_HKL_command("NGL_HKLviewer.bin_scene_label = %s" % bin_scene_label) def update_table_opacities(self, allalpha=None): bin_opacitieslst = eval(self.bin_opacities) self.binstable_isready = False for binopacity in bin_opacitieslst: if not allalpha: alpha = float(binopacity.split(",")[0]) else: alpha = allalpha bin = int(binopacity.split(",")[1]) item = QTableWidgetItem() item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled) if alpha < 0.5: item.setCheckState(Qt.Unchecked) else: item.setCheckState(Qt.Checked) item.setFlags(item.flags() ^ Qt.ItemIsEditable) self.binstable.setItem(bin, 3, item) self.binstable_isready = True def SetOpaqueAll(self): if self.binstableitemchanges: return bin_opacitieslst = eval(self.bin_opacities) nbins = len(bin_opacitieslst) sum = 0 for binopacity in bin_opacitieslst: sum += float(binopacity.split(",")[0]) if sum >= nbins: self.OpaqueAllCheckbox.setCheckState(Qt.Checked) if sum == 0: self.OpaqueAllCheckbox.setCheckState(Qt.Unchecked) if sum > 0.0 and sum < nbins: self.OpaqueAllCheckbox.setCheckState(Qt.PartiallyChecked) def onBinsTableItemChanged(self, item): row = item.row() column = item.column() try: if item.checkState() == Qt.Unchecked: newval = 0 else: newval = 1.0 if column == 3 and self.binstable_isready: # changing opacity assert (newval <= 1.0 and newval >= 0.0) bin_opacitieslst = eval(self.bin_opacities) bin_opacitieslst[row] = str(newval) + ', ' + str(row) self.bin_opacities = str(bin_opacitieslst) self.SetOpaqueAll() self.NGL_HKL_command( 'NGL_HKLviewer.viewer.NGL.bin_opacities = "%s"' % self.bin_opacities) except Exception as e: print(str(e)) #self.binstable.currentItem().setText( self.currentSelectedBinsTableVal) def onBinsTableItemSelectionChanged(self): row = self.binstable.currentItem().row() column = self.binstable.currentItem().column() self.currentSelectedBinsTableVal = self.binstable.currentItem().text() #print( "in itemSelectionChanged " + self.currentSelectedBinsTableVal) def onOpaqueAll(self): self.binstableitemchanges = True bin_opacitieslst = eval(self.bin_opacities) nbins = len(bin_opacitieslst) bin_opacitieslst = [] self.binstable_isready = False if self.OpaqueAllCheckbox.isChecked(): for i in range(nbins): bin_opacitieslst.append("1.0, %d" % i) else: for i in range(nbins): bin_opacitieslst.append("0.0, %d" % i) self.bin_opacities = str(bin_opacitieslst) self.NGL_HKL_command('NGL_HKLviewer.viewer.NGL.bin_opacities = "%s"' % self.bin_opacities) self.binstableitemchanges = False self.binstable_isready = True """ def onLoadFinished(self, val): pass #print("web page finished loading now") def onBinsTableitemActivated(self, item): row = item.row() column = item.column() currentval = item.text() #print( "in itemActivated " + currentval) def onBinsTableCellentered(self, row, col): pass #print( "in Cellentered " + self.binstable.currentItem().text() ) def onBinsTableCellPressed(self, row, col): pass #print( "in CellPressed " + self.binstable.currentItem().text() ) """ def onNbinsChanged(self, val): self.nbins = val if not self.updatingNbins: # avoid possible endless loop to cctbx self.NGL_HKL_command("NGL_HKLviewer.nbins = %d" % self.nbins) def onRadiiScaleChanged(self, val): self.radii_scale = val self.NGL_HKL_command(""" NGL_HKLviewer.viewer { nth_power_scale_radii = %f scale = %f } """ % (self.nth_power_scale, self.radii_scale)) def onPowerScaleChanged(self, val): self.nth_power_scale = val self.NGL_HKL_command(""" NGL_HKLviewer.viewer { nth_power_scale_radii = %f scale = %f } """ % (self.nth_power_scale, self.radii_scale)) def onManualPowerScale(self): if self.ManualPowerScalecheckbox.isChecked(): self.NGL_HKL_command( 'NGL_HKLviewer.viewer.nth_power_scale_radii = %f' % self.nth_power_scale) self.power_scale_spinBox.setEnabled(True) else: self.NGL_HKL_command( 'NGL_HKLviewer.viewer.nth_power_scale_radii = -1.0') self.power_scale_spinBox.setEnabled(False) self.nth_power_scale = -1.0 def OpenReflectionsFile(self): options = QFileDialog.Options() fileName, filtr = QFileDialog.getOpenFileName( self, "Load reflections file", "", "All Files (*);;MTZ Files (*.mtz);;CIF (*.cif)", "", options) if fileName: self.HKLnameedit.setText(fileName) #self.infostr = "" self.textInfo.setPlainText("") self.fileisvalid = False self.NGL_HKL_command('NGL_HKLviewer.filename = "%s"' % fileName) self.MillerComboBox.clear() self.BinDataComboBox.clear() def createExpansionBox(self): self.SpaceGroupComboBox = QComboBox() self.SpaceGroupComboBox.activated.connect(self.SpacegroupSelchange) self.SpacegroupLabel = QLabel() self.SpacegroupLabel.setText("Space Subgroups") self.mergecheckbox = QCheckBox() self.mergecheckbox.setText("Merge data") #self.mergecheckbox.setTristate (True) self.mergecheckbox.clicked.connect(self.MergeData) self.expandP1checkbox = QCheckBox() self.expandP1checkbox.setText("Expand to P1") self.expandP1checkbox.clicked.connect(self.ExpandToP1) self.expandAnomalouscheckbox = QCheckBox() self.expandAnomalouscheckbox.setText("Show Friedel pairs") self.expandAnomalouscheckbox.clicked.connect(self.ExpandAnomalous) self.sysabsentcheckbox = QCheckBox() self.sysabsentcheckbox.setText("Show Systematic Absences") self.sysabsentcheckbox.clicked.connect(self.showSysAbsent) self.missingcheckbox = QCheckBox() self.missingcheckbox.setText("Show Missing") self.missingcheckbox.clicked.connect(self.showMissing) self.onlymissingcheckbox = QCheckBox() self.onlymissingcheckbox.setText("Only Show Missing") self.onlymissingcheckbox.clicked.connect(self.showOnlyMissing) self.ExpansionBox = QGroupBox("Expansions") layout = QGridLayout() layout.addWidget(self.SpacegroupLabel, 0, 0) layout.addWidget(self.SpaceGroupComboBox, 0, 1) #layout.addWidget(self.mergecheckbox, 1, 0) layout.addWidget(self.expandP1checkbox, 1, 0) layout.addWidget(self.expandAnomalouscheckbox, 1, 1) layout.addWidget(self.sysabsentcheckbox, 2, 0) layout.addWidget(self.missingcheckbox, 3, 0) layout.addWidget(self.onlymissingcheckbox, 3, 1) layout.setRowStretch(0, 0) layout.setRowStretch(1, 0) layout.setRowStretch(2, 0) layout.setRowStretch(3, 1) self.ExpansionBox.setLayout(layout) def CreateSliceTabs(self): self.showslicecheckbox = QCheckBox() self.showslicecheckbox.setText("Show Slice") self.showslicecheckbox.clicked.connect(self.showSlice) self.sliceindexspinBox = QDoubleSpinBox() self.sliceindex = 0 self.sliceindexspinBox.setValue(self.sliceindex) self.sliceindexspinBox.setDecimals(0) self.sliceindexspinBox.setSingleStep(1) self.sliceindexspinBox.setRange(0, 20) self.sliceindexspinBox.valueChanged.connect(self.onSliceIndexChanged) self.SliceLabelComboBox = QComboBox() self.SliceLabelComboBox.activated.connect(self.onSliceComboSelchange) self.sliceaxis = ["h", "k", "l"] self.SliceLabelComboBox.addItems(self.sliceaxis) self.sliceTabWidget = QTabWidget() tab1 = QWidget() layout1 = QGridLayout() layout1.addWidget(self.showslicecheckbox, 0, 0, 1, 1) layout1.addWidget(self.SliceLabelComboBox, 0, 1, 1, 1) layout1.addWidget(self.sliceindexspinBox, 0, 2, 1, 1) tab1.setLayout(layout1) tab2 = QWidget() layout2 = QGridLayout() self.hvec_spinBox = QDoubleSpinBox(self.sliceTabWidget) self.hvecval = 2.0 self.hvec_spinBox.setValue(self.hvecval) self.hvec_spinBox.setDecimals(2) self.hvec_spinBox.setSingleStep(0.5) self.hvec_spinBox.setRange(-100.0, 10.0) self.hvec_spinBox.valueChanged.connect(self.onHvecChanged) self.hvec_Label = QLabel() self.hvec_Label.setText("H") layout2.addWidget(self.hvec_Label, 0, 0, 1, 1) layout2.addWidget(self.hvec_spinBox, 0, 1, 1, 1) self.kvec_spinBox = QDoubleSpinBox(self.sliceTabWidget) self.kvecval = 0.0 self.kvec_spinBox.setValue(self.kvecval) self.kvec_spinBox.setDecimals(2) self.kvec_spinBox.setSingleStep(0.5) self.kvec_spinBox.setRange(-100.0, 100.0) self.kvec_spinBox.valueChanged.connect(self.onKvecChanged) self.kvec_Label = QLabel() self.kvec_Label.setText("K") layout2.addWidget(self.kvec_Label, 1, 0, 1, 1) layout2.addWidget(self.kvec_spinBox, 1, 1, 1, 1) self.lvec_spinBox = QDoubleSpinBox(self.sliceTabWidget) self.lvecval = 0.0 self.lvec_spinBox.setValue(self.lvecval) self.lvec_spinBox.setDecimals(2) self.lvec_spinBox.setSingleStep(0.5) self.lvec_spinBox.setRange(-100.0, 100.0) self.lvec_spinBox.valueChanged.connect(self.onLvecChanged) self.lvec_Label = QLabel() self.lvec_Label.setText("L") layout2.addWidget(self.lvec_Label, 2, 0, 1, 1) layout2.addWidget(self.lvec_spinBox, 2, 1, 1, 1) self.hkldist_spinBox = QDoubleSpinBox(self.sliceTabWidget) self.hkldistval = 0.0 self.hkldist_spinBox.setValue(self.hkldistval) self.hkldist_spinBox.setDecimals(2) self.hkldist_spinBox.setSingleStep(0.5) self.hkldist_spinBox.setRange(-100.0, 100.0) self.hkldist_spinBox.valueChanged.connect(self.onHKLdistChanged) self.hkldist_Label = QLabel() self.hkldist_Label.setText("Distance from Origin") layout2.addWidget(self.hkldist_Label, 3, 0, 1, 1) layout2.addWidget(self.hkldist_spinBox, 3, 1, 1, 1) self.clipwidth_spinBox = QDoubleSpinBox(self.sliceTabWidget) self.clipwidthval = 0.5 self.clipwidth_spinBox.setValue(self.clipwidthval) self.clipwidth_spinBox.setDecimals(2) self.clipwidth_spinBox.setSingleStep(0.05) self.clipwidth_spinBox.setRange(0.0, 100.0) self.clipwidth_spinBox.valueChanged.connect(self.onClipwidthChanged) self.clipwidth_Label = QLabel() self.clipwidth_Label.setText("Clip Plane Width") layout2.addWidget(self.clipwidth_Label, 4, 0, 1, 1) layout2.addWidget(self.clipwidth_spinBox, 4, 1, 1, 1) self.ClipBox = QGroupBox("Normal Vector to Clip Plane") self.ClipBox.setLayout(layout2) layout3 = QGridLayout() self.ClipPlaneChkBox = QCheckBox(self.sliceTabWidget) self.ClipPlaneChkBox.setText( "Use clip plane normal to HKL vector pointing out") self.ClipPlaneChkBox.clicked.connect(self.onClipPlaneChkBox) layout3.addWidget(self.ClipPlaneChkBox, 0, 0) layout3.addWidget(self.ClipBox, 1, 0) tab2.setLayout(layout3) self.sliceTabWidget.addTab(tab1, "Explicit Slicing") self.sliceTabWidget.addTab(tab2, "Clip Plane Slicing") self.ClipBox.setDisabled(True) def onClipPlaneChkBox(self): if self.ClipPlaneChkBox.isChecked(): self.ClipBox.setDisabled(False) philstr = """NGL_HKLviewer.normal_clip_plane { h = %s k = %s l = %s hkldist = %s clipwidth = %s } NGL_HKLviewer.viewer.NGL.fixorientation = %s """ %(self.hvecval, self.kvecval, self.lvecval, self.hkldistval, self.clipwidthval, \ str(self.fixedorientcheckbox.isChecked()) ) self.NGL_HKL_command(philstr) else: self.ClipBox.setDisabled(True) self.NGL_HKL_command( "NGL_HKLviewer.normal_clip_plane.clipwidth = None") def onClipwidthChanged(self, val): self.clipwidthval = val self.NGL_HKL_command("NGL_HKLviewer.normal_clip_plane.clipwidth = %f" % self.clipwidthval) def onHKLdistChanged(self, val): self.hkldistval = val self.NGL_HKL_command("NGL_HKLviewer.normal_clip_plane.hkldist = %f" % self.hkldistval) def onHvecChanged(self, val): self.hvecval = val self.NGL_HKL_command("NGL_HKLviewer.normal_clip_plane.h = %f" % self.hvecval) def onKvecChanged(self, val): self.kvecval = val self.NGL_HKL_command("NGL_HKLviewer.normal_clip_plane.k = %f" % self.kvecval) def onLvecChanged(self, val): self.lvecval = val self.NGL_HKL_command("NGL_HKLviewer.normal_clip_plane.l = %f" % self.lvecval) def onFixedorient(self): self.NGL_HKL_command('NGL_HKLviewer.viewer.NGL.fixorientation = %s' \ %str(self.fixedorientcheckbox.isChecked())) def onMillerComboSelchange(self, i): self.NGL_HKL_command("NGL_HKLviewer.scene_id = %d" % i) #self.MillerComboBox.setCurrentIndex(i) if self.MillerComboBox.currentText(): self.functionTabWidget.setEnabled(True) self.expandAnomalouscheckbox.setEnabled(True) # don' allow anomalous expansion for data that's already anomalous for arrayinfo in self.array_infotpls: isanomalous = arrayinfo[-1] label = arrayinfo[0] if isanomalous and label == self.MillerComboBox.currentText( )[:len(label)]: self.expandAnomalouscheckbox.setDisabled(True) else: self.functionTabWidget.setDisabled(True) self.SpaceGroupComboBox.clear() self.SpaceGroupComboBox.addItems(self.spacegroups) # need to supply issymunique flag in infotuple #if self.hklscenes_arrays[ i ][6] == 0: # self.mergecheckbox.setEnabled(True) #else: # self.mergecheckbox.setEnabled(False) def createFileInfoBox(self): self.FileInfoBox = QGroupBox("Reflection File Information") layout = QGridLayout() layout.addWidget(self.openFileNameButton, 0, 0, 1, 2) if self.devmode: layout.addWidget(self.debugbutton, 0, 2, 1, 1) layout.addWidget(self.HKLnameedit, 1, 0, 1, 3) layout.addWidget(self.millertable, 2, 0, 1, 3) layout.addWidget(self.textInfo, 3, 0, 1, 3) #layout.setColumnStretch(1, 2) self.FileInfoBox.setLayout(layout) def createRadiiScaleGroupBox(self): self.RadiiScaleGroupBox = QGroupBox("Radii Size of HKL Spheres") self.ManualPowerScalecheckbox = QCheckBox() self.ManualPowerScalecheckbox.setText( "Manual Power Scaling of Sphere Radii") self.ManualPowerScalecheckbox.clicked.connect(self.onManualPowerScale) self.power_scale_spinBox = QDoubleSpinBox(self.RadiiScaleGroupBox) self.nth_power_scale = 0.5 self.power_scale_spinBox.setValue(self.nth_power_scale) self.power_scale_spinBox.setDecimals(2) self.power_scale_spinBox.setSingleStep(0.05) self.power_scale_spinBox.setRange(0.0, 1.0) self.power_scale_spinBox.valueChanged.connect(self.onPowerScaleChanged) self.power_scale_spinBox.setEnabled(False) self.powerscaleLabel = QLabel() self.powerscaleLabel.setText("Power scale Factor") self.radii_scale_spinBox = QDoubleSpinBox(self.RadiiScaleGroupBox) self.radii_scale = 1.0 self.radii_scale_spinBox.setValue(self.radii_scale) self.radii_scale_spinBox.setDecimals(1) self.radii_scale_spinBox.setSingleStep(0.1) self.radii_scale_spinBox.setRange(0.2, 2.0) self.radii_scale_spinBox.valueChanged.connect(self.onRadiiScaleChanged) self.radiiscaleLabel = QLabel() self.radiiscaleLabel.setText("Linear Scale Factor") layout = QGridLayout() layout.addWidget(self.ManualPowerScalecheckbox, 1, 0, 1, 2) layout.addWidget(self.powerscaleLabel, 2, 0, 1, 2) layout.addWidget(self.power_scale_spinBox, 2, 1, 1, 2) layout.addWidget(self.radiiscaleLabel, 3, 0, 1, 2) layout.addWidget(self.radii_scale_spinBox, 3, 1, 1, 2) layout.setColumnStretch(0, 1) layout.setColumnStretch(1, 0) self.RadiiScaleGroupBox.setLayout(layout) def createBinsBox(self): self.binstable = QTableWidget(0, 4) self.binstable_isready = False labels = [ "no. of HKLs", "lower bin value", "upper bin value", "opacity" ] self.binstable.setHorizontalHeaderLabels(labels) self.binstable.horizontalHeader().setDefaultAlignment(Qt.AlignLeft) self.bindata_labeltxt = QLabel() self.bindata_labeltxt.setText("Data binned:") self.Nbins_spinBox = QSpinBox() self.Nbins_spinBox.setSingleStep(1) self.Nbins_spinBox.setRange(1, 40) self.Nbins_spinBox.valueChanged.connect(self.onNbinsChanged) self.Nbins_labeltxt = QLabel() self.Nbins_labeltxt.setText("Number of bins:") self.OpaqueAllCheckbox = QCheckBox() #self.OpaqueAllCheckbox.setTristate() self.OpaqueAllCheckbox.setText("Show all data in bins") self.OpaqueAllCheckbox.clicked.connect(self.onOpaqueAll) self.binstable.itemChanged.connect(self.onBinsTableItemChanged) self.binstable.itemSelectionChanged.connect( self.onBinsTableItemSelectionChanged) self.BinDataComboBox = QComboBox() self.BinDataComboBox.activated.connect(self.onBindataComboSelchange) self.BinsGroupBox = QGroupBox("Bins") layout = QGridLayout() layout.addWidget(self.bindata_labeltxt, 0, 0) layout.addWidget(self.BinDataComboBox, 0, 1) layout.addWidget(self.Nbins_labeltxt, 0, 2) layout.addWidget(self.Nbins_spinBox, 0, 3) layout.addWidget(self.OpaqueAllCheckbox, 1, 2) layout.addWidget(self.binstable, 2, 0, 1, 4) layout.setColumnStretch(0, 0) layout.setColumnStretch(1, 2) layout.setColumnStretch(3, 1) self.BinsGroupBox.setLayout(layout) def DebugInteractively(self): import code, traceback code.interact(local=locals(), banner="".join(traceback.format_stack(limit=10))) def CreateFunctionTabs(self): self.functionTabWidget = QTabWidget() tab1 = QWidget() layout1 = QGridLayout() layout1.addWidget(self.ExpansionBox, 0, 0) layout1.setRowStretch(0, 0) tab1.setLayout(layout1) tab2 = QWidget() layout2 = QGridLayout() self.fixedorientcheckbox = QCheckBox(self.sliceTabWidget) self.fixedorientcheckbox.setText( "Fix orientation but allow zoom and translation") self.fixedorientcheckbox.clicked.connect(self.onFixedorient) layout2.addWidget(self.fixedorientcheckbox, 0, 0) layout2.addWidget(self.sliceTabWidget, 1, 0) tab2.setLayout(layout2) tab3 = QWidget() layout3 = QGridLayout() layout3.addWidget(self.RadiiScaleGroupBox, 0, 0) tab3.setLayout(layout3) tab4 = QWidget() layout4 = QGridLayout() layout4.addWidget(self.BinsGroupBox, 0, 0) tab4.setLayout(layout4) self.functionTabWidget.addTab(tab1, "Expand") self.functionTabWidget.addTab(tab2, "Slice") self.functionTabWidget.addTab(tab3, "Size") self.functionTabWidget.addTab(tab4, "Bins") self.functionTabWidget.setDisabled(True) def SpacegroupSelchange(self, i): self.NGL_HKL_command("NGL_HKLviewer.spacegroup_choice = %d" % i) def find_free_port(self): import socket s = socket.socket() s.bind(('', 0)) # Bind to a free port provided by the host. port = s.getsockname()[1] s.close() return port def LaunchCCTBXPython(self): self.sockport = self.find_free_port() self.zmq_context = zmq.Context() self.socket = self.zmq_context.socket(zmq.PAIR) self.socket.bind("tcp://127.0.0.1:%s" % self.sockport) try: msg = self.socket.recv( flags=zmq.NOBLOCK) #To empty the socket from previous messages except Exception as e: pass cmdargs = 'cctbx.python.bat -i -c "from crys3d.hklview import cmdlineframes;' \ + ' myHKLview = cmdlineframes.HKLViewFrame(useGuiSocket=%s, high_quality=True,' %self.sockport \ + ' jscriptfname = \'%s\', ' %self.jscriptfname \ + ' verbose=%s, UseOSBrowser= %s )"\n' %(self.verbose, str(self.UseOSbrowser)) self.cctbxproc = subprocess.Popen(cmdargs, shell=True, stdin=subprocess.PIPE, stdout=sys.stdout, stderr=sys.stderr) #time.sleep(1) def NGL_HKL_command(self, cmdstr): #print("sending:\n" + cmdstr) self.socket.send(bytes(cmdstr, "utf-8"))
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 Ui_Transformation(object): def setupUi(self, Transformation, instrument): Transformation.setObjectName("Transformation") Transformation.resize(361, 171) self.frame_layout = QVBoxLayout(Transformation) self.frame_layout.setContentsMargins(4, 4, 4, 4) self.main_layout = QVBoxLayout() self.main_layout.setSpacing(4) self.name_layout = QHBoxLayout() self.name_layout.setSpacing(-1) self.name_label = QLabel("Name", Transformation) self._make_text_bold(self.name_label) self.name_layout.addWidget(self.name_label) self.name_line_edit = QLineEdit(Transformation) self.name_layout.addWidget(self.name_line_edit) self.main_layout.addLayout(self.name_layout) self._add_line() self.vector_label = QLabel("", Transformation) self._make_text_bold(self.vector_label) self.main_layout.addWidget(self.vector_label) self._set_up_vector_box(Transformation) self._add_line() self.value_label = QLabel("") self._make_text_bold(self.value_label) self.main_layout.addWidget(self.value_label) self.magnitude_widget = FieldWidget(hide_name_field=True, instrument=instrument) self.magnitude_widget.setFrameShape(QFrame.NoFrame) self.magnitude_widget.setMinimumHeight(40) self.main_layout.addWidget(self.magnitude_widget) self.ui_placeholder_layout = QFormLayout() self.value_spinbox = QDoubleSpinBox(Transformation) self.value_spinbox.setToolTip("Placeholder value for 3D view to use") self.value_spinbox.setDecimals(8) self.value_spinbox.setMaximumSize(QSize(100, 16777215)) self.ui_placeholder_layout.addRow("Value to use in 3D view:", self.value_spinbox) self.main_layout.addLayout(self.ui_placeholder_layout) self.set_spinbox_ranges() self.frame_layout.addLayout(self.main_layout) self.retranslateUi(Transformation) QMetaObject.connectSlotsByName(Transformation) def _add_line(self): line = QFrame() line.setFrameShape((QFrame.HLine)) line.setFrameShadow(QFrame.Sunken) self.main_layout.addWidget(line) @staticmethod def _make_text_bold(label: QLabel): font = label.font() font.setBold(True) label.setFont(font) def _set_up_vector_box(self, Transformation): self.xyz_layout = QHBoxLayout() self.x_layout = QFormLayout() self.x_spinbox = QDoubleSpinBox(Transformation) self.x_layout.addRow("x:", self.x_spinbox) self.xyz_layout.addLayout(self.x_layout) self.y_layout = QFormLayout() self.y_spinbox = QDoubleSpinBox(Transformation) self.y_layout.addRow("y:", self.y_spinbox) self.xyz_layout.addLayout(self.y_layout) self.z_layout = QFormLayout() self.z_spinbox = QDoubleSpinBox(Transformation) self.z_layout.addRow("z:", self.z_spinbox) self.xyz_layout.addLayout(self.z_layout) self.main_layout.addLayout(self.xyz_layout) def set_spinbox_ranges(self): self.spinboxes = [ self.x_spinbox, self.y_spinbox, self.z_spinbox, self.value_spinbox, ] for spinbox in self.spinboxes: spinbox.setRange(-10000000, 10000000) spinbox.setDecimals(5) def retranslateUi(self, Transformation): Transformation.setWindowTitle( QApplication.translate("Transformation", "GroupBox", None, -1)) Transformation.setTitle( QApplication.translate("Transformation", "Translation", None, -1))
class ColorForm(QWidget): """ Class for handling a field with a colormap, alpha, and visibility Attributes ---------- model : PlotModel The model instance used when updating information on the form. colormapBox : QComboBox Holds the string of the matplotlib colorbar being used visibilityBox : QCheckBox Indicator for whether or not the field should be visible alphaBox : QDoubleSpinBox Holds the alpha value for the displayed field data colormapBox : QComboBox Selector for colormap dataIndicatorCheckBox : QCheckBox Inidcates whether or not the data indicator will appear on the colorbar userMinMaxBox : QCheckBox Indicates whether or not the user defined values in the min and max will be used to set the bounds of the colorbar. maxBox : ScientificDoubleSpinBox Max value of the colorbar. If the userMinMaxBox is checked, this will be the user's input. If the userMinMaxBox is not checked, this box will hold the max value of the visible data. minBox : ScientificDoubleSpinBox Min value of the colorbar. If the userMinMaxBox is checked, this will be the user's input. If the userMinMaxBox is not checked, this box will hold the max value of the visible data. scaleBox : QCheckBox Indicates whether or not the data is displayed on a log or linear scale maskZeroBox : QCheckBox Indicates whether or not values equal to zero are displayed clipDataBox : QCheckBox Indicates whether or not values outside the min/max are displayed contoursBox : QCheckBox Inidicates whether or not data is displayed as contours contourLevelsLine : QLineEdit Controls the contours of the data. If this line contains a single integer, that number of levels is used to display the data. If a comma-separated set of values is entered, those values will be used as levels in the contour plot. """ def __init__(self, model, main_window, field, colormaps=None): super().__init__() self.model = model self.main_window = main_window self.field = field self.layout = QFormLayout() # Visibility check box self.visibilityBox = QCheckBox() visible_connector = partial(main_window.toggleTallyVisibility) self.visibilityBox.stateChanged.connect(visible_connector) # Alpha value self.alphaBox = QDoubleSpinBox() self.alphaBox.setDecimals(2) self.alphaBox.setRange(0, 1) self.alphaBox.setSingleStep(0.05) alpha_connector = partial(main_window.editTallyAlpha) self.alphaBox.valueChanged.connect(alpha_connector) # Color map selector self.colormapBox = QComboBox() if colormaps is None: colormaps = sorted(m for m in mcolormaps.datad if not m.endswith("_r")) for colormap in colormaps: self.colormapBox.addItem(colormap) cmap_connector = partial(main_window.editTallyDataColormap) self.colormapBox.currentTextChanged[str].connect(cmap_connector) # Data indicator line check box self.dataIndicatorCheckBox = QCheckBox() data_indicator_connector = partial(main_window.toggleTallyDataIndicator) self.dataIndicatorCheckBox.stateChanged.connect(data_indicator_connector) # User specified min/max check box self.userMinMaxBox = QCheckBox() minmax_connector = partial(main_window.toggleTallyDataUserMinMax) self.userMinMaxBox.stateChanged.connect(minmax_connector) # Data min spin box self.minBox = ScientificDoubleSpinBox() self.minBox.setMinimum(0.0) min_connector = partial(main_window.editTallyDataMin) self.minBox.valueChanged.connect(min_connector) # Data max spin box self.maxBox = ScientificDoubleSpinBox() self.maxBox.setMinimum(0.0) max_connector = partial(main_window.editTallyDataMax) self.maxBox.valueChanged.connect(max_connector) # Linear/Log scaling check box self.scaleBox = QCheckBox() scale_connector = partial(main_window.toggleTallyLogScale) self.scaleBox.stateChanged.connect(scale_connector) # Masking of zero values check box self.maskZeroBox = QCheckBox() zero_connector = partial(main_window.toggleTallyMaskZero) self.maskZeroBox.stateChanged.connect(zero_connector) # Clip data to min/max check box self.clipDataBox = QCheckBox() clip_connector = partial(main_window.toggleTallyDataClip) self.clipDataBox.stateChanged.connect(clip_connector) # Display data as contour plot check box self.contoursBox = QCheckBox() self.contoursBox.stateChanged.connect(main_window.toggleTallyContours) self.contourLevelsLine = QLineEdit() self.contourLevelsLine.textChanged.connect( main_window.editTallyContourLevels) # Organize widgets on layout self.layout.addRow("Visible:", self.visibilityBox) self.layout.addRow("Alpha: ", self.alphaBox) self.layout.addRow("Colormap: ", self.colormapBox) self.layout.addRow("Data Indicator: ", self.dataIndicatorCheckBox) self.layout.addRow("Custom Min/Max: ", self.userMinMaxBox) self.layout.addRow("Min: ", self.minBox) self.layout.addRow("Max: ", self.maxBox) self.layout.addRow("Log Scale: ", self.scaleBox) self.layout.addRow("Clip Data: ", self.clipDataBox) self.layout.addRow("Mask Zeros: ", self.maskZeroBox) self.layout.addRow("Contours: ", self.contoursBox) self.layout.addRow("Contour Levels:", self.contourLevelsLine) self.setLayout(self.layout) def updateTallyContours(self): cv = self.model.currentView self.contoursBox.setChecked(cv.tallyContours) self.contourLevelsLine.setText(cv.tallyContourLevels) def updateDataIndicator(self): cv = self.model.currentView self.dataIndicatorCheckBox.setChecked(cv.tallyDataIndicator) def setMinMaxEnabled(self, enable): enable = bool(enable) self.minBox.setEnabled(enable) self.maxBox.setEnabled(enable) def updateMinMax(self): cv = self.model.currentView self.minBox.setValue(cv.tallyDataMin) self.maxBox.setValue(cv.tallyDataMax) self.setMinMaxEnabled(cv.tallyDataUserMinMax) def updateTallyVisibility(self): cv = self.model.currentView self.visibilityBox.setChecked(cv.tallyDataVisible) def updateMaskZeros(self): cv = self.model.currentView self.maskZeroBox.setChecked(cv.tallyMaskZeroValues) def updateDataClip(self): cv = self.model.currentView self.clipDataBox.setChecked(cv.clipTallyData) def update(self): cv = self.model.currentView # set colormap value in selector cmap = cv.tallyDataColormap idx = self.colormapBox.findText(cmap, QtCore.Qt.MatchFixedString) self.colormapBox.setCurrentIndex(idx) self.alphaBox.setValue(cv.tallyDataAlpha) self.visibilityBox.setChecked(cv.tallyDataVisible) self.userMinMaxBox.setChecked(cv.tallyDataUserMinMax) self.scaleBox.setChecked(cv.tallyDataLogScale) self.updateMinMax() self.updateMaskZeros() self.updateDataClip() self.updateDataIndicator() self.updateTallyContours()
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 CleanSkinUI(QWidget): def __init__(self): QWidget.__init__(self) self.setParent(uiUtils.getTopLevelWidget(), 1) self.setAttribute(Qt.WA_DeleteOnClose) self.setWindowTitle("Clean Skin") self.setWindowIcon(QIcon(uiUtils.getIconFolder()+"arikara_CleanSkin.png")) lLayout = QFormLayout() # Max Weight self.dsb_maxWeight = QDoubleSpinBox() self.dsb_maxWeight.setRange(0.0, 1.0) self.dsb_maxWeight.setDecimals(4) self.dsb_maxWeight.setSingleStep(0.001) weight = 0.001 if cmds.optionVar(exists="ariCleanSkin_MW"): weight = cmds.optionVar(q="ariCleanSkin_MW") else: cmds.optionVar(fv=("ariCleanSkin_MW", weight)) self.dsb_maxWeight.setValue(weight) self.dsb_maxWeight.editingFinished.connect(self.dsb_maxWeightEdited) # Max Influence self.sb_maxInfluence = QSpinBox() self.sb_maxInfluence.setRange(1, 12) infl = 4 if cmds.optionVar(exists="ariCleanSkin_MI"): infl = cmds.optionVar(q="ariCleanSkin_MI") else: cmds.optionVar(iv=("ariCleanSkin_MI", infl)) self.sb_maxInfluence.setValue(infl) self.sb_maxInfluence.editingFinished.connect(self.sb_maxInfluenceEdited) self.pb_cleanSkin = QPushButton("Clean Skin") self.pb_cleanSkin.clicked.connect(self.cleanSkinCallback) lLayout.addRow("Max Weight:", self.dsb_maxWeight) lLayout.addRow("Max Influence:", self.sb_maxInfluence) lLayout.addRow(self.pb_cleanSkin) self.setLayout(lLayout) if cmds.optionVar(exists="ariCleanSkin_Geo"): geo = cmds.optionVar(q="ariCleanSkin_Geo") self.setGeometry(*geo) def cleanSkinCallback(self): cmds.undoInfo(openChunk=True, chunkName="Arikara Clean Skin") selection = cmds.ls(selection=True) maxWeight = self.dsb_maxWeight.value() maxInfluence = self.sb_maxInfluence.value() for obj in selection: try: cmds.arikaraInfluence(obj, maxInfluence=maxInfluence) except Exception as e: print e try: cmds.arikaraInfluence(obj, ru=maxWeight) except Exception as e: print e cmds.undoInfo(closeChunk=True) def updateGeometry(self): geo = self.geometry() cmds.optionVar(iv=("ariCleanSkin_Geo", geo.x())) cmds.optionVar(iva=("ariCleanSkin_Geo", geo.y())) cmds.optionVar(iva=("ariCleanSkin_Geo", geo.width())) cmds.optionVar(iva=("ariCleanSkin_Geo", geo.height())) def moveEvent(self, event): self.updateGeometry() def resizeEvent(self, event): self.updateGeometry() def dsb_maxWeightEdited(self): val = self.dsb_maxWeight.value() cmds.optionVar(fv=("ariCleanSkin_MW", val)) def sb_maxInfluenceEdited(self): val = self.sb_maxInfluence.value() cmds.optionVar(iv=("ariCleanSkin_MI", val))