class TimebaseBox(QGroupBox): def __init__(self, controller, parent=None): super().__init__("Timebase", parent=parent) self.controller = controller layout = QVBoxLayout() self.setLayout(layout) self.timebase_options = [ "100 us", "200 us", "500 us", "1 ms", "2 ms", "5 ms", "10 ms", "20 ms", ] self.combobox_timebase = QComboBox() self.combobox_timebase.addItems(self.timebase_options) self.combobox_timebase.setCurrentIndex(7) layout.addWidget(QLabel("time/div (1 div = 1/10 graph)")) layout.addWidget(self.combobox_timebase) self.combobox_timebase.currentTextChanged.connect(self.set_timebase) def set_timebase(self): timebase = self.combobox_timebase.currentText() self.controller.set_timebase(timebase)
def createEditor(self, parent, option, index): editor = QComboBox(parent) if isinstance(self.items, QStringListModel): editor.setModel(self.items) else: editor.addItems(self.items) return editor
class MainWindowUI: def setup_ui(self, win: QMainWindow) -> None: # ui widgets self.toolbar = QToolBar("main", parent=win) self.port_combobox1 = PortCombobox("") self.port_combobox2 = PortCombobox("") self.baudrate_combobox = QComboBox() self.monitor1 = QPlainTextEdit("") self.monitor2 = QPlainTextEdit("") self.btn_clear_monitor1 = QPushButton("Clear") self.btn_clear_monitor2 = QPushButton("Clear") self.group_monitor1 = QGroupBox("Monitor 1") self.group_monitor2 = QGroupBox("Monitor 2") # setup widgets self.monitor1.setReadOnly(True) self.monitor1.setLineWrapMode(QPlainTextEdit.NoWrap) self.monitor1.setUndoRedoEnabled(False) self.monitor2.setReadOnly(True) self.monitor2.setLineWrapMode(QPlainTextEdit.NoWrap) self.monitor2.setUndoRedoEnabled(False) self.baudrate_combobox.addItems([ "300", "1200", "2400", "4800", "9600", "19200", "38400", "57600", "74880", "115200", "230400", "250000", "500000", "1000000", "2000000", ]) self.baudrate_combobox.setCurrentText("9600") # setup layout win.addToolBar(self.toolbar) v_layout = QVBoxLayout() # type:ignore v_layout.addWidget(self.monitor1) v_layout.addWidget(self.btn_clear_monitor1) self.group_monitor1.setLayout(v_layout) v_layout = QVBoxLayout() # type:ignore v_layout.addWidget(self.monitor2) v_layout.addWidget(self.btn_clear_monitor2) self.group_monitor2.setLayout(v_layout) h_layout = QHBoxLayout() # type:ignore h_layout.addWidget(self.group_monitor1) h_layout.addWidget(self.group_monitor2) central_widget = QWidget() central_widget.setLayout(h_layout) win.setCentralWidget(central_widget)
def setup_ui(self): super(SettingUI, self).setup_ui() max_width_label = QLabel(text="最大宽度", alignment=QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) max_width_combo = QComboBox() max_width_combo.addItems(Globals.max_width_arr) max_width_combo.setCurrentIndex(self.max_width_index) max_width_combo.currentIndexChanged.connect(self.on_combo_changed) size_label = QLabel(text="输出字号", alignment=QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) size_spin = QSpinBox() size_spin.setRange(10, 64) size_spin.setValue(Globals.config.get(Globals.UserData.font_size)) size_spin.valueChanged.connect(self.on_save_font_size) output_name_label = QLabel(text="输出名称", alignment=QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) output_name_edit = QLineEdit( Globals.config.get(Globals.UserData.font_save_name)) output_name_edit.textEdited.connect(self.on_output_name_edited) output_label = QLabel(text="输出目录", alignment=QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) output_line_edit = QLineEdit( Globals.config.get(Globals.UserData.output_dir)) output_line_edit.setReadOnly(True) output_line_edit.cursorPositionChanged.connect( self.on_output_choose_clicked) mode_1_radio = QRadioButton("图集模式") mode_2_radio = QRadioButton("字体模式") mode_1_radio.setChecked(True) mode_1_radio.toggled.connect(self.on_mode_1_radio_toggled) mode_radio_group = QButtonGroup(self) mode_radio_group.addButton(mode_1_radio, 0) mode_radio_group.addButton(mode_2_radio, 1) self.main_layout.setColumnStretch(1, 1) self.main_layout.setColumnStretch(3, 1) self.main_layout.addWidget(mode_1_radio, 0, 0, 1, 1) self.main_layout.addWidget(mode_2_radio, 0, 1, 1, 1) self.main_layout.addWidget(output_name_label, 1, 0, 1, 1) self.main_layout.addWidget(output_name_edit, 1, 1, 1, 1) self.main_layout.addWidget(max_width_label, 1, 2, 1, 1) self.main_layout.addWidget(max_width_combo, 1, 3, 1, 1) self.main_layout.addWidget(output_label, 2, 0, 1, 1) self.main_layout.addWidget(output_line_edit, 2, 1, 1, 1) self.main_layout.addWidget(size_label, 2, 2, 1, 1) self.main_layout.addWidget(size_spin, 2, 3, 1, 1) self.max_width_combo = max_width_combo self.size_spin = size_spin self.output_name_edit = output_name_edit self.output_line_edit = output_line_edit
class DeviceConnectingManager(QDialog): def __init__( self, parent: QWidget, lcrmeter: LCRMeterIM3536, lcrmeter_status: DeviceStatus, stage_controller: StageControllerShot702, stage_controller_status: DeviceStatus, ) -> None: super().__init__(parent=parent) self._lcrmeter = lcrmeter self._lcrmeter_status = lcrmeter_status self._stage_controller = stage_controller self._stage_controller_status = stage_controller_status self._lcr_combobox_port = PortCombobox(LCRMeterIM3536.PORT_FILTER) self._lcr_combobox_baudrate = QComboBox() self._lcr_t_btn_connect = create_tool_button(is_text_beside_icon=True) self._stage_combobox_port = PortCombobox("") self._stage_t_btn_connect = create_tool_button( is_text_beside_icon=True) self._action_connect_lcr = create_action( self, text="Connect Port", icon=create_qicon(IconNames.ADD_GREEN), triggered=self._connect_lcr, ) self._action_disconnect_lcr = create_action( self, text="Disconnect Port", icon=create_qicon(IconNames.REMOVE_RED), triggered=self._disconnect_lcr, ) self._action_connect_stage_controller = create_action( self, text="Connect Port", icon=create_qicon(IconNames.ADD_GREEN), triggered=self._connect_stage_controller, ) self._action_disconnect_stage_controller = create_action( self, text="Disconnect Port", icon=create_qicon(IconNames.REMOVE_RED), triggered=self._disconnect_stage_controller, ) self._setup() def _setup(self): self._lcr_combobox_baudrate.addItems(LCRMeterIM3536.BAUDRATES) self._lcr_combobox_baudrate.setCurrentText( str(self._lcrmeter_status.baudrate)) if (description := self._lcrmeter_status.description) is not None: self._lcr_combobox_port.setItemText(0, description) if (description := self._stage_controller_status.description) is not None: self._stage_combobox_port.setItemText(0, description)
class SetSyncTimeWidget(QWidget): Sg_view_changed = Signal() def __init__(self, model: SettingsModel, parent=None): super(SetSyncTimeWidget, self).__init__(parent) self._time_list = ["5s", "10s", "15s", "15m", "30m", "45m"] self._time_in_sec = [] for curr_time in self._time_list: time_int = int(re.search(r'\d+', curr_time).group()) if 'm' in curr_time: time_int = time_int * 60 if 'h' in curr_time: time_int = time_int * 3600 self._time_in_sec.append(time_int) self._model = model self.setAccessibleName('InfoBox') self._titolo = QLabel() self._titolo.setText("Finestra Temporale") self._titolo.setAccessibleName('Title2') self.sottotitolo = QLabel() self.sottotitolo.setAccessibleName('Sottotitolo') self.sottotitolo.setText("Seleziona finestra temporale per la sincronizzazione") self.spaceLabel = QLabel(" ") self.time_box = QComboBox() self.time_box.wheelEvent = lambda event: None self.time_box.addItems(self._time_list) self.Sl_model_changed() layout = QVBoxLayout() layout.addWidget(self._titolo) layout.addWidget(self.sottotitolo) layout.addWidget(self.spaceLabel) layout.addWidget(self.time_box) self.setLayout(layout) # connect signal self.time_box.currentIndexChanged.connect(self.Sl_time_checked) @Slot() def Sl_time_checked(self): self.Sg_view_changed.emit() @Slot() def Sl_model_changed(self): time = self._model.get_sync_time() i: int = 0 for el in self._time_in_sec: if time == el: self.time_box.setCurrentIndex(i) i += 1
def __init__(self): super(MainWindow, self).__init__() self.setWindowTitle("My App") box = QComboBox() box.addItems(["One", "Two", "Three"]) box.currentIndexChanged.connect(self.index_changed) box.currentTextChanged.connect(self.text_changed) self.setCentralWidget(box)
class InterpolateBadsDialog(QDialog): def __init__(self, parent): super().__init__(parent) self.setWindowTitle("Interpolate bad channels") vbox = QVBoxLayout(self) grid = QGridLayout() grid.addWidget(QLabel("Reset bads:"), 0, 0) self.reset_bads_checkbox = QCheckBox() self.reset_bads_checkbox.setChecked(True) grid.addWidget(self.reset_bads_checkbox, 0, 1) grid.addWidget(QLabel("Mode:"), 1, 0) self.mode_select = QComboBox() self.modes = {"Accurate": "accurate", "Fast": "fast"} self.mode_select.addItems(self.modes.keys()) self.mode_select.setCurrentText("Accurate") grid.addWidget(self.mode_select, 1, 1) grid.addWidget(QLabel("Origin (x, y, z):"), 2, 0) hbox = QHBoxLayout() self.x = QDoubleSpinBox() self.x.setValue(0) self.x.setDecimals(3) hbox.addWidget(self.x) self.y = QDoubleSpinBox() self.y.setValue(0) self.y.setDecimals(3) hbox.addWidget(self.y) self.z = QDoubleSpinBox() self.z.setValue(0.04) self.z.setDecimals(3) hbox.addWidget(self.z) grid.addLayout(hbox, 2, 1) vbox.addLayout(grid) buttonbox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) vbox.addWidget(buttonbox) buttonbox.accepted.connect(self.accept) buttonbox.rejected.connect(self.reject) vbox.setSizeConstraint(QVBoxLayout.SetFixedSize) @property def origin(self): x = float(self.x.value()) y = float(self.y.value()) z = float(self.z.value()) return x, y, z @property def mode(self): return self.mode_select.currentText() @property def reset_bads(self): return self.reset_bads_checkbox.isChecked()
def setupWidgets(self): """ Set up the widgets and layouts for interface. """ dir_label = QLabel("Choose Directory:") self.dir_line_edit = QLineEdit() dir_button = QPushButton('...') dir_button.setToolTip("Select file directory.") dir_button.clicked.connect(self.setDirectory) self.change_name_edit = QLineEdit() self.change_name_edit.setToolTip( "Files will be appended with numerical values.For example: filename <b> 01 </b >.jpg") self.change_name_edit.setPlaceholderText("Change file names to...") rename_button = QPushButton("Rename Files") rename_button.setToolTip("Begin renaming files in directory.") rename_button.clicked.connect(self.renameFiles) file_exts = [".jpg", ".jpeg", ".png", ".gif", ".txt"] # Create combo box for selecting file extensions. ext_cb = QComboBox() self.cb_value = file_exts[0] ext_cb.setToolTip("Only files with this extension will be changed.") ext_cb.addItems(file_exts) ext_cb.currentTextChanged.connect(self.updateCbValue) # Text edit is for displaying the file names as they are updated. self.display_files_edit = QTextEdit() self.display_files_edit.setReadOnly(True) self.progress_bar = QProgressBar() self.progress_bar.setValue(0) # Set layout and widgets. grid = QGridLayout() grid.addWidget(dir_label, 0, 0) grid.addWidget(self.dir_line_edit, 1, 0, 1, 2) grid.addWidget(dir_button, 1, 2) grid.addWidget(self.change_name_edit, 2, 0) grid.addWidget(ext_cb, 2, 1) grid.addWidget(rename_button, 2, 2) grid.addWidget(self.display_files_edit, 3, 0, 1, 3) grid.addWidget(self.progress_bar, 4, 0, 1, 3) self.setLayout(grid)
class FindEventsDialog(QDialog): def __init__(self, parent, channels, default_stim): super().__init__(parent) self.setWindowTitle("Find Events") vbox = QVBoxLayout(self) grid = QGridLayout() grid.addWidget(QLabel("Stim channel:"), 0, 0) self.stimchan = QComboBox() self.stimchan.addItems(channels) self.stimchan.setCurrentIndex(default_stim) grid.addWidget(self.stimchan, 0, 1) grid.addWidget(QLabel("Consecutive"), 1, 0) self.consecutive = QCheckBox() self.consecutive.setChecked(True) grid.addWidget(self.consecutive, 1, 1) grid.addWidget(QLabel("Initial event"), 2, 0) self.initial_event = QCheckBox() self.initial_event.setChecked(True) grid.addWidget(self.initial_event, 2, 1) grid.addWidget(QLabel("Cast to unsigned integer"), 3, 0) self.uint_cast = QCheckBox() self.uint_cast.setChecked(True) grid.addWidget(self.uint_cast, 3, 1) grid.addWidget(QLabel("Minimum duration:"), 4, 0) self.minduredit = QSpinBox() self.minduredit.setMaximum(MAX_INT) grid.addWidget(self.minduredit, 4, 1) grid.addWidget(QLabel("Shortest event:"), 5, 0) self.shortesteventedit = QSpinBox() self.shortesteventedit.setMaximum(MAX_INT) grid.addWidget(self.shortesteventedit, 5, 1) vbox.addLayout(grid) buttonbox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) vbox.addWidget(buttonbox) buttonbox.accepted.connect(self.accept) buttonbox.rejected.connect(self.reject) vbox.setSizeConstraint(QVBoxLayout.SetFixedSize)
class KeyPressWidget(StepBaseWidget): def __init__(self, step: Steps.KeyPress, timeline): super(KeyPressWidget, self).__init__(step, timeline) detail_layout = self.ui.detailFrame.layout() # Key input self.key_label = QLabel("Key: ", self) self.key_line_edit = QLineEdit(self) self.key_line_edit.setMaxLength(1) self.key_line_edit.setText(self.step.key) self.key_line_edit.textChanged.connect(self.update_key) # Mod Input self.mod_label = QLabel("Mod: ", self) self.mod_combo = QComboBox(self) mod_list = ["None", "Ctrl", "Shift", "Alt", "Super"] self.mod_combo.addItems(mod_list) if self.step.mod: current_mod_index = mod_list.index(self.step.mod.capitalize()) self.mod_combo.setCurrentIndex(current_mod_index) self.mod_combo.currentIndexChanged.connect(self.update_mod) # Add to layout detail_layout.addWidget(self.key_label) detail_layout.addWidget(self.key_line_edit) detail_layout.addWidget(self.mod_label) detail_layout.addWidget(self.mod_combo) def update_key(self): if not self.key_line_edit.text(): self.key_line_edit.setText(" ") self.step.key = self.key_line_edit.text() def update_mod(self): if self.mod_combo.currentText() == "None": self.step.mod = None else: self.step.mod = self.mod_combo.currentText().lower()
class TriggerBox(QGroupBox): def __init__(self, controller, parent=None): super().__init__("Trigger", parent=parent) self.controller = controller self.setCheckable(True) self.setChecked(False) layout = QHBoxLayout() self.setLayout(layout) self.combobox_slope = QComboBox() self.combobox_slope.addItems(["Rising", "Falling", "Any"]) self.combobox_slope.setCurrentIndex(0) layout.addWidget(QLabel("Trigger slope")) layout.addWidget(self.combobox_slope) self.toggled.connect(self.controller.set_trigger_state) self.combobox_slope.currentTextChanged.connect( self.controller.set_trigger_slope)
class DeviceBox(QGroupBox): def __init__(self, controller, parent=None): super().__init__("Device", parent=parent) self.controller = controller self.is_connected = False layout = QVBoxLayout() self.setLayout(layout) self.button_refresh = QPushButton("Refresh") self.combobox_ports = QComboBox() self.button_connect = QPushButton("Connect") layout.addWidget(self.button_refresh) layout.addWidget(self.combobox_ports) layout.addWidget(self.button_connect) self.button_refresh.clicked.connect(self.refresh_ports) self.button_connect.clicked.connect(self.connect_to_device) def refresh_ports(self): self.combobox_ports.clear() self.combobox_ports.addItems(self.controller.get_ports_names()) def connect_to_device(self): if not self.is_connected: port = self.combobox_ports.currentText() self.controller.connect_to_device(port) else: self.controller.disconnect_device() self.is_connected = self.controller.is_device_connected() if self.is_connected: self.button_connect.setText("Disconnect") else: self.button_connect.setText("Connect")
class Page1Widget(QWidget): def __init__(self): super().__init__() # Create Widgets self.dropdown_quest = QComboBox() self.dropdown_quest.addItems(MODES) self.dropdown_quest.setCurrentText("Romaji") self.dropdown_ans = QComboBox() self.dropdown_ans.addItems(MODES) self.dropdown_also = QComboBox() self.dropdown_also.addItem("----") self.dropdown_also.addItems(MODES) self.spinbox_level = QSpinBox(Minimum=1, Maximum=2) self.list_groups = QListWidget(FixedWidth=W * .6) for group_name in GROUPS: item = QListWidgetItem(group_name) item.setCheckState(QtCore.Qt.Unchecked) self.list_groups.addItem(item) # Make Layout self.sub_layout = QVBoxLayout() self.sub_layout.addWidget(QLabel('Question:')) self.sub_layout.addWidget(self.dropdown_quest) self.sub_layout.addWidget(QLabel('Answer:')) self.sub_layout.addWidget(self.dropdown_ans) self.sub_layout.addWidget(QLabel('Also:')) self.sub_layout.addWidget(self.dropdown_also) self.sub_layout.addWidget(QLabel('Level:')) self.sub_layout.addWidget(self.spinbox_level) self.layout = QHBoxLayout(self) self.layout.addLayout(self.sub_layout) self.layout.addWidget(self.list_groups)
class UIDrawROIWindow: def setup_ui(self, draw_roi_window_instance, rois, dataset_rtss, signal_roi_drawn): """ this function is responsible for setting up the UI for DrawROIWindow param draw_roi_window_instance: the current drawing window instance. :param rois: the rois to be drawn :param dataset_rtss: the rtss to be written to :param signal_roi_drawn: the signal to be triggered when roi is drawn """ self.patient_dict_container = PatientDictContainer() self.rois = rois self.dataset_rtss = dataset_rtss self.signal_roi_drawn = signal_roi_drawn self.drawn_roi_list = {} self.standard_organ_names = [] self.standard_volume_names = [] self.standard_names = [] # Combination of organ and volume self.ROI_name = None # Selected ROI name self.target_pixel_coords = [] # This will contain the new pixel # coordinates specified by the min and max self.drawingROI = None self.slice_changed = False self.drawing_tool_radius = INITIAL_DRAWING_TOOL_RADIUS self.keep_empty_pixel = False # pixel density self.target_pixel_coords_single_array = [] # 1D array self.draw_roi_window_instance = draw_roi_window_instance self.colour = None self.ds = None self.zoom = 1.0 self.upper_limit = None self.lower_limit = None # is_four_view is set to True to stop the SUV2ROI button from appearing self.dicom_view = DicomAxialView(is_four_view=True) self.current_slice = self.dicom_view.slider.value() self.dicom_view.slider.valueChanged.connect(self.slider_value_changed) self.init_layout() QtCore.QMetaObject.connectSlotsByName(draw_roi_window_instance) def retranslate_ui(self, draw_roi_window_instance): """ this function retranslate the ui for draw roi window :param draw_roi_window_instance: the current drawing window instance. """ _translate = QtCore.QCoreApplication.translate draw_roi_window_instance.setWindowTitle( _translate("DrawRoiWindowInstance", "OnkoDICOM - Draw Region Of Interest")) self.roi_name_label.setText( _translate("ROINameLabel", "Region of Interest: ")) self.roi_name_line_edit.setText(_translate("ROINameLineEdit", "")) self.image_slice_number_label.setText( _translate("ImageSliceNumberLabel", "Slice Number: ")) self.image_slice_number_line_edit.setText( _translate("ImageSliceNumberLineEdit", str(self.dicom_view.current_slice_number))) self.image_slice_number_transect_button.setText( _translate("ImageSliceNumberTransectButton", "Transect")) self.image_slice_number_box_draw_button.setText( _translate("ImageSliceNumberBoxDrawButton", "Set Bounds")) self.image_slice_number_draw_button.setText( _translate("ImageSliceNumberDrawButton", "Draw")) self.image_slice_number_move_forward_button.setText( _translate("ImageSliceNumberMoveForwardButton", "")) self.image_slice_number_move_backward_button.setText( _translate("ImageSliceNumberMoveBackwardButton", "")) self.draw_roi_window_instance_save_button.setText( _translate("DrawRoiWindowInstanceSaveButton", "Save")) self.draw_roi_window_instance_cancel_button.setText( _translate("DrawRoiWindowInstanceCancelButton", "Cancel")) self.internal_hole_max_label.setText( _translate("InternalHoleLabel", "Maximum internal hole size (pixels): ")) self.internal_hole_max_line_edit.setText( _translate("InternalHoleInput", "9")) self.isthmus_width_max_label.setText( _translate("IsthmusWidthLabel", "Maximum isthmus width size (pixels): ")) self.isthmus_width_max_line_edit.setText( _translate("IsthmusWidthInput", "5")) self.min_pixel_density_label.setText( _translate("MinPixelDensityLabel", "Minimum density (pixels): ")) self.min_pixel_density_line_edit.setText( _translate("MinPixelDensityInput", "")) self.max_pixel_density_label.setText( _translate("MaxPixelDensityLabel", "Maximum density (pixels): ")) self.max_pixel_density_line_edit.setText( _translate("MaxPixelDensityInput", "")) self.toggle_keep_empty_pixel_label.setText( _translate("ToggleKeepEmptyPixelLabel", "Keep empty pixel: ")) self.draw_roi_window_viewport_zoom_label.setText( _translate("DrawRoiWindowViewportZoomLabel", "Zoom: ")) self.draw_roi_window_cursor_radius_change_label.setText( _translate("DrawRoiWindowCursorRadiusChangeLabel", "Cursor Radius: ")) self.draw_roi_window_instance_action_reset_button.setText( _translate("DrawRoiWindowInstanceActionClearButton", "Reset")) def init_layout(self): """ Initialize the layout for the DICOM View tab. Add the view widget and the slider in the layout. Add the whole container 'tab2_view' as a tab in the main page. """ # Initialise a DrawROIWindow if platform.system() == 'Darwin': self.stylesheet_path = "res/stylesheet.qss" else: self.stylesheet_path = "res/stylesheet-win-linux.qss" stylesheet = open(resource_path(self.stylesheet_path)).read() window_icon = QIcon() window_icon.addPixmap(QPixmap(resource_path("res/images/icon.ico")), QIcon.Normal, QIcon.Off) self.draw_roi_window_instance.setObjectName("DrawRoiWindowInstance") self.draw_roi_window_instance.setWindowIcon(window_icon) # Creating a form box to hold all buttons and input fields self.draw_roi_window_input_container_box = QFormLayout() self.draw_roi_window_input_container_box. \ setObjectName("DrawRoiWindowInputContainerBox") self.draw_roi_window_input_container_box. \ setLabelAlignment(Qt.AlignLeft) # Create a label for denoting the ROI name self.roi_name_label = QLabel() self.roi_name_label.setObjectName("ROINameLabel") self.roi_name_line_edit = QLineEdit() # Create an input box for ROI name self.roi_name_line_edit.setObjectName("ROINameLineEdit") self.roi_name_line_edit.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum) self.roi_name_line_edit.resize( self.roi_name_line_edit.sizeHint().width(), self.roi_name_line_edit.sizeHint().height()) self.roi_name_line_edit.setEnabled(False) self.draw_roi_window_input_container_box. \ addRow(self.roi_name_label, self.roi_name_line_edit) # Create horizontal box to store image slice number and backward, # forward buttons self.image_slice_number_box = QHBoxLayout() self.image_slice_number_box.setObjectName("ImageSliceNumberBox") # Create a label for denoting the Image Slice Number self.image_slice_number_label = QLabel() self.image_slice_number_label.setObjectName("ImageSliceNumberLabel") self.image_slice_number_box.addWidget(self.image_slice_number_label) # Create a line edit for containing the image slice number self.image_slice_number_line_edit = QLineEdit() self.image_slice_number_line_edit. \ setObjectName("ImageSliceNumberLineEdit") self.image_slice_number_line_edit. \ setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum) self.image_slice_number_line_edit.resize( self.image_slice_number_line_edit.sizeHint().width(), self.image_slice_number_line_edit.sizeHint().height()) self.image_slice_number_line_edit.setCursorPosition(0) self.image_slice_number_line_edit.setEnabled(False) self.image_slice_number_box. \ addWidget(self.image_slice_number_line_edit) # Create a button to move backward to the previous image self.image_slice_number_move_backward_button = QPushButton() self.image_slice_number_move_backward_button. \ setObjectName("ImageSliceNumberMoveBackwardButton") self.image_slice_number_move_backward_button.setSizePolicy( QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)) self.image_slice_number_move_backward_button.resize(QSize(24, 24)) self.image_slice_number_move_backward_button.clicked. \ connect(self.onBackwardClicked) icon_move_backward = QtGui.QIcon() icon_move_backward.addPixmap( QtGui.QPixmap( resource_path('res/images/btn-icons/backward_slide_icon.png'))) self.image_slice_number_move_backward_button.setIcon( icon_move_backward) self.image_slice_number_box. \ addWidget(self.image_slice_number_move_backward_button) # Create a button to move forward to the next image self.image_slice_number_move_forward_button = QPushButton() self.image_slice_number_move_forward_button. \ setObjectName("ImageSliceNumberMoveForwardButton") self.image_slice_number_move_forward_button.setSizePolicy( QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)) self.image_slice_number_move_forward_button.resize(QSize(24, 24)) self.image_slice_number_move_forward_button.clicked. \ connect(self.onForwardClicked) icon_move_forward = QtGui.QIcon() icon_move_forward.addPixmap( QtGui.QPixmap( resource_path('res/images/btn-icons/forward_slide_icon.png'))) self.image_slice_number_move_forward_button.setIcon(icon_move_forward) self.image_slice_number_box. \ addWidget(self.image_slice_number_move_forward_button) self.draw_roi_window_input_container_box. \ addRow(self.image_slice_number_box) # Create a horizontal box for containing the zoom function self.draw_roi_window_viewport_zoom_box = QHBoxLayout() self.draw_roi_window_viewport_zoom_box.setObjectName( "DrawRoiWindowViewportZoomBox") # Create a label for zooming self.draw_roi_window_viewport_zoom_label = QLabel() self.draw_roi_window_viewport_zoom_label. \ setObjectName("DrawRoiWindowViewportZoomLabel") # Create an input box for zoom factor self.draw_roi_window_viewport_zoom_input = QLineEdit() self.draw_roi_window_viewport_zoom_input. \ setObjectName("DrawRoiWindowViewportZoomInput") self.draw_roi_window_viewport_zoom_input. \ setText("{:.2f}".format(self.zoom * 100) + "%") self.draw_roi_window_viewport_zoom_input.setCursorPosition(0) self.draw_roi_window_viewport_zoom_input.setEnabled(False) self.draw_roi_window_viewport_zoom_input. \ setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum) self.draw_roi_window_viewport_zoom_input.resize( self.draw_roi_window_viewport_zoom_input.sizeHint().width(), self.draw_roi_window_viewport_zoom_input.sizeHint().height()) # Create 2 buttons for zooming in and out # Zoom In Button self.draw_roi_window_viewport_zoom_in_button = QPushButton() self.draw_roi_window_viewport_zoom_in_button. \ setObjectName("DrawRoiWindowViewportZoomInButton") self.draw_roi_window_viewport_zoom_in_button.setSizePolicy( QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)) self.draw_roi_window_viewport_zoom_in_button.resize(QSize(24, 24)) self.draw_roi_window_viewport_zoom_in_button. \ setProperty("QPushButtonClass", "zoom-button") icon_zoom_in = QtGui.QIcon() icon_zoom_in.addPixmap( QtGui.QPixmap( resource_path('res/images/btn-icons/zoom_in_icon.png'))) self.draw_roi_window_viewport_zoom_in_button.setIcon(icon_zoom_in) self.draw_roi_window_viewport_zoom_in_button.clicked. \ connect(self.onZoomInClicked) # Zoom Out Button self.draw_roi_window_viewport_zoom_out_button = QPushButton() self.draw_roi_window_viewport_zoom_out_button. \ setObjectName("DrawRoiWindowViewportZoomOutButton") self.draw_roi_window_viewport_zoom_out_button.setSizePolicy( QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)) self.draw_roi_window_viewport_zoom_out_button.resize(QSize(24, 24)) self.draw_roi_window_viewport_zoom_out_button. \ setProperty("QPushButtonClass", "zoom-button") icon_zoom_out = QtGui.QIcon() icon_zoom_out.addPixmap( QtGui.QPixmap( resource_path('res/images/btn-icons/zoom_out_icon.png'))) self.draw_roi_window_viewport_zoom_out_button.setIcon(icon_zoom_out) self.draw_roi_window_viewport_zoom_out_button.clicked. \ connect(self.onZoomOutClicked) self.draw_roi_window_viewport_zoom_box. \ addWidget(self.draw_roi_window_viewport_zoom_label) self.draw_roi_window_viewport_zoom_box. \ addWidget(self.draw_roi_window_viewport_zoom_input) self.draw_roi_window_viewport_zoom_box. \ addWidget(self.draw_roi_window_viewport_zoom_out_button) self.draw_roi_window_viewport_zoom_box. \ addWidget(self.draw_roi_window_viewport_zoom_in_button) self.draw_roi_window_input_container_box. \ addRow(self.draw_roi_window_viewport_zoom_box) self.init_cursor_radius_change_box() # Create field to toggle two options: Keep empty pixel or fill empty # pixel when using draw cursor self.toggle_keep_empty_pixel_box = QHBoxLayout() self.toggle_keep_empty_pixel_label = QLabel() self.toggle_keep_empty_pixel_label. \ setObjectName("ToggleKeepEmptyPixelLabel") # Create input for min pixel size self.toggle_keep_empty_pixel_combo_box = QComboBox() self.toggle_keep_empty_pixel_combo_box.addItems(["Off", "On"]) self.toggle_keep_empty_pixel_combo_box.setCurrentIndex(0) self.toggle_keep_empty_pixel_combo_box.setEnabled(False) self.toggle_keep_empty_pixel_combo_box. \ setObjectName("ToggleKeepEmptyPixelComboBox") self.toggle_keep_empty_pixel_combo_box. \ setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum) self.toggle_keep_empty_pixel_combo_box.resize( self.toggle_keep_empty_pixel_combo_box.sizeHint().width(), self.toggle_keep_empty_pixel_combo_box.sizeHint().height()) self.toggle_keep_empty_pixel_combo_box.currentIndexChanged.connect( self.toggle_keep_empty_pixel_box_index_changed) self.toggle_keep_empty_pixel_box. \ addWidget(self.toggle_keep_empty_pixel_label) self.toggle_keep_empty_pixel_box. \ addWidget(self.toggle_keep_empty_pixel_combo_box) self.draw_roi_window_input_container_box. \ addRow(self.toggle_keep_empty_pixel_box) # Create a horizontal box for transect and draw button self.draw_roi_window_transect_draw_box = QHBoxLayout() self.draw_roi_window_transect_draw_box. \ setObjectName("DrawRoiWindowTransectDrawBox") # Create a transect button self.image_slice_number_transect_button = QPushButton() self.image_slice_number_transect_button. \ setObjectName("ImageSliceNumberTransectButton") self.image_slice_number_transect_button.setSizePolicy( QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Minimum)) self.image_slice_number_transect_button.resize( self.image_slice_number_transect_button.sizeHint().width(), self.image_slice_number_transect_button.sizeHint().height()) self.image_slice_number_transect_button.clicked. \ connect(self.transect_handler) icon_transect = QtGui.QIcon() icon_transect.addPixmap( QtGui.QPixmap( resource_path('res/images/btn-icons/transect_icon.png'))) self.image_slice_number_transect_button.setIcon(icon_transect) self.draw_roi_window_transect_draw_box. \ addWidget(self.image_slice_number_transect_button) # Create a bounding box button self.image_slice_number_box_draw_button = QPushButton() self.image_slice_number_box_draw_button. \ setObjectName("ImageSliceNumberBoxDrawButton") self.image_slice_number_box_draw_button.setSizePolicy( QSizePolicy.MinimumExpanding, QSizePolicy.Minimum) self.image_slice_number_box_draw_button.resize( self.image_slice_number_box_draw_button.sizeHint().width(), self.image_slice_number_box_draw_button.sizeHint().height()) self.image_slice_number_box_draw_button.clicked. \ connect(self.onBoxDrawClicked) icon_box_draw = QtGui.QIcon() icon_box_draw.addPixmap( QtGui.QPixmap( resource_path('res/images/btn-icons/draw_bound_icon.png'))) self.image_slice_number_box_draw_button.setIcon(icon_box_draw) self.draw_roi_window_transect_draw_box. \ addWidget(self.image_slice_number_box_draw_button) # Create a draw button self.image_slice_number_draw_button = QPushButton() self.image_slice_number_draw_button. \ setObjectName("ImageSliceNumberDrawButton") self.image_slice_number_draw_button.setSizePolicy( QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Minimum)) self.image_slice_number_draw_button.resize( self.image_slice_number_draw_button.sizeHint().width(), self.image_slice_number_draw_button.sizeHint().height()) self.image_slice_number_draw_button.clicked.connect(self.onDrawClicked) icon_draw = QtGui.QIcon() icon_draw.addPixmap( QtGui.QPixmap(resource_path('res/images/btn-icons/draw_icon.png'))) self.image_slice_number_draw_button.setIcon(icon_draw) self.draw_roi_window_transect_draw_box. \ addWidget(self.image_slice_number_draw_button) self.draw_roi_window_input_container_box. \ addRow(self.draw_roi_window_transect_draw_box) # Create a contour preview button self.row_preview_layout = QtWidgets.QHBoxLayout() self.button_contour_preview = QtWidgets.QPushButton("Preview contour") self.button_contour_preview.clicked.connect(self.onPreviewClicked) self.row_preview_layout.addWidget(self.button_contour_preview) self.draw_roi_window_input_container_box. \ addRow(self.row_preview_layout) icon_preview = QtGui.QIcon() icon_preview.addPixmap( QtGui.QPixmap( resource_path('res/images/btn-icons/preview_icon.png'))) self.button_contour_preview.setIcon(icon_preview) # Create input line edit for alpha value self.label_alpha_value = QtWidgets.QLabel("Alpha value:") self.input_alpha_value = QtWidgets.QLineEdit("0.2") self.input_alpha_value. \ setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Minimum) self.input_alpha_value.resize( self.input_alpha_value.sizeHint().width(), self.input_alpha_value.sizeHint().height()) self.input_alpha_value.setValidator( QRegularExpressionValidator( QRegularExpression("^[0-9]*[.]?[0-9]*$"))) self.draw_roi_window_input_container_box. \ addRow(self.label_alpha_value, self.input_alpha_value) # Create a label for denoting the max internal hole size self.internal_hole_max_label = QLabel() self.internal_hole_max_label.setObjectName("InternalHoleLabel") # Create input for max internal hole size self.internal_hole_max_line_edit = QLineEdit() self.internal_hole_max_line_edit.setObjectName("InternalHoleInput") self.internal_hole_max_line_edit. \ setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Minimum) self.internal_hole_max_line_edit.resize( self.internal_hole_max_line_edit.sizeHint().width(), self.internal_hole_max_line_edit.sizeHint().height()) self.internal_hole_max_line_edit.setValidator( QRegularExpressionValidator( QRegularExpression("^[0-9]*[.]?[0-9]*$"))) self.draw_roi_window_input_container_box.addRow( self.internal_hole_max_label, self.internal_hole_max_line_edit) # Create a label for denoting the isthmus width size self.isthmus_width_max_label = QLabel() self.isthmus_width_max_label.setObjectName("IsthmusWidthLabel") # Create input for max isthmus width size self.isthmus_width_max_line_edit = QLineEdit() self.isthmus_width_max_line_edit.setObjectName("IsthmusWidthInput") self.isthmus_width_max_line_edit.setSizePolicy( QSizePolicy.MinimumExpanding, QSizePolicy.Minimum) self.isthmus_width_max_line_edit.resize( self.isthmus_width_max_line_edit.sizeHint().width(), self.isthmus_width_max_line_edit.sizeHint().height()) self.isthmus_width_max_line_edit.setValidator( QRegularExpressionValidator( QRegularExpression("^[0-9]*[.]?[0-9]*$"))) self.draw_roi_window_input_container_box.addRow( self.isthmus_width_max_label, self.isthmus_width_max_line_edit) # Create a label for denoting the minimum pixel density self.min_pixel_density_label = QLabel() self.min_pixel_density_label.setObjectName("MinPixelDensityLabel") # Create input for min pixel size self.min_pixel_density_line_edit = QLineEdit() self.min_pixel_density_line_edit.setObjectName("MinPixelDensityInput") self.min_pixel_density_line_edit.setSizePolicy( QSizePolicy.MinimumExpanding, QSizePolicy.Minimum) self.min_pixel_density_line_edit.resize( self.min_pixel_density_line_edit.sizeHint().width(), self.min_pixel_density_line_edit.sizeHint().height()) self.min_pixel_density_line_edit.setValidator( QRegularExpressionValidator( QRegularExpression("^[0-9]*[.]?[0-9]*$"))) self.draw_roi_window_input_container_box.addRow( self.min_pixel_density_label, self.min_pixel_density_line_edit) # Create a label for denoting the minimum pixel density self.max_pixel_density_label = QLabel() self.max_pixel_density_label.setObjectName("MaxPixelDensityLabel") # Create input for min pixel size self.max_pixel_density_line_edit = QLineEdit() self.max_pixel_density_line_edit.setObjectName("MaxPixelDensityInput") self.max_pixel_density_line_edit. \ setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Minimum) self.max_pixel_density_line_edit.resize( self.max_pixel_density_line_edit.sizeHint().width(), self.max_pixel_density_line_edit.sizeHint().height()) self.max_pixel_density_line_edit.setValidator( QRegularExpressionValidator( QRegularExpression("^[0-9]*[.]?[0-9]*$"))) self.draw_roi_window_input_container_box.addRow( self.max_pixel_density_label, self.max_pixel_density_line_edit) # Create a button to clear the draw self.draw_roi_window_instance_action_reset_button = QPushButton() self.draw_roi_window_instance_action_reset_button. \ setObjectName("DrawRoiWindowInstanceActionClearButton") self.draw_roi_window_instance_action_reset_button.setSizePolicy( QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Minimum)) reset_button = self.draw_roi_window_instance_action_reset_button self.draw_roi_window_instance_action_reset_button.resize( reset_button.sizeHint().width(), reset_button.sizeHint().height()) self.draw_roi_window_instance_action_reset_button.clicked. \ connect(self.onResetClicked) self.draw_roi_window_instance_action_reset_button. \ setProperty("QPushButtonClass", "fail-button") icon_clear_roi_draw = QtGui.QIcon() icon_clear_roi_draw.addPixmap( QtGui.QPixmap( resource_path('res/images/btn-icons/reset_roi_draw_icon.png'))) self.draw_roi_window_instance_action_reset_button. \ setIcon(icon_clear_roi_draw) self.draw_roi_window_input_container_box. \ addRow(self.draw_roi_window_instance_action_reset_button) # Create a horizontal box for saving and cancel the drawing self.draw_roi_window_cancel_save_box = QHBoxLayout() self.draw_roi_window_cancel_save_box. \ setObjectName("DrawRoiWindowCancelSaveBox") # Create an exit button to cancel the drawing # Add a button to go back/exit from the application self.draw_roi_window_instance_cancel_button = QPushButton() self.draw_roi_window_instance_cancel_button. \ setObjectName("DrawRoiWindowInstanceCancelButton") self.draw_roi_window_instance_cancel_button.setSizePolicy( QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Minimum)) self.draw_roi_window_instance_cancel_button.resize( self.draw_roi_window_instance_cancel_button.sizeHint().width(), self.draw_roi_window_instance_cancel_button.sizeHint().height()) self.draw_roi_window_instance_cancel_button. \ setCursor(QtGui.QCursor(QtCore.Qt.PointingHandCursor)) self.draw_roi_window_instance_cancel_button.clicked. \ connect(self.onCancelButtonClicked) self.draw_roi_window_instance_cancel_button. \ setProperty("QPushButtonClass", "fail-button") icon_cancel = QtGui.QIcon() icon_cancel.addPixmap( QtGui.QPixmap( resource_path('res/images/btn-icons/cancel_icon.png'))) self.draw_roi_window_instance_cancel_button.setIcon(icon_cancel) self.draw_roi_window_cancel_save_box. \ addWidget(self.draw_roi_window_instance_cancel_button) # Create a save button to save all the changes self.draw_roi_window_instance_save_button = QPushButton() self.draw_roi_window_instance_save_button. \ setObjectName("DrawRoiWindowInstanceSaveButton") self.draw_roi_window_instance_save_button.setSizePolicy( QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Minimum)) self.draw_roi_window_instance_save_button.resize( self.draw_roi_window_instance_save_button.sizeHint().width(), self.draw_roi_window_instance_save_button.sizeHint().height()) self.draw_roi_window_instance_save_button. \ setProperty("QPushButtonClass", "success-button") icon_save = QtGui.QIcon() icon_save.addPixmap( QtGui.QPixmap(resource_path('res/images/btn-icons/save_icon.png'))) self.draw_roi_window_instance_save_button.setIcon(icon_save) self.draw_roi_window_instance_save_button.clicked. \ connect(self.onSaveClicked) self.draw_roi_window_cancel_save_box. \ addWidget(self.draw_roi_window_instance_save_button) self.draw_roi_window_input_container_box. \ addRow(self.draw_roi_window_cancel_save_box) # Creating a horizontal box to hold the ROI view and slider self.draw_roi_window_instance_view_box = QHBoxLayout() self.draw_roi_window_instance_view_box. \ setObjectName("DrawRoiWindowInstanceViewBox") # Add View and Slider into horizontal box self.draw_roi_window_instance_view_box.addWidget(self.dicom_view) # Create a widget to hold the image slice box self.draw_roi_window_instance_view_widget = QWidget() self.draw_roi_window_instance_view_widget.setObjectName( "DrawRoiWindowInstanceActionWidget") self.draw_roi_window_instance_view_widget.setLayout( self.draw_roi_window_instance_view_box) # Create a horizontal box for containing the input fields and the # viewport self.draw_roi_window_main_box = QHBoxLayout() self.draw_roi_window_main_box.setObjectName("DrawRoiWindowMainBox") self.draw_roi_window_main_box. \ addLayout(self.draw_roi_window_input_container_box, 1) self.draw_roi_window_main_box. \ addWidget(self.draw_roi_window_instance_view_widget, 11) # Create a new central widget to hold the vertical box layout self.draw_roi_window_instance_central_widget = QWidget() self.draw_roi_window_instance_central_widget. \ setObjectName("DrawRoiWindowInstanceCentralWidget") self.draw_roi_window_instance_central_widget.setLayout( self.draw_roi_window_main_box) self.retranslate_ui(self.draw_roi_window_instance) self.draw_roi_window_instance.setStyleSheet(stylesheet) self.draw_roi_window_instance. \ setCentralWidget(self.draw_roi_window_instance_central_widget) QtCore.QMetaObject.connectSlotsByName(self.draw_roi_window_instance) def slider_value_changed(self): """ actions to be taken when slider value changes """ image_slice_number = self.current_slice # save progress self.save_drawing_progress(image_slice_number) self.set_current_slice(self.dicom_view.slider.value()) def set_current_slice(self, slice_number): """ set the current slice :param slice_number: the slice number to be set """ self.image_slice_number_line_edit.setText(str(slice_number + 1)) self.current_slice = slice_number self.dicom_view.update_view() # check if this slice has any drawings before if self.drawn_roi_list.get(self.current_slice) is not None: self.drawingROI = self.drawn_roi_list[ self.current_slice]['drawingROI'] self.ds = self.drawn_roi_list[self.current_slice]['ds'] self.dicom_view.view.setScene(self.drawingROI) self.enable_cursor_radius_change_box() self.drawingROI.clear_cursor(self.drawing_tool_radius) else: self.disable_cursor_radius_change_box() self.ds = None def onZoomInClicked(self): """ This function is used for zooming in button """ self.dicom_view.zoom *= 1.05 self.dicom_view.update_view(zoom_change=True) if self.drawingROI \ and self.drawingROI.current_slice == self.current_slice: self.dicom_view.view.setScene(self.drawingROI) self.draw_roi_window_viewport_zoom_input.setText( "{:.2f}".format(self.dicom_view.zoom * 100) + "%") self.draw_roi_window_viewport_zoom_input.setCursorPosition(0) def onZoomOutClicked(self): """ This function is used for zooming out button """ self.dicom_view.zoom /= 1.05 self.dicom_view.update_view(zoom_change=True) if self.drawingROI \ and self.drawingROI.current_slice == self.current_slice: self.dicom_view.view.setScene(self.drawingROI) self.draw_roi_window_viewport_zoom_input. \ setText("{:.2f}".format(self.dicom_view.zoom * 100) + "%") self.draw_roi_window_viewport_zoom_input.setCursorPosition(0) def toggle_keep_empty_pixel_box_index_changed(self): self.keep_empty_pixel = self.toggle_keep_empty_pixel_combo_box. \ currentText() == "On" self.drawingROI.keep_empty_pixel = self.keep_empty_pixel def onCancelButtonClicked(self): """ This function is used for canceling the drawing """ self.closeWindow() def onBackwardClicked(self): """ This function is used when backward button is clicked """ image_slice_number = self.current_slice # save progress if self.save_drawing_progress(image_slice_number): # Backward will only execute if current image slice is above 0. if int(image_slice_number) > 0: # decrements slice by 1 and update slider to move to correct # position self.dicom_view.slider.setValue(image_slice_number - 1) def onForwardClicked(self): """ This function is used when forward button is clicked """ image_slice_number = self.current_slice # save progress if self.save_drawing_progress(image_slice_number): pixmaps = self.patient_dict_container.get("pixmaps_axial") total_slices = len(pixmaps) # Forward will only execute if current image slice is below the # total number of slices. if int(image_slice_number) < total_slices: # increments slice by 1 and update slider to move to correct # position self.dicom_view.slider.setValue(image_slice_number + 1) def onResetClicked(self): """ This function is used when reset button is clicked """ self.dicom_view.image_display() self.dicom_view.update_view() self.isthmus_width_max_line_edit.setText("5") self.internal_hole_max_line_edit.setText("9") self.min_pixel_density_line_edit.setText("") self.max_pixel_density_line_edit.setText("") if hasattr(self, 'bounds_box_draw'): delattr(self, 'bounds_box_draw') if hasattr(self, 'drawingROI'): delattr(self, 'drawingROI') self.ds = None def transect_handler(self): """ Function triggered when the Transect button is pressed from the menu. """ pixmaps = self.patient_dict_container.get("pixmaps_axial") id = self.current_slice dt = self.patient_dict_container.dataset[id] rowS = dt.PixelSpacing[0] colS = dt.PixelSpacing[1] dt.convert_pixel_data() MainPageCallClass().run_transect( self.draw_roi_window_instance, self.dicom_view.view, pixmaps[id], dt._pixel_array.transpose(), rowS, colS, is_roi_draw=True, ) def save_drawing_progress(self, image_slice_number): """ this function saves the drawing progress on current slice :param image_slice_number: the slice number to be saved """ if self.slice_changed: if hasattr(self, 'drawingROI') and self.drawingROI \ and self.ds is not None \ and len(self.drawingROI.target_pixel_coords) != 0: alpha = float(self.input_alpha_value.text()) pixel_hull_list = calculate_concave_hull_of_points( self.drawingROI.target_pixel_coords, alpha) coord_list = [] for pixel_hull in pixel_hull_list: coord_list.append(pixel_hull) self.drawn_roi_list[image_slice_number] = { 'coords': coord_list, 'ds': self.ds, 'drawingROI': self.drawingROI } self.slice_changed = False return True else: return True return True def on_transect_close(self): """ Function triggered when transect is closed """ if self.upper_limit and self.lower_limit: self.min_pixel_density_line_edit.setText(str(self.lower_limit)) self.max_pixel_density_line_edit.setText(str(self.upper_limit)) self.dicom_view.update_view() def onDrawClicked(self): """ Function triggered when the Draw button is pressed from the menu. """ pixmaps = self.patient_dict_container.get("pixmaps_axial") if self.min_pixel_density_line_edit.text() == "" \ or self.max_pixel_density_line_edit.text() == "": QMessageBox.about(self.draw_roi_window_instance, "Not Enough Data", "Not all values are specified or correct.") else: # Getting most updated selected slice id = self.current_slice dt = self.patient_dict_container.dataset[id] dt.convert_pixel_data() # Path to the selected .dcm file location = self.patient_dict_container.filepaths[id] self.ds = pydicom.dcmread(location) min_pixel = self.min_pixel_density_line_edit.text() max_pixel = self.max_pixel_density_line_edit.text() # If they are number inputs if min_pixel.isdecimal() and max_pixel.isdecimal(): min_pixel = int(min_pixel) max_pixel = int(max_pixel) if min_pixel >= max_pixel: QMessageBox.about( self.draw_roi_window_instance, "Incorrect Input", "Please ensure maximum density is " "atleast higher than minimum density.") self.drawingROI = Drawing( pixmaps[id], dt._pixel_array.transpose(), min_pixel, max_pixel, self.patient_dict_container.dataset[id], self.draw_roi_window_instance, self.slice_changed, self.current_slice, self.drawing_tool_radius, self.keep_empty_pixel, set()) self.slice_changed = True self.dicom_view.view.setScene(self.drawingROI) self.enable_cursor_radius_change_box() else: QMessageBox.about(self.draw_roi_window_instance, "Not Enough Data", "Not all values are specified or correct.") def onBoxDrawClicked(self): """ Function triggered when bounding box button is pressed """ id = self.current_slice dt = self.patient_dict_container.dataset[id] dt.convert_pixel_data() pixmaps = self.patient_dict_container.get("pixmaps_axial") self.bounds_box_draw = DrawBoundingBox(pixmaps[id], dt) self.dicom_view.view.setScene(self.bounds_box_draw) self.disable_cursor_radius_change_box() def onSaveClicked(self): """ Function triggered when Save button is clicked """ # Make sure the user has clicked Draw first if self.save_drawing_progress(image_slice_number=self.current_slice): self.saveROIList() def saveROIList(self): """ Function triggered when saving ROI list """ roi_list = ROI.convert_hull_list_to_contours_data( self.drawn_roi_list, self.patient_dict_container) if len(roi_list) == 0: QMessageBox.about(self.draw_roi_window_instance, "No ROI Detected", "Please ensure you have drawn your ROI first.") return # The list of points will need to be converted into a # single-dimensional array, as RTSTRUCT contour data is stored in # such a way. i.e. [x, y, z, x, y, z, x, y, z, ..., ...] Create a # popup window that modifies the RTSTRUCT and tells the user that # processing is happening. connectSaveROIProgress(self, roi_list, self.dataset_rtss, self.ROI_name, self.roi_saved) def roi_saved(self, new_rtss): """ Function to call save ROI and display progress """ self.signal_roi_drawn.emit((new_rtss, {"draw": self.ROI_name})) QMessageBox.about(self.draw_roi_window_instance, "Saved", "New contour successfully created!") self.closeWindow() def onPreviewClicked(self): """ function triggered when Preview button is clicked """ if hasattr(self, 'drawingROI') and self.drawingROI and len( self.drawingROI.target_pixel_coords) > 0: alpha = float(self.input_alpha_value.text()) polygon_list = calculate_concave_hull_of_points( self.drawingROI.target_pixel_coords, alpha) self.drawingROI.draw_contour_preview(polygon_list) else: QMessageBox.about(self.draw_roi_window_instance, "Not Enough Data", "Please ensure you have drawn your ROI first.") def set_selected_roi_name(self, roi_name): """ function to set selected roi name :param roi_name: roi name selected """ roi_exists = False patient_dict_container = PatientDictContainer() existing_rois = patient_dict_container.get("rois") number_of_rois = len(existing_rois) # Check to see if the ROI already exists for key, value in existing_rois.items(): if roi_name in value['name']: roi_exists = True if roi_exists: QMessageBox.about(self.draw_roi_window_instance, "ROI already exists in RTSS", "Would you like to continue?") self.ROI_name = roi_name self.roi_name_line_edit.setText(self.ROI_name) def onRadiusReduceClicked(self): """ function triggered when user reduce cursor radius """ self.drawing_tool_radius = max(self.drawing_tool_radius - 1, 4) self.draw_roi_window_cursor_radius_change_input.setText( str(self.drawing_tool_radius)) self.draw_roi_window_cursor_radius_change_input.setCursorPosition(0) self.draw_cursor_when_radius_changed() def onRadiusIncreaseClicked(self): """ function triggered when user increase cursor radius """ self.drawing_tool_radius = min(self.drawing_tool_radius + 1, 25) self.draw_roi_window_cursor_radius_change_input.setText( str(self.drawing_tool_radius)) self.draw_cursor_when_radius_changed() def draw_cursor_when_radius_changed(self): """ function to update drawing cursor when radius changed """ if self.drawingROI.cursor: self.drawingROI.draw_cursor( self.drawingROI.current_cursor_x + self.drawing_tool_radius, self.drawingROI.current_cursor_y + self.drawing_tool_radius, self.drawing_tool_radius) else: self.drawingROI.draw_cursor( (self.drawingROI.min_x + self.drawingROI.max_x) / 2, (self.drawingROI.min_y + self.drawingROI.max_y) / 2, self.drawing_tool_radius, True) def init_cursor_radius_change_box(self): """ function to init cursor radius change box """ # Create a horizontal box for containing the cursor radius changing # function self.draw_roi_window_cursor_radius_change_box = QHBoxLayout() self.draw_roi_window_cursor_radius_change_box.setObjectName( "DrawRoiWindowCursorRadiusChangeBox") # Create a label for cursor radius change self.draw_roi_window_cursor_radius_change_label = QLabel() self.draw_roi_window_cursor_radius_change_label.setObjectName( "DrawRoiWindowCursorRadiusChangeLabel") # Create an input box for cursor radius self.draw_roi_window_cursor_radius_change_input = QLineEdit() self.draw_roi_window_cursor_radius_change_input.setObjectName( "DrawRoiWindowCursorRadiusChangeInput") self.draw_roi_window_cursor_radius_change_input.setText(str(19)) self.draw_roi_window_cursor_radius_change_input.setCursorPosition(0) self.draw_roi_window_cursor_radius_change_input.setEnabled(False) self.draw_roi_window_cursor_radius_change_input.setSizePolicy( QSizePolicy.Minimum, QSizePolicy.Minimum) self.draw_roi_window_cursor_radius_change_input.resize( self.draw_roi_window_cursor_radius_change_input.sizeHint().width(), self.draw_roi_window_cursor_radius_change_input.sizeHint().height( )) # Create 2 buttons for increasing and reducing cursor radius # Increase Button self.draw_roi_window_cursor_radius_change_increase_button = \ QPushButton() self.draw_roi_window_cursor_radius_change_increase_button. \ setObjectName("DrawRoiWindowCursorRadiusIncreaseButton") self.draw_roi_window_cursor_radius_change_increase_button. \ setSizePolicy(QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)) self.draw_roi_window_cursor_radius_change_increase_button.resize( QSize(24, 24)) self.draw_roi_window_cursor_radius_change_increase_button.setProperty( "QPushButtonClass", "zoom-button") icon_zoom_in = QtGui.QIcon() icon_zoom_in.addPixmap( QtGui.QPixmap( resource_path('res/images/btn-icons/zoom_in_icon.png'))) self.draw_roi_window_cursor_radius_change_increase_button.setIcon( icon_zoom_in) self.draw_roi_window_cursor_radius_change_increase_button.clicked. \ connect(self.onRadiusIncreaseClicked) # Reduce Button self.draw_roi_window_cursor_radius_change_reduce_button = QPushButton() self.draw_roi_window_cursor_radius_change_reduce_button.setObjectName( "DrawRoiWindowCursorRadiusReduceButton") self.draw_roi_window_cursor_radius_change_reduce_button.setSizePolicy( QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)) self.draw_roi_window_cursor_radius_change_reduce_button.resize( QSize(24, 24)) self.draw_roi_window_cursor_radius_change_reduce_button.setProperty( "QPushButtonClass", "zoom-button") icon_zoom_out = QtGui.QIcon() icon_zoom_out.addPixmap( QtGui.QPixmap( resource_path('res/images/btn-icons/zoom_out_icon.png'))) self.draw_roi_window_cursor_radius_change_reduce_button.setIcon( icon_zoom_out) self.draw_roi_window_cursor_radius_change_reduce_button.clicked. \ connect(self.onRadiusReduceClicked) self.draw_roi_window_cursor_radius_change_box.addWidget( self.draw_roi_window_cursor_radius_change_label) self.draw_roi_window_cursor_radius_change_box.addWidget( self.draw_roi_window_cursor_radius_change_input) self.draw_roi_window_cursor_radius_change_box.addWidget( self.draw_roi_window_cursor_radius_change_reduce_button) self.draw_roi_window_cursor_radius_change_box.addWidget( self.draw_roi_window_cursor_radius_change_increase_button) self.draw_roi_window_input_container_box.addRow( self.draw_roi_window_cursor_radius_change_box) self.draw_roi_window_cursor_radius_change_increase_button.setEnabled( False) self.draw_roi_window_cursor_radius_change_reduce_button.setEnabled( False) def disable_cursor_radius_change_box(self): """ function to disable cursor radius change box """ self.draw_roi_window_cursor_radius_change_reduce_button.setEnabled( False) self.draw_roi_window_cursor_radius_change_increase_button.setEnabled( False) self.toggle_keep_empty_pixel_combo_box.setEnabled(False) def enable_cursor_radius_change_box(self): """ function to enable cursor radius change box """ self.draw_roi_window_cursor_radius_change_reduce_button.setEnabled( True) self.draw_roi_window_cursor_radius_change_increase_button.setEnabled( True) self.toggle_keep_empty_pixel_combo_box.setEnabled(True) def closeWindow(self): """ function to close draw roi window """ self.drawn_roi_list = {} if hasattr(self, 'bounds_box_draw'): delattr(self, 'bounds_box_draw') if hasattr(self, 'drawingROI'): delattr(self, 'drawingROI') self.ds = None self.close()
class ImageManipulation(QWidget): def __init__(self, img): super().__init__() # Declare Widgets self.edit_label = QLabel('Change your image') # set up list and combo box option self.my_list = [ "Pick a value", "Luminosity", "Contrast", "Colorize", "Sepia", "Negative", "Grayscale", "None" ] self.my_combo_box = QComboBox() self.my_combo_box.addItems(self.my_list) self.edit_btn = QPushButton("Edit") # Create U.I. Layout mbox = QHBoxLayout() vbox = QVBoxLayout() vbox.addWidget(self.edit_label) vbox.addWidget(self.my_combo_box) vbox.addWidget(self.edit_btn) mbox.addLayout(vbox) image = Image.open(requests.get(img['urls']['thumb'], stream=True).raw) editpath = "./editing/edit.jpg" image.save(editpath) self.lbl = QLabel() pix = QPixmap(editpath) self.lbl.setPixmap(pix) mbox.addWidget(self.lbl) self.setLayout(mbox) # apply layout to this class # when button is clicked send lineedit and combo box info to on_submit self.edit_btn.clicked.connect(self.on_edit) @Slot() def on_edit(self): # set up im_edit as which filter the user chose im_edit = self.my_combo_box.currentText() # take the image to edit and load it input_image = Image.open("./editing/edit.jpg") input_pixels = input_image.load() output_image = Image.new("RGB", input_image.size) draw = ImageDraw.Draw(output_image) # Options are: ["Pick a value", "Luminosity", "Contrast", "Colorize", "Sepia", "Negative", "Grayscale", "None"] # Luminostity brightens the image overall if (im_edit == "Luminosity"): luminosity = 80 # Generate image for x in range(output_image.width): for y in range(output_image.height): r, g, b = input_pixels[x, y] r = int(r + luminosity) g = int(g + luminosity) b = int(b + luminosity) draw.point((x, y), (r, g, b)) output_image.show() # Contrast makes the image slightly darker overall elif (im_edit == "Contrast"): # Find minimum and maximum luminosity imin = 255 imax = 0 for x in range(input_image.width): for y in range(input_image.height): r, g, b = input_pixels[x, y] i = (r + g + b) / 3 imin = min(imin, i) imax = max(imax, i) # Generate image for x in range(output_image.width): for y in range(output_image.height): r, g, b = input_pixels[x, y] # Current luminosity i = (r + g + b) / 3 # New luminosity ip = 255 * (i - imin) / (imax - imin) r = int(r * ip / i) g = int(g * ip / i) b = int(b * ip / i) draw.point((x, y), (r, g, b)) output_image.show() # Colorize increases one color in the image elif (im_edit == "Colorize"): # Square distance between 2 colors def distance2(color1, color2): r1, g1, b1 = color1 r2, g2, b2 = color2 return (r1 - r2)**2 + (g1 - g2)**2 + (b1 - b2)**2 color_to_change = (0, 0, 255) threshold = 220 # Generate image for x in range(output_image.width): for y in range(output_image.height): r, g, b = input_pixels[x, y] if distance2(color_to_change, input_pixels[x, y]) < threshold**2: r = int(r * .5) g = int(g * 1.25) b = int(b * .5) draw.point((x, y), (r, g, b)) output_image.show() # Sepia increases the red and decreases the blue value depending on the intensity elif (im_edit == "Sepia"): def sepia(pixel): if pixel[0] < 63: r, g, b = int(pixel[0] * 1.1), pixel[1], int(pixel[2] * .9) elif pixel[0] > 62 and pixel[0] < 192: r, g, b = int(pixel[0] * 1.15), pixel[1], int(pixel[2] * .85) else: r = int(pixel[0] * 1.08) if r > 255: r = 255 g, b = pixel[1], pixel[2] // 2 return r, g, b sepia_list = map(sepia, input_image.getdata()) output_image.putdata(list(sepia_list)) output_image.show() # Negative swaps the rgb values to their opposite counterparts elif (im_edit == "Negative"): negative_list = [(255 - p[0], 255 - p[1], 255 - p[2]) for p in input_image.getdata()] output_image.putdata(negative_list) output_image.show() # Grayscale averages the rgb values and creates the gray version of the image elif (im_edit == "Grayscale"): new_list = [((a[0] + a[1] + a[2]) // 3, ) * 3 for a in input_image.getdata()] output_image.putdata(new_list) output_image.show() else: #"Pick a value" or "None" input_image.show()
def createEditor(self, parent, option, index): editor = QComboBox(parent) editor.addItems(channel_types) editor.currentIndexChanged.connect(self.commit_data) return editor
def startTable(self): for col in range(self.Tabela.columnCount()): combo = QComboBox() combo.addItems(["Selecionar","Data & Hora","Prec. Observada","Data","Hora","Nível do Rio"]) self.Tabela.setCellWidget(0, col, combo)
class RunICADialog(QDialog): def __init__(self, parent, nchan, methods): super().__init__(parent) self.setWindowTitle("Run ICA") vbox = QVBoxLayout(self) grid = QGridLayout() grid.addWidget(QLabel("Method:"), 0, 0) self.method = QComboBox() self.method.addItems(methods) self.method.setCurrentIndex(0) self.method.currentIndexChanged.connect(self.toggle_options) grid.addWidget(self.method, 0, 1) self.extended_label = QLabel("Extended:") grid.addWidget(self.extended_label, 1, 0) self.extended = QCheckBox() self.extended.setChecked(True) grid.addWidget(self.extended, 1, 1) self.ortho_label = QLabel("Orthogonal:") grid.addWidget(self.ortho_label, 2, 0) self.ortho = QCheckBox() self.ortho.setChecked(False) grid.addWidget(self.ortho, 2, 1) if "Picard" not in methods: self.ortho_label.hide() self.ortho.hide() grid.addWidget(QLabel("Number of components:"), 3, 0) self.n_components = QSpinBox() self.n_components.setRange(0, nchan) self.n_components.setValue(nchan) self.n_components.setAlignment(Qt.AlignRight) grid.addWidget(self.n_components, 3, 1) grid.addWidget(QLabel("Exclude bad segments:"), 4, 0) self.exclude_bad_segments = QCheckBox() self.exclude_bad_segments.setChecked(True) grid.addWidget(self.exclude_bad_segments, 4, 1) vbox.addLayout(grid) buttonbox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) vbox.addWidget(buttonbox) buttonbox.accepted.connect(self.accept) buttonbox.rejected.connect(self.reject) vbox.setSizeConstraint(QVBoxLayout.SetFixedSize) self.toggle_options() @Slot() def toggle_options(self): """Toggle extended options.""" if self.method.currentText() == "Picard": # enable extended and ortho self.extended_label.setEnabled(True) self.extended.setEnabled(True) self.ortho_label.setEnabled(True) self.ortho.setEnabled(True) elif self.method.currentText() == "Infomax": # enable extended self.extended_label.setEnabled(True) self.extended.setEnabled(True) self.ortho_label.setEnabled(False) self.ortho.setChecked(False) self.ortho.setEnabled(False) else: self.extended_label.setEnabled(False) self.extended.setChecked(False) self.extended.setEnabled(False) self.ortho_label.setEnabled(False) self.ortho.setChecked(False) self.ortho.setEnabled(False)
class PredictionWindow(QWidget): """Subwindow dedicated to random forest prediction functions.""" # Private Instance Attributes: # - _predict_btn: Button that signals for a prediction to be made. # - _predict_btn: Button that signals for the selected model to be deleted. # - _model: The RandomForest model currently loaded. # - _model_info: QPlainTextEdit widget displaying information about the selected model. # - _target_date: Calendar widget for the user to select a target prediction date. # -_plot_window: Window for displaying historical information with a prediction. _predict_btn: QDialogButtonBox _delete_btn: QDialogButtonBox _model: QComboBox _model_info: QPlainTextEdit _target_date: QCalendarWidget _plot_window: QMainWindow def __init__(self) -> None: super().__init__() main_layout = QGridLayout() button_box = self._create_button_box() main_layout.addWidget(self._create_options_group_box(), 0, 0) main_layout.addWidget(button_box, 1, 0) main_layout.setSizeConstraint(QLayout.SetMinimumSize) self.setLayout(main_layout) self._refresh_model_info() self.setWindowTitle('Predict') self._plot_window = QMainWindow() def show(self) -> None: """Override of QWidget's show() function. Refreshes window and then shows the window. """ self._refresh_lists() return super().show() @property def _selected_model(self) -> Union[RandomForest, None]: """Gets the currently selected model.""" model_name = self._model.currentText() if model_name != '': try: return load_model(model_name) except pickle.UnpicklingError: self._error_event(f'{model_name} is an invalid model.') return None else: return None def _create_button_box(self) -> QDialogButtonBox: """Creates the lower control buttons at the bottom of the window.""" button_box = QDialogButtonBox() self._predict_btn = button_box.addButton('Predict', QDialogButtonBox.ActionRole) self._delete_btn = button_box.addButton('Delete Model', QDialogButtonBox.ActionRole) refresh_btn = button_box.addButton('Refresh &Options', QDialogButtonBox.ActionRole) self._predict_btn.clicked.connect(self._predict) refresh_btn.clicked.connect(self._refresh_lists) self._delete_btn.clicked.connect(self._delete) return button_box def _create_options_group_box(self) -> QGroupBox: """Returns the group of prediction options.""" options_group_box = QGroupBox("Options") options_layout = QGridLayout() left_options = QGridLayout() right_options = QGridLayout() date_label = QLabel("Target Date:") self._target_date = QCalendarWidget() left_options.addWidget(date_label, 0, 0) left_options.addWidget(self._target_date, 1, 0, 1, 3) left_options.setColumnStretch(0, 1) self._model = QComboBox() self._model_info = QPlainTextEdit() self._model_info.setReadOnly(True) self._model.currentTextChanged.connect(self._refresh_model_info) self._refresh_lists() models_label = QLabel("Models:") info_label = QLabel("Model Information:") right_options.addWidget(models_label, 0, 0) right_options.addWidget(self._model, 1, 0) right_options.addWidget(info_label, 2, 0) right_options.addWidget(self._model_info, 3, 0) options_layout.addLayout(left_options, 0, 0) options_layout.addLayout(right_options, 0, 1) options_group_box.setLayout(options_layout) return options_group_box def _delete(self) -> None: """Deletes the currently selected dataset.""" self.setEnabled(False) name = self._model.currentText() warning = f'Are you sure you want to delete {name}?' response = QMessageBox.warning(self, self.tr("Delete Model"), warning, QMessageBox.Yes, QMessageBox.No) if response == QMessageBox.Yes: data_ingest.delete_data(name, file_type='model') self._refresh_lists() self.setEnabled(True) def _refresh_lists(self) -> None: """Refreshes avaliable datasets for training.""" self._model.clear() data_list = data_ingest.get_avaliable_data(search_type='model') self._model.addItems(data_list) def _refresh_model_info(self) -> None: """Refreshes avaliable features for the selected target.""" self._predict_btn.setEnabled(False) self._target_date.setEnabled(False) self._model_info.clear() model_name = self._model.currentText() model = self._selected_model if model is None: self._delete_btn.setEnabled(False) return None self._delete_btn.setEnabled(True) self._display_model_info(model) req_features = model.window.req_features avaliable_sym = data_ingest.get_avaliable_sym() if len(req_features - avaliable_sym) != 0: self._error_event( f'Missing required data for {model_name}: {req_features - avaliable_sym}' ) return None dfs = load_corresponding_dataframes(model) grouped_dataframe = data_ingest.create_grouped_dataframe(dfs) date_offset = pd.DateOffset(days=model.window.target_shift) self._target_date.setMaximumDate(grouped_dataframe.index.max() + date_offset) self._target_date.setMinimumDate(grouped_dataframe.index.min() + date_offset) self._target_date.setEnabled(True) self._predict_btn.setEnabled(True) return None def _display_model_info(self, model: RandomForest) -> None: """Updates model info box to display current model's information.""" self._model_info.appendPlainText( f'Target Feature Name: \n{model.window.target_lbl}') self._model_info.appendPlainText('Window Information:') self._model_info.appendPlainText( f'\t- Window Size: {model.window.window_size}') self._model_info.appendPlainText( f'\t- Target Shift: {model.window.target_shift}') self._model_info.appendPlainText( f'\t- Required Features: {model.window.req_features}') self._model_info.appendPlainText('Forest Information:') self._model_info.appendPlainText( f'\t- Number of Trees: {model.forest.n_trees}') self._model_info.appendPlainText( f'\t- Tree Max Depth: {model.forest.max_depth}') self._model_info.appendPlainText(f'\t- Seed: {model.forest.seed}') def _predict(self) -> None: """Creates a model prediction using the selected target date and model.""" self.setEnabled(False) self._predict_btn.setEnabled(False) model = self._selected_model if model is None: self.setEnabled(True) return None target_date = self._target_date.selectedDate().toPython() try: dfs = load_corresponding_dataframes(model) prediction_input = data_ingest.create_input( model.window.window_size, model.window.target_shift, target_date, dfs) except ce.MissingData: self._error_event( 'Missing required data. Could be that loaded datasets have holes.' ) self.setEnabled(True) return None prediction = model.predict(prediction_input) historical_dfs = load_corresponding_dataframes(model, 'target') if len(historical_dfs) == 0: self._prediction_historical_error(prediction) else: self._plot_prediction(historical_dfs, model, prediction, target_date) self._predict_btn.setEnabled(True) self.setEnabled(True) return None def _plot_prediction(self, historical_dfs: list[pd.DataFrame], model: RandomForest, prediction: ndarray, target_date: datetime.date) -> None: """Opens a window with a plot of the historical target data as well as the prediction the model made.""" hdf = historical_dfs[0] for frame in historical_dfs[1:]: hdf = hdf.combine_first(frame) window_end = target_date - \ pd.DateOffset(days=model.window.target_shift) window_start = window_end - pd.DateOffset(days=30 - 1) hdf = pd.Series( hdf.loc[window_end:window_start][model.window.target_lbl]) hdf_data = hdf.to_list() hdf_dates = hdf.index hdf_dates = [ts.to_pydatetime().timestamp() for ts in hdf_dates] b_axis = pg.DateAxisItem(orientation='bottom') b_axis.setLabel('Date') plot = PlotWidget(axisItems={'bottom': b_axis}) target_time = datetime.combine(target_date, datetime.min.time()) plot.addLegend() plot.plot(x=hdf_dates, y=hdf_data, name=f'Historical {model.window.target_lbl}') plot.plot(x=[target_time.timestamp()], y=prediction, pen=None, symbol='o', name=f'Predicted Value: {prediction[0]}') model_name = self._model.currentText() self._plot_window.setWindowTitle(f'{model_name} Prediction') self._plot_window.setCentralWidget(plot) self._plot_window.show() def _prediction_historical_error(self, prediction: list) -> None: """Displays a message for when historical target is unavalable such that a graph can't be made.""" QMessageBox.information( self, self.tr("Information"), f'Prediction was: {prediction}. \n ' 'Unable to display graph due to missing historical data.', QtWidgets.QMessageBox.Ok) def _error_event( self, error: str, choice: bool = False, btn: QMessageBox = QMessageBox.Abort ) -> Union[QMessageBox.Ignore, QMessageBox.Abort, None]: """Displays an error message with the given error.""" if choice: response = QMessageBox.critical(self, self.tr("Error"), error, btn, QMessageBox.Ignore) return response else: QMessageBox.critical(self, self.tr("Error"), error, QMessageBox.Ok) return None
class MyWidget(QWidget): def __init__(self): QWidget.__init__(self) self.init_ui() self.combobox.currentTextChanged.connect(self.slot_combo_textchanged) self.btn_open_conn.clicked.connect(self.slot_conn_clicked) self.btn_close_conn.clicked.connect(self.slot_conn_close) self.btn_status.clicked.connect(self.slot_send_status_packet) self.btn_head.clicked.connect(self.slot_send_head_packet) self.btn_motion.clicked.connect(self.slof_send_motion_packet) def slot_conn_close(self): #TODO 关闭其他窗口 self.fd.close() self.set_send_btn_statu(False) def slot_send_status_packet(self): statuswidget = StatusWidget(self.fd) statuswidget.show() def slot_send_head_packet(self): headwidget = HeadWidget(self.fd) headwidget.show() def slof_send_motion_packet(self): motionwidget = MotionWidget(self.fd) motionwidget.show() pass def init_ui(self): self.tuple_method = ("Connect to Server", "Connect to /dev") self.combobox = QComboBox() self.combobox.addItems(self.tuple_method) self.addr_edit = QLineEdit() self.port_edit = QLineEdit() self.btn_open_conn = QPushButton("Connect/Open") self.btn_close_conn = QPushButton("Close Conn") self.fd = None self.method_layout = QVBoxLayout() self.method_layout.addWidget(self.combobox) self.method_layout.addWidget(self.addr_edit) self.method_layout.addWidget(self.port_edit) self.method_layout.addWidget(self.btn_open_conn) self.method_layout.addWidget(self.btn_close_conn) self.btn_status = QPushButton("Send Status Packet") self.btn_head = QPushButton("Send Head Packet") self.btn_motion = QPushButton("Send Motion Packet") self.packet_layout = QVBoxLayout() self.packet_layout.addWidget(self.btn_status) self.packet_layout.addWidget(self.btn_head) self.packet_layout.addWidget(self.btn_motion) self.main_layout = QVBoxLayout() self.main_layout.addLayout(self.method_layout) self.main_layout.addLayout(self.packet_layout) self.setLayout(self.main_layout) self.set_send_btn_statu(False) def set_send_btn_statu(self, statu): self.btn_motion.setEnabled(statu) self.btn_head.setEnabled(statu) self.btn_status.setEnabled(statu) self.btn_close_conn.setEnabled(statu) self.btn_open_conn.setEnabled(True if statu == False else False) def slot_combo_textchanged(self, current_text): if current_text == "Connect to /dev": self.port_edit.setVisible(False) else: self.port_edit.setVisible(True) def slot_conn_clicked(self): # try: if self.combobox.currentText() == "Connect to /dev": self.fd = open(self.addr_edit.text(), "wb") elif self.combobox.currentText() == "Connect to Server": self.fd = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.fd.connect(("127.0.0.1", int(self.port_edit.text()))) # except : # pass # TODO except QMessageBox.information(self, "success", "connected") self.set_send_btn_statu(True)
class SetQuotaDiskWidget(QWidget): Sg_view_changed = Signal() def __init__(self, model: SettingsModel, parent=None): super(SetQuotaDiskWidget, self).__init__(parent) self._model = model self.setAccessibleName("InfoBox") self.title = QLabel() self.title.setText("Spazio di archiviazione") self.title.setAccessibleName("Title2") self.sottotitolo = QLabel() self.sottotitolo.setAccessibleName('Sottotitolo') self.sottotitolo.setText( "Cambia lo spazio di archiviazione destinato alla cartella sincronizzata" ) # Barra riempimento disco self.progress_label = QLabel() self.progress_label.setText("Spazio occupato:") self.disk_progress = QProgressBar() self.disk_progress.setFormat("") self.disk_quota = QLabel() # Modifica spazio dedicato self.spaceLabel = QLabel(" ") self.dedicated_space = QLineEdit() self.dedicated_space.setValidator(QDoubleValidator()) self.sizes_box = QComboBox() self.sizes_box.wheelEvent = lambda event: None _path_size = bitmath.parse_string(model.convert_size(model.get_size())) _disk_free = bitmath.parse_string( model.convert_size(model.get_free_disk())) self.populate_size_box(_path_size, _disk_free) self.change_quota_button = QPushButton("Cambia quota disco") self.change_quota_button.setMaximumWidth(150) self.change_quota_button.clicked.connect( self.Sl_dedicated_space_changed) self.dedicated_space.returnPressed.connect( self.Sl_dedicated_space_changed) self.buttonLayout = QHBoxLayout() self.buttonLayout.addWidget(self.spaceLabel) self.buttonLayout.addWidget(self.change_quota_button) self.buttonLayout.addWidget(self.spaceLabel) set_space_layout = QHBoxLayout() set_space_layout.addWidget(self.dedicated_space) set_space_layout.addWidget(self.sizes_box) quota_layout = QHBoxLayout() quota_layout.setAlignment(Qt.AlignLeft) quota_layout.addWidget(self.progress_label) quota_layout.addWidget(self.disk_quota) # layout disk_layout = QVBoxLayout() disk_layout.setAlignment(Qt.AlignLeft) disk_layout.addWidget(self.title) disk_layout.addWidget(self.sottotitolo) disk_layout.addWidget(self.spaceLabel) disk_layout.addLayout(quota_layout) disk_layout.addWidget(self.disk_progress) disk_layout.addWidget(self.spaceLabel) disk_layout.addLayout(set_space_layout) disk_layout.addLayout(self.buttonLayout) self.setLayout(disk_layout) self.Sl_model_changed() @Slot() def Sl_dedicated_space_changed(self): self.Sg_view_changed.emit() @Slot() def Sl_model_changed(self): """ Slot collegato ai segnali del model, aggiorna la vista con i nuovi valori :return: None """ # Prendo quota disco con unità e il peso della cartella senza unità (Byte default) new_max_quota = self._model.get_quota_disco() _folder_size = self._model.get_size() # Converto ad oggetto bitmath il peso della cartella e la quota disco folder_size_parsed = bitmath.parse_string( self._model.convert_size(_folder_size)) quota_disco_parsed = bitmath.parse_string(new_max_quota) # Imposto la textbox che mi dice quanto peso ho occupato su quello disponibile self.disk_quota.setText( f"{folder_size_parsed} su {new_max_quota} in uso") free_disk_parsed = bitmath.parse_string( self._model.convert_size(self._model.get_free_disk())) # Imposto la textbox che richiede input if not self.dedicated_space.hasFocus(): self.dedicated_space.setText(str(quota_disco_parsed.value)) # Creo i nuovi valori della combobox if not self.sizes_box.hasFocus(): self.populate_size_box(folder_size_parsed, free_disk_parsed) # Imposto l'item in focus della combobox self.sizes_box.setCurrentText(quota_disco_parsed.unit) # Prendo dimensione corrente della sync folder e della quota disco # e metto in proporzione con quotadisco:100=syncfolder:x _progress_bar_max_value = 100 _tmp = folder_size_parsed.to_Byte().value * _progress_bar_max_value _progress_bar_current_percentage = _tmp / quota_disco_parsed.to_Byte( ).value # Inserisco nuovi valori nella progress bar self.disk_progress.setRange(0, _progress_bar_max_value) self.disk_progress.setValue(_progress_bar_current_percentage) # Se la cartella occupa più spazio di quanto voluto allora la porto a quanto occupa if quota_disco_parsed < folder_size_parsed and not self.dedicated_space.hasFocus( ): self.dedicated_space.setText(str(folder_size_parsed.value)) self.sizes_box.setCurrentText(folder_size_parsed.unit) self.Sg_view_changed.emit() def populate_size_box( self, _min: str, _max: str, ) -> None: """ This method populates the size box with only the available units ex hdd has only <1gb so gb will not be used, the current folder is heavier than 1mb so kb will not be used. :param _min: minimum value with unit ex 10 KiB or just 'KiB' :param _max: maximum value with unit ex 10 KiB or just 'KiB' :return: None """ _sizes = "Byte", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB" # Converto in ogni caso a string, in caso in cui venga passato un oggetto # tipo bitmath _min = str(_min) _max = str(_max) # Rimuovo eventuali numeri e caratteri extra, tengo solo l'unità di misura _min = ''.join(i for i in _min if not i.isdigit() and i != '.') _max = ''.join(i for i in _max if not i.isdigit() and i != '.') # Rimuovo possibili spazi ad inizio e fine stringa _min = _min.strip() _max = _max.strip() # Rimuovo dal vettore di possibili unità di misura tutte le unità sotto il lower bound lower_bound = _sizes[_sizes.index(_min):] # Rimuovo dal vettore di possibili unità di misura tutte le unità sopra l'upper bound upper_bound = lower_bound[:lower_bound.index(_max) + 1] # Pulisco il vecchio combo box self.sizes_box.clear() # Inserisco nuovi valori self.sizes_box.addItems(upper_bound)
class ApplicationWindow(QMainWindow): def __init__(self, parent=None): QMainWindow.__init__(self, parent) self.column_names = ["Column A", "Column B", "Column C"] # Central widget self._main = QWidget() self.setCentralWidget(self._main) # Main menu bar self.menu = self.menuBar() self.menu_file = self.menu.addMenu("File") exit = QAction("Exit", self, triggered=qApp.quit) self.menu_file.addAction(exit) self.menu_about = self.menu.addMenu("&About") about = QAction("About Qt", self, shortcut=QKeySequence(QKeySequence.HelpContents), triggered=qApp.aboutQt) self.menu_about.addAction(about) # Figure (Left) self.fig = Figure(figsize=(5, 3)) self.canvas = FigureCanvas(self.fig) # Sliders (Left) self.slider_azim = QSlider(minimum=0, maximum=360, orientation=Qt.Horizontal) self.slider_elev = QSlider(minimum=0, maximum=360, orientation=Qt.Horizontal) self.slider_azim_layout = QHBoxLayout() self.slider_azim_layout.addWidget( QLabel("{}".format(self.slider_azim.minimum()))) self.slider_azim_layout.addWidget(self.slider_azim) self.slider_azim_layout.addWidget( QLabel("{}".format(self.slider_azim.maximum()))) self.slider_elev_layout = QHBoxLayout() self.slider_elev_layout.addWidget( QLabel("{}".format(self.slider_elev.minimum()))) self.slider_elev_layout.addWidget(self.slider_elev) self.slider_elev_layout.addWidget( QLabel("{}".format(self.slider_elev.maximum()))) # Table (Right) self.table = QTableWidget() header = self.table.horizontalHeader() header.setSectionResizeMode(QHeaderView.Stretch) # ComboBox (Right) self.combo = QComboBox() self.combo.addItems( ["Wired", "Surface", "Triangular Surface", "Sphere"]) # Right layout rlayout = QVBoxLayout() rlayout.setContentsMargins(1, 1, 1, 1) rlayout.addWidget(QLabel("Plot type:")) rlayout.addWidget(self.combo) rlayout.addWidget(self.table) # Left layout llayout = QVBoxLayout() rlayout.setContentsMargins(1, 1, 1, 1) llayout.addWidget(self.canvas, 88) llayout.addWidget(QLabel("Azimuth:"), 1) llayout.addLayout(self.slider_azim_layout, 5) llayout.addWidget(QLabel("Elevation:"), 1) llayout.addLayout(self.slider_elev_layout, 5) # Main layout layout = QHBoxLayout(self._main) layout.addLayout(llayout, 70) layout.addLayout(rlayout, 30) # Signal and Slots connections self.combo.currentTextChanged.connect(self.combo_option) self.slider_azim.valueChanged.connect(self.rotate_azim) self.slider_elev.valueChanged.connect(self.rotate_elev) # Initial setup self.plot_wire() self._ax.view_init(30, 30) self.slider_azim.setValue(30) self.slider_elev.setValue(30) self.fig.canvas.mpl_connect("button_release_event", self.on_click) # Matplotlib slot method def on_click(self, event): azim, elev = self._ax.azim, self._ax.elev self.slider_azim.setValue(azim + 180) self.slider_elev.setValue(elev + 180) # Utils methods def set_table_data(self, X, Y, Z): for i in range(len(X)): self.table.setItem(i, 0, QTableWidgetItem("{:.2f}".format(X[i]))) self.table.setItem(i, 1, QTableWidgetItem("{:.2f}".format(Y[i]))) self.table.setItem(i, 2, QTableWidgetItem("{:.2f}".format(Z[i]))) def set_canvas_table_configuration(self, row_count, data): self.fig.set_canvas(self.canvas) self._ax = self.canvas.figure.add_subplot(projection="3d") self._ax.set_xlabel(self.column_names[0]) self._ax.set_ylabel(self.column_names[1]) self._ax.set_zlabel(self.column_names[2]) self.table.setRowCount(row_count) self.table.setColumnCount(3) self.table.setHorizontalHeaderLabels(self.column_names) self.set_table_data(data[0], data[1], data[2]) # Plot methods def plot_wire(self): # Data self.X, self.Y, self.Z = axes3d.get_test_data(0.03) self.set_canvas_table_configuration(len(self.X[0]), (self.X[0], self.Y[0], self.Z[0])) self._ax.plot_wireframe(self.X, self.Y, self.Z, rstride=10, cstride=10, cmap="viridis") self.canvas.draw() def plot_surface(self): # Data self.X, self.Y = np.meshgrid(np.linspace(-6, 6, 30), np.linspace(-6, 6, 30)) self.Z = np.sin(np.sqrt(self.X**2 + self.Y**2)) self.set_canvas_table_configuration(len(self.X[0]), (self.X[0], self.Y[0], self.Z[0])) self._ax.plot_surface(self.X, self.Y, self.Z, rstride=1, cstride=1, cmap="viridis", edgecolor="none") self.canvas.draw() def plot_triangular_surface(self): # Data radii = np.linspace(0.125, 1.0, 8) angles = np.linspace(0, 2 * np.pi, 36, endpoint=False)[..., np.newaxis] self.X = np.append(0, (radii * np.cos(angles)).flatten()) self.Y = np.append(0, (radii * np.sin(angles)).flatten()) self.Z = np.sin(-self.X * self.Y) self.set_canvas_table_configuration(len(self.X), (self.X, self.Y, self.Z)) self._ax.plot_trisurf(self.X, self.Y, self.Z, linewidth=0.2, antialiased=True) self.canvas.draw() def plot_sphere(self): # Data u = np.linspace(0, 2 * np.pi, 100) v = np.linspace(0, np.pi, 100) self.X = 10 * np.outer(np.cos(u), np.sin(v)) self.Y = 10 * np.outer(np.sin(u), np.sin(v)) self.Z = 9 * np.outer(np.ones(np.size(u)), np.cos(v)) self.set_canvas_table_configuration(len(self.X), (self.X[0], self.Y[0], self.Z[0])) self._ax.plot_surface(self.X, self.Y, self.Z) self.canvas.draw() # Slots @Slot() def combo_option(self, text): if text == "Wired": self.plot_wire() elif text == "Surface": self.plot_surface() elif text == "Triangular Surface": self.plot_triangular_surface() elif text == "Sphere": self.plot_sphere() @Slot() def rotate_azim(self, value): self._ax.view_init(self._ax.elev, value) self.fig.set_canvas(self.canvas) self.canvas.draw() @Slot() def rotate_elev(self, value): self._ax.view_init(value, self._ax.azim) self.fig.set_canvas(self.canvas) self.canvas.draw()
class ImageManipulation(QWidget): def __init__(self): super().__init__() # Declare Widgets self.edit_label = QLabel('Change your image') # set up list and combo box option self.my_list = ["Pick a value", "Luminosity", "Contrast", "Colorize", "Sepia", "Negative", "Grayscale", "None"] self.my_combo_box = QComboBox() self.my_combo_box.addItems(self.my_list) self.edit_btn = QPushButton("Edit") self.cancel_btn = QPushButton("Back") # Create U.I. Layout vbox = QVBoxLayout() vbox.addWidget(self.edit_label) vbox.addWidget(self.my_combo_box) vbox.addWidget(self.edit_btn) vbox.addWidget(self.cancel_btn) self.setLayout(vbox) # apply layout to this class # when button is clicked send lineedit and combo box info to on_submit self.edit_btn.clicked.connect(self.on_edit) self.cancel_btn.clicked.connect(self.on_back) @Slot() def on_edit(self): # set up im_edit as which filter the user chose im_edit = self.my_combo_box.currentText() ##TODO change to correct image input_image = Image.open("image.png") input_pixels = input_image.load() output_image = Image.new("RGB", input_image.size) draw = ImageDraw.Draw(output_image) # Options are: ["Pick a value", "Luminosity", "Contrast", "Colorize", "Sepia", "Negative", "Grayscale", "None"] if (im_edit == "Luminosity"): luminosity = 80 # Generate image for x in range(output_image.width): for y in range(output_image.height): r, g, b, a = input_pixels[x, y] r = int(r + luminosity) g = int(g + luminosity) b = int(b + luminosity) draw.point((x, y), (r, g, b)) #output_image.save("output.png") output_image.show() elif (im_edit == "Contrast"): # Find minimum and maximum luminosity imin = 255 imax = 0 for x in range(input_image.width): for y in range(input_image.height): r, g, b, a = input_pixels[x, y] i = (r + g + b) / 3 imin = min(imin, i) imax = max(imax, i) # Generate image for x in range(output_image.width): for y in range(output_image.height): r, g, b, a = input_pixels[x, y] # Current luminosity i = (r + g + b) / 3 # New luminosity ip = 255 * (i - imin) / (imax - imin) r = int(r * ip / i) g = int(g * ip / i) b = int(b * ip / i) draw.point((x, y), (r, g, b)) output_image.show() elif (im_edit == "Colorize"): # Square distance between 2 colors def distance2(color1, color2): r1, g1, b1 = color1 r2, g2, b2, a2 = color2 return (r1 - r2) ** 2 + (g1 - g2) ** 2 + (b1 - b2) ** 2 color_to_change = (0, 0, 255) threshold = 220 # Generate image for x in range(output_image.width): for y in range(output_image.height): r, g, b, a = input_pixels[x, y] if distance2(color_to_change, input_pixels[x, y]) < threshold ** 2: r = int(r * .5) g = int(g * 1.25) b = int(b * .5) draw.point((x, y), (r, g, b)) #output_image.save("output.png") output_image.show() elif (im_edit == "Sepia"): def sepia(pixel): if pixel[0] < 63: r,g,b = int(pixel[0]*1.1), pixel[1], int(pixel[2]*.9) elif pixel[0]>62 and pixel[0]<192: r,g,b = int(pixel[0]*1.15), pixel[1], int(pixel[2]*.85) else: r = int(pixel[0]*1.08) if r>255: r=255 g,b = pixel[1], pixel[2]//2 return r,g,b sepia_list = map(sepia, input_image.getdata()) output_image.putdata(list(sepia_list)) #output_image.save("output.png") output_image.show() elif (im_edit == "Negative"): negative_list = [(255-p[0], 255-p[1], 255-p[2]) for p in input_image.getdata()] output_image.putdata(negative_list) #output_image.save("output.png") output_image.show() elif (im_edit == "Grayscale"): new_list = [ ( (a[0]+a[1]+a[2])//3, ) * 3 for a in input_image.getdata() ] output_image.putdata(new_list) #output_image.save("output.png") output_image.show() else: #"Pick a value" or "None" input_image.show() @Slot() def on_back(self): print("back")
class MainWindow(QMainWindow): def __init__(self): QMainWindow.__init__(self) # Variaveis self.separador = ";" # Separador padrao de colunas em um arquivo txt ou csv self.selected = np.array([1, 24, 48, 96]).astype('timedelta64[h]') # selecionados ao iniciar o programa, modificavel. self.fileformat = '' # Reservado para o formato do arquivo a ser aberto. Pode ser .xlsx ou .odf. ou .csv e assim vai. # facilita o acesso a variavel. self.timedeltastr = ("1 Hora","2 Horas", "3 Horas", "4 Horas","12 Horas", "24 Horas", "48 Horas", "72 horas", "96 horas", "30 Dias") self.timedeltas = np.array([1, 2, 3, 4, 12, 24, 48, 72, 96, 24*30]).astype('timedelta64[h]') self.linktimedelta = dict([(self.timedeltas[x], self.timedeltastr[x]) for x in range(len(self.timedeltastr))]) self.datastring = ["DD/MM/AAAA",'AAAA/MM/DD', "AAAA-MM-DD", "DD-MM-AAAA"] self.dataformat = ["%d/%m/%Y", "%Y/%m/%d", "%Y-%m-%d", "%d-%m-%Y"] self.linkdata = dict([(self.datastring[x], self.dataformat[x]) for x in range(len(self.dataformat))]) self.timestring = ["hh:mm", "hh:mm:ss", "hh:mm:ss.ms"] self.timeformat = ["%H:%M", "%H:%M:%S", "%H:%M:%S.%f"] self.linktime = dict([(self.timestring[x], self.timeformat[x]) for x in range(len(self.timeformat))]) #Janela Principal widget = QWidget() self.setCentralWidget(widget) # Inicializa os Widgets self.folder = QLineEdit("Salvar Como...") self.path = QLineEdit("Abrir arquivo...") # buttonOpen = QPushButton('Abrir') buttonSave = QPushButton("Destino") Processar = QPushButton('Executar') Ajuda = QPushButton('Informações') # groupBox2 = QGroupBox("Delimitador") self.delimitador1 = QRadioButton("Ponto-Vírgula") self.delimitador2 = QRadioButton("Vírgula") self.delimitador3 = QRadioButton("Ponto") self.delimitador4 = QRadioButton("Tabulação") # checkGroup = QGroupBox("Mais opções") text3 = QPushButton("Configurações") text2 = QLabel("Formato da Data") text1 = QLabel("Formato da Hora") self.FormatoTime = QComboBox() self.FormatoTime.addItems(self.timestring) self.FormatoData = QComboBox() self.FormatoData.addItems(self.datastring) # text = QLabel("Por favor, selecione na tabela abaixo as colunas a utilizar:") self.ignore = QRadioButton("Possui Cabeçalho") # True se estiver selecionado, False caso nao # self.Tabela = QTableWidget(15,15) self.startTable() # Layouts MainLayout = QVBoxLayout() Gridlayout = QGridLayout() Gridlayout.addWidget(self.path, 0, 0) Gridlayout.addWidget(self.folder, 1, 0) Gridlayout.addWidget(buttonOpen, 0, 1) Gridlayout.addWidget(buttonSave, 1, 1) Gridlayout.addWidget(Processar, 0, 3) Gridlayout.addWidget(Ajuda, 1, 3) Gridlayout.setColumnStretch(0, 2) Gridlayout.setColumnStretch(3, 1) Gridlayout.setColumnMinimumWidth(2, 20) SecondLayout = QHBoxLayout() SecondLayout.addWidget(groupBox2) SecondLayout.addSpacing(40) SecondLayout.addWidget(checkGroup) # SepLayout = QVBoxLayout() SepLayout.addWidget(self.delimitador1) SepLayout.addWidget(self.delimitador2) SepLayout.addWidget(self.delimitador3) SepLayout.addWidget(self.delimitador4) # OptionsLayout = QVBoxLayout() OptionsLayout.addWidget(text3) OptionsLayout.addWidget(text2) OptionsLayout.addWidget(self.FormatoData) OptionsLayout.addWidget(text1) OptionsLayout.addWidget(self.FormatoTime) ThirdLayout = QVBoxLayout() ThirdLayout.addWidget(self.ignore) ThirdLayout.addWidget(text) MainLayout.addLayout(Gridlayout) MainLayout.addLayout(SecondLayout) MainLayout.addLayout(ThirdLayout) MainLayout.addWidget(self.Tabela) # Coloca o Layout principal na Janela widget.setLayout(MainLayout) # Comandos dos Widgets e edicoes. groupBox2.setLayout(SepLayout) self.delimitador1.setChecked(True) self.folder.setReadOnly(True) self.path.setReadOnly(True) checkGroup.setLayout(OptionsLayout) buttonOpen.clicked.connect(self.searchFile) buttonSave.clicked.connect(self.getNewFile) self.delimitador1.clicked.connect(self.updateDelimiter) self.delimitador2.clicked.connect(self.updateDelimiter) self.delimitador3.clicked.connect(self.updateDelimiter) self.delimitador4.clicked.connect(self.updateDelimiter) Ajuda.clicked.connect(self.help) Processar.clicked.connect(self.taskStart) text3.clicked.connect(self.openSubWindow) # Propriedades da janela principal height = 480 width = 640 myappid = 'GePlu.release1_0.0' # arbitrary string ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(myappid) self.setWindowIcon(QIcon(r'images\icon6.ico')) self.setFixedSize(width, height) self.setWindowTitle("GePlu") def openSubWindow(self): dialog = MyDialog(self) dialog.show() dialog.exec_() def taskStart(self): ''' Inicia a execucao do programa, se houver algum erro durante o processo notifica o usuario e deixa a funcao imediatamente''' if self.folder.isModified() and self.path.isModified(): # o usuario entrou com os enderecos? start = time.time() # Conhece do que se trata cada coluna na tabela e armazena essa informacao. header = {} for col in range(15): header[self.Tabela.cellWidget(0, col).currentText()] = col boolean = 0 if self.ignore.isChecked() else None # Le o arquivo e retorna um dataframe de strings df_master = utils.read_file(self, header = boolean) df_master = dt.data_filter(self, df_master, header) df_master = dt.convert_dtype(self, df_master) # Computa os acumulados para cada intervalo de tempo (key). for key in self.selected: array = dt.compute(df_master.index.to_numpy(), df_master['Observado'].to_numpy(), key) df_master[self.linktimedelta[key]] = pd.Series(array, df_master.index) # salva o arquivo final. utils.save_file(self, df_master) # Fim do processo end = time.time() # Notifica o usuario QMessageBox.information(self, "Notificação", "Tarefa realizada com sucesso!\nTempo de execução: {} s.".format(round(end-start, 2))) # Reseta a tabela e os endereço do arquivo aberto e onde salvar, na janela principal. self.resetProgram() else: QMessageBox.warning(self, "Notificação", "Houve um erro no arquivo ou diretório especificado.\nPor favor, selecione um caminho válido.") def help(self): x = 'Caso tenha alguma dúvida, abra o documento em PDF presente\nna pasta do programa ou entre em contato.\n\nGeplu\n1.0.0' msgBox = QMessageBox.information(self, "Informação", x) def resetProgram(self): self.Tabela.clearContents() self.startTable() self.folder.setText("Salvar Como...") self.path.setText("Selecionar o arquivo...") self.folder.setModified(False) self.folder.setModified(False) def updateDelimiter(self): separadores = {"Ponto-Vírgula": ';', "Vírgula":",", "Ponto":".", "Tabulação":"\t"} for x in [self.delimitador1, self.delimitador3, self.delimitador2, self.delimitador4]: if x.isChecked(): self.separador = separadores[x.text()] break if self.path.isModified(): self.updateTable() def startTable(self): for col in range(self.Tabela.columnCount()): combo = QComboBox() combo.addItems(["Selecionar","Data & Hora","Prec. Observada","Data","Hora","Nível do Rio"]) self.Tabela.setCellWidget(0, col, combo) def updateTable(self): # Guarda a primeira linha n_col = self.Tabela.columnCount() textos = [0]*n_col for col in range(n_col): textos[col] = self.Tabela.cellWidget(0, col).currentText() self.Tabela.clearContents() self.startTable() for col in range(n_col): self.Tabela.cellWidget(0, col).setCurrentText(textos[col]) # Mostra na tabela as primeiras 14 linhas do arquivo que o usuario deseja abrir/utilizar. data_df = utils.read_file(self, 14).to_numpy() for row in range(data_df.shape[0]): for col in range(data_df.shape[1]): self.Tabela.setItem(row+1, col, QTableWidgetItem(data_df[row][col])) def searchFile(self): address, x = QFileDialog.getOpenFileName(self, "Selecione um arquivo", filter = "Text files (*.txt *.csv *.xlsx)" ) if len(address) > 0: self.path.setText(address) self.path.setModified(True) self.fileformat = address[address.index('.'):] self.updateTable() def getNewFile(self): address, x = QFileDialog.getSaveFileName(self, "Salvar como", filter = "Text files (*.csv);; Text files (*.txt);; Planilha do Microsoft Excel (*.xlsx)" ) if len(address) > 0: self.folder.setText(address) self.folder.setModified(True)
class MainWindow(QMainWindow): def __init__(self): super().__init__() ## declared variables self.dir_path = "None selected" self.filelist = ["Select Folder"] self.filelistindex = None self.setWindowTitle("Ephys-Quick Analysis") layout = QGridLayout() toolbar = QToolBar("Function toolbar") self.addToolBar(toolbar) self.folderbuttonsetup() toolbar.addAction(self.folderbutton) self.setStatusBar(QStatusBar(self)) self.filebox = QComboBox() self.filebox.addItems(self.filelist) layout.addWidget(self.filebox, 0, 0, 1, 2) self.tracelabel = QLabel("Sweep number :") layout.addWidget(self.tracelabel, 0, 2) self.sweepslider = QSpinBox() self.sweepslider.setMinimum(0) self.sweepslider.setSingleStep(1) layout.addWidget(self.sweepslider, 0, 3, 1, 2) self.pw = pg.PlotWidget(name='Clamp') ## giving the plots names allows us to link their axes together layout.addWidget(self.pw, 1, 0, 2, 5) self.pw2 = pg.PlotWidget(name='ClampZoom') ## giving the plots names allows us to link their axes together layout.addWidget(self.pw2, 1, 6, 2, 5) self.pw3 = pg.PlotWidget(name='Stim') layout.addWidget(self.pw3, 6, 0, 2, 5) self.pw3.setXLink(self.pw) self.pw4 = pg.PlotWidget(name='StimZoom') layout.addWidget(self.pw4, 6, 6, 2, 5) self.pw4.setXLink(self.pw2) self.pw.setBackground('w') self.pw2.setBackground('w') self.pw3.setBackground('w') self.pw4.setBackground('w') widget = QWidget() widget.setLayout(layout) self.setCentralWidget(widget) def folderbuttonsetup(self): self.folderbutton = QAction("Folder", self) self.folderbutton.setStatusTip(self.dir_path) self.folderbutton.triggered.connect(self.folderselect) def folderselect(self): print("click") print(self.dir_path) self.dir_path = QFileDialog.getExistingDirectory() self.folderbutton.setStatusTip(self.dir_path) print(self.dir_path) self.fileboxlist() def fileboxlist(self): print('Files within experiment date folder') print('ISOLATING ABF FILES...') self.dir_path_1 = self.dir_path[2:] + "/" self.fileinfolder = os.listdir(self.dir_path_1) self.abffiles = [extension for extension in self.fileinfolder if re.search("\.abf$", extension)] self.abffiles.sort() print('*.abf files in folder:') print(self.abffiles) self.filebox.clear() self.filebox.currentTextChanged.connect(self.fileselected) self.filelist = self.abffiles self.filebox.addItems(self.filelist) def fileselected(self, s): print("yo") print(s) self.fileselected_1 = self.dir_path_1 + s print(self.fileselected_1) self.pw.clear() self.pw2.clear() self.pw3.clear() self.pw4.clear() self.loadabf(self.fileselected_1) def loadabf(self, filetoload): print("load file") self.abf = pyabf.ABF(filetoload) self.numsweep = self.abf.sweepCount - 1 self.sweepslider.cleanText() self.sweepslider.setMaximum(self.numsweep) self.sweepslider.valueChanged.connect(self.setsweep) self.pw.setLabel('left', self.abf.sweepLabelY) self.pw.setLabel('bottom', self.abf.sweepLabelX) self.pw2.setLabel('left', self.abf.sweepLabelY) self.pw2.setLabel('bottom', self.abf.sweepLabelX) self.pw3.setLabel('left', self.abf.sweepLabelY) self.pw3.setLabel('bottom', self.abf.sweepLabelX) self.pw4.setLabel('left', self.abf.sweepLabelY) self.pw4.setLabel('bottom', self.abf.sweepLabelX) self.zoomarea = pg.LinearRegionItem([0, 1]) self.zoomarea.setZValue(-10) self.pw.addItem(self.zoomarea) for sweepnum in self.abf.sweepList: self.abf.setSweep(sweepnum, channel=0) self.pw.plot(self.abf.sweepX, self.abf.sweepY, pen=pg.mkPen('black', width=1)) for sweepnum in self.abf.sweepList: self.abf.setSweep(sweepnum, channel=1) self.pw3.plot(self.abf.sweepX, self.abf.sweepC, pen=pg.mkPen('black', width=1)) for sweepnum in self.abf.sweepList: self.abf.setSweep(sweepnum, channel=0) self.pw2.plot(self.abf.sweepX, self.abf.sweepY, pen=pg.mkPen('black', width=1)) for sweepnum in self.abf.sweepList: self.abf.setSweep(sweepnum, channel=1) self.pw4.plot(self.abf.sweepX, self.abf.sweepC, pen=pg.mkPen('black', width=1)) def updatePlot(): self.pw2.setXRange(*self.zoomarea.getRegion(), padding=0) def updateRegion(): self.zoomarea.setRegion(self.pw2.getViewBox().viewRange()[0]) self.zoomarea.sigRegionChanged.connect(updatePlot) self.pw2.sigXRangeChanged.connect(updateRegion) updatePlot() self.currenttrace = self.pw.plot() self.currenttrace.setPen(pg.mkPen('r', width=2.5)) self.currenttrace2 = self.pw2.plot() self.currenttrace2.setPen(pg.mkPen('r', width=2.5)) self.currenttrace3 = self.pw3.plot() self.currenttrace3.setPen(pg.mkPen('r', width=2.5)) self.currenttrace4 = self.pw4.plot() self.currenttrace4.setPen(pg.mkPen('r', width=2.5)) def setsweep(self, numofsweep): print(numofsweep) self.currenttrace.clear() self.currenttrace2.clear() self.currenttrace3.clear() self.currenttrace4.clear() for sweepnum in self.abf.sweepList: self.abf.setSweep(sweepnum, channel=0) if sweepnum == numofsweep: self.currenttrace.setData(self.abf.sweepX, self.abf.sweepY) for sweepnum in self.abf.sweepList: self.abf.setSweep(sweepnum, channel=1) if sweepnum == numofsweep: self.currenttrace3.setData(self.abf.sweepX, self.abf.sweepC) for sweepnum in self.abf.sweepList: self.abf.setSweep(sweepnum, channel=0) if sweepnum == numofsweep: self.currenttrace2.setData(self.abf.sweepX, self.abf.sweepY) for sweepnum in self.abf.sweepList: self.abf.setSweep(sweepnum, channel=1) if sweepnum == numofsweep: self.currenttrace4.setData(self.abf.sweepX, self.abf.sweepC)
class Scraper(QWidget): def __init__(self): super().__init__() self.setup() def setup(self): #self.setGeometry(200, 200, 400, 300) self.setWindowTitle('Quizlet Scraper') layout = QHBoxLayout() layout.setSpacing(20) self.setLayout(layout) left = QWidget() left_layout = QVBoxLayout() left.setLayout(left_layout) layout.addWidget(left) right = QWidget() right_layout = QVBoxLayout() right.setLayout(right_layout) layout.addWidget(right) url_text = QLabel('URL:') left_layout.addWidget(url_text) self.urlbox = QLineEdit(self) left_layout.addWidget(self.urlbox) self.add_deck = QWidget() add_deck_layout = QVBoxLayout() self.add_deck.setLayout(add_deck_layout) right_layout.addWidget(self.add_deck) self.add_deck.hide() add_deck_label = QLabel('Deck name:') add_deck_layout.addWidget(add_deck_label) self.add_deck_box = QLineEdit(self) add_deck_layout.addWidget(self.add_deck_box) self.combo = QComboBox() self.combo.addItems([ '.csv (Comma separated)', '.txt (Tab separated)', '.xls (Excel)', '.apkg (Anki package)' ]) self.combo.currentIndexChanged.connect(self.index_changed) right_layout.addWidget(self.combo) spreadsheet_button = QPushButton('Get Spreadsheet', self) spreadsheet_button.clicked.connect(self.get_spreadsheet) spreadsheet_button.resize(spreadsheet_button.sizeHint()) right_layout.addWidget(spreadsheet_button) def index_changed(self, i): self.add_deck.show() if i == 3 else self.add_deck.hide() def get_spreadsheet(self): try: page = q.start_session(self.urlbox.text()) print('got page') term_list = q.get_terms(page) except: print('Not a valid Quizlet URL.') term_list = [] self.save_file(term_list) def save_file(self, term_list): filename = QFileDialog.getSaveFileName( self, 'Save file', '', 'All Files (*)' )[0] i = self.combo.currentIndex() if i == 0: s.write_csv(term_list, filename + '.csv') elif i == 1: s.write_txt(term_list, filename + '.txt') elif i == 2: s.write_xls(term_list, filename + '.xls') elif i == 3: s.write_anki(term_list, self.add_deck_box.text(), filename + '.apkg')
class App(QWidget): def __init__(self): #init super(App, self).__init__() #▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ #parameters for the resume generation. self.params = { "White": 1.0, "Black": 1.0, "Hispanic": 1.0, "Asian": 1.0, "GenderRatio": 0.5, "TestSection": '', "TestMode": 2, "WorkPath": "", "BeginYear": "", "EndYear": "", "BeginMonth": "", "EndMonth": "", "BeginYearEdu": "", "EndYearEdu": "", "BeginMonthEdu": "", "EndMonthEdu": "" } #▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ #Dictionaries for UI buttons self.testModes = {"Before": 1, "After": 2, "Replace": 3} self.testSections = { "Address": 1, "Education": 2, "Work History": 3, "Skills": 4 } #▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ #Window sizing for application self.title = "COEHP Resume Generator" self.left = 10 self.top = 10 self.width = 100 self.height = 300 #▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ #Window is created here self.makeUI() #▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ #Function creates window and adds widgets def makeUI(self): self.setWindowTitle(self.title) self.setGeometry(self.left, self.top, self.width, self.height) self.createLayout() windowLayout = QGridLayout() windowLayout.addWidget(self.box0, 1, 1, 1, 1) windowLayout.addWidget(self.box4, 0, 0, 1, 1) windowLayout.addWidget(self.box6, 1, 0, 1, 1) windowLayout.addWidget(self.box7, 0, 1, 1, 1) windowLayout.addWidget(self.box5, 3, 0, 1, 2) windowLayout.addWidget(self.box8, 2, 0, 1, 2) windowLayout.setAlignment(QtCore.Qt.AlignTop) self.setLayout(windowLayout) self.show() #▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ #All QGroupBoxes for features are added here. def createLayout(self): self.box0 = QGroupBox("Timeframe") self.box4 = QGroupBox("Test Data") self.box6 = QGroupBox("Output Directory") self.box5 = QGroupBox("") self.box7 = QGroupBox("Demographic Settings") self.box8 = QGroupBox("Resume Layout") #Demographic Settings self.wPercent = QTextEdit("0.25") self.bPercent = QTextEdit("0.25") self.aPercent = QTextEdit("0.25") self.hPercent = QTextEdit("0.25") self.gPercent = QTextEdit("0.5") self.wLabel = QLabel("White %") self.bLabel = QLabel("Black %") self.aLabel = QLabel("Asian %") self.hLabel = QLabel("Hispanic %") self.gLabel = QLabel(" Gender Ratio") self.wPercent.setFixedSize(100, 30) self.bPercent.setFixedSize(100, 30) self.aPercent.setFixedSize(100, 30) self.hPercent.setFixedSize(100, 30) self.gPercent.setFixedSize(100, 30) #Resume Layout Settings self.testSectionLabel1 = QLabel("Test Location") self.testSectionLabel2 = QLabel("Section") self.testSectionLabel3 = QLabel("Location of Content") self.sectionSelect = QComboBox() self.sectionSelect.addItems( ["Address", "Education", "Work History", "Skills"]) self.sectionSelect.setFixedSize(300, 30) self.modeSelect = QComboBox() self.modeSelect.addItems(["Before", "After", "Replace"]) self.modeSelect.setFixedSize(300, 30) #Academic Year #First Semester self.monthBegin = QComboBox() self.monthBegin.addItems([ "January", "February", "March", "April", "May", "June", "July", "August", "September", "November", "December" ]) self.monthBegin.setFixedSize(100, 30) self.yearBeginLabel = QLabel("First Semester") self.yearBegin = QComboBox() self.yearBegin.setFixedSize(100, 30) for year in range(1970, 2050): self.yearBegin.addItem(str(year)) #Last Semester self.monthEnd = QComboBox() self.monthEnd.addItems([ "January", "February", "March", "April", "May", "June", "July", "August", "September", "November", "December" ]) self.monthEnd.setFixedSize(100, 30) self.yearEnd = QComboBox() self.yearEndLabel = QLabel("Semester of Graduation") for year in range(1970, 2050): self.yearEnd.addItem(str(year)) self.yearEnd.setFixedSize(100, 30) #Earliest relevant employment self.monthWorkBegin = QComboBox() self.monthWorkBegin.addItems([ "January", "February", "March", "April", "May", "June", "July", "August", "September", "November", "December" ]) self.monthBegin.setFixedSize(100, 30) self.yearWorkBeginLabel = QLabel( "Earliest Possible Date of Employment") self.yearWorkBegin = QComboBox() self.yearWorkBegin.setFixedSize(100, 30) for year in range(1970, 2050): self.yearWorkBegin.addItem(str(year)) #Latest relevant employment self.monthWorkEnd = QComboBox() self.monthWorkEnd.addItems([ "January", "February", "March", "April", "May", "June", "July", "August", "September", "November", "December" ]) self.monthWorkEnd.setFixedSize(100, 30) self.yearWorkEnd = QComboBox() self.yearWorkEndLabel = QLabel("Latest Possible Date of Employment") for year in range(1970, 2050): self.yearWorkEnd.addItem(str(year)) self.yearWorkEnd.setFixedSize(100, 30) currentYear = date.today().year index = currentYear - 1970 self.yearEnd.setCurrentIndex(index) self.yearBegin.setCurrentIndex(index) self.yearWorkBegin.setCurrentIndex(index) self.yearWorkEnd.setCurrentIndex(index) #Output Directory self.dirLabel = QLabel("Output Directory") self.currentDir = QTextEdit() self.currentDir.setText("Not Selected") self.currentDir.layout() self.currentDir.setFixedSize(300, 30) self.currentDir.setReadOnly(True) self.outputName = QTextEdit() self.outputLabel = QLabel("Output Folder Name") self.outputName.setText("None written") self.outputName.setToolTip( "Type in the name of the new Folder you would like to make for your Resume batch. \n Otherwise, this will use the current timestamp." ) self.outputName.setFixedSize(300, 30) #Select ouput folder button self.outputButton = QPushButton('Select Output Directory') self.outputButton.setToolTip( "Click here to tell the generator where to put this batch of Resumes when it is finished." ) self.outputButton.clicked.connect( lambda: self.openDir(self.currentDir)) self.currentTest = QTextEdit() self.currentTest.setText("SportsCollegeList.csv") #Output Directory self.workLabel = QLabel("Output Directory") self.currentWork = QTextEdit() self.currentWork.setText("SportsCollegeList.csv") self.currentWork.layout() self.currentWork.setFixedSize(300, 30) self.currentWork.setReadOnly(True) #Select work datafolder button self.workButton = QPushButton('Select Work Data (.CSV)') self.workButton.setToolTip( "Click here to select a source file for the employment information in this Resume Batch." ) self.workButton.clicked.connect(lambda: self.openDir(self.currentWork)) #Select School Data self.workLabel = QLabel("Output Directory") self.currentSchool = QTextEdit() self.currentSchool.setText("Not Selected") self.currentSchool.layout() self.currentSchool.setFixedSize(300, 30) self.currentSchool.setReadOnly(True) #Select work datafolder button self.schoolButton = QPushButton('Select Work Data (.CSV)') self.schoolButton.clicked.connect( lambda: self.openDir(self.currentWork)) #Select test data self.testLabel = QLabel("Output Directory") self.currentTest = QTextEdit() self.currentTest.setText("SportsCollegeList.csv") self.currentTest.layout() self.currentTest.setFixedSize(300, 30) self.currentTest.setReadOnly(True) self.testButton = QPushButton('Select Test Data (.CSV)') self.testButton.clicked.connect(lambda: self.openDir(self.currentTest)) #Generate Resumes button self.begin = QPushButton('Generate Resumes') self.begin.clicked.connect( lambda: self.beginTask(self.currentTest.toPlainText())) layout = QGridLayout() self.box0.setLayout(layout) layout.addWidget(self.yearBeginLabel, 0, 0, 1, 2) layout.addWidget(self.monthBegin, 1, 0, 1, 1) layout.addWidget(self.yearBegin, 1, 1, 1, 1) layout.addWidget(self.yearEndLabel, 2, 0, 1, 2) layout.addWidget(self.monthEnd, 3, 0, 1, 1) layout.addWidget(self.yearEnd, 3, 1, 1, 1) layout.addWidget(self.yearWorkBeginLabel, 4, 0, 1, 2) layout.addWidget(self.monthWorkBegin, 5, 0, 1, 1) layout.addWidget(self.yearWorkBegin, 5, 1, 1, 1) layout.addWidget(self.yearWorkEndLabel, 6, 0, 1, 2) layout.addWidget(self.monthWorkEnd, 7, 0, 1, 1) layout.addWidget(self.yearWorkEnd, 7, 1, 1, 1) layout1 = QGridLayout() self.box8.setLayout(layout1) layout1.addWidget(self.testSectionLabel1, 0, 0, 1, 1) layout1.addWidget(self.testSectionLabel3, 1, 0, 1, 1) layout1.addWidget(self.sectionSelect, 0, 1, 1, 1) layout1.addWidget(self.modeSelect, 1, 1, 1, 1) layout2 = QGridLayout() self.box7.setLayout(layout2) layout2.addWidget(self.wLabel, 0, 0, 1, 1) layout2.addWidget(self.bLabel, 1, 0, 1, 1) layout2.addWidget(self.hLabel, 0, 2, 1, 1) layout2.addWidget(self.aLabel, 2, 0, 1, 1) layout2.addWidget(self.wPercent, 0, 1, 1, 1) layout2.addWidget(self.bPercent, 1, 1, 1, 1) layout2.addWidget(self.hPercent, 0, 3, 1, 1) layout2.addWidget(self.aPercent, 2, 1, 1, 1) layout2.addWidget(self.gLabel, 3, 1, 1, 1) layout2.addWidget(self.gPercent, 3, 2, 1, 2) layout = QGridLayout() self.box5.setLayout(layout) layout.addWidget(self.begin, 0, 0, 1, 2) layout3 = QGridLayout() layout3.addWidget(self.testButton, 0, 0, 1, 2) layout3.addWidget(self.currentTest, 1, 0, 1, 2) self.box4.setLayout(layout3) layout4 = QGridLayout() layout4.addWidget(self.outputButton, 0, 0, 1, 2) layout4.addWidget(self.currentDir, 1, 0, 1, 2) layout4.addWidget(self.outputLabel, 2, 0, 1, 2) layout4.addWidget(self.outputName, 3, 0, 1, 2) self.box6.setLayout(layout4) #▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ # def openDir(self, target): fileName = QFileDialog() filenames = list() if fileName.exec_(): fileNames = fileName.selectedFiles() target.setText(fileNames[0]) #▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ # def beginTask(self, path): self.beginGen(path) def beginGen(self, path): self.params["White"] = self.wPercent.toPlainText() self.params["Black"] = self.bPercent.toPlainText() self.params["Hispanic"] = self.hPercent.toPlainText() self.params["Asian"] = self.aPercent.toPlainText() self.params["GenderRatio"] = self.gPercent.toPlainText() self.params["TestMode"] = str(self.modeSelect.currentText()) self.params["TestSection"] = str(self.sectionSelect.currentText()) self.params["BeginYear"] = str(self.yearWorkBegin.currentText()) self.params["EndYear"] = str(self.yearWorkEnd.currentText()) self.params["BeginMonth"] = str(self.monthWorkBegin.currentText()) self.params["EndMonth"] = str(self.monthWorkEnd.currentText()) self.params["workPath"] = "work.csv" self.params["BeginYearEdu"] = str(self.yearBegin.currentText()) self.params["EndYearEdu"] = str(self.yearEnd.currentText()) self.params["BeginMonthEdu"] = str(self.monthBegin.currentText()) self.params["EndMonthEdu"] = str(self.monthEnd.currentText()) print(self.params) Printer.begin(self.currentDir.toPlainText(), path, self.outputName.toPlainText(), self.params)
class Dialog_Dose(QDialog): """ This class creates the user input dialog for when Modifying or Adding a isodose level option for ISO2ROI functionality. """ def __init__(self, dose, notes): super(Dialog_Dose, self).__init__() # Class variables self.dose = dose self.notes = notes self.setWindowIcon( QtGui.QIcon("res/images/btn-icons/onkodicom_icon.png")) buttonBox = QDialogButtonBox( QDialogButtonBox.Ok | QDialogButtonBox.Cancel, self) self.iso_dose = QLineEdit() self.iso_dose.setText(self.dose) self.iso_unit = QComboBox() self.iso_unit.addItems(["cGy", "%"]) self.iso_notes = QLineEdit() self.iso_notes.setText(self.notes) # Input dialog layout layout = QFormLayout(self) layout.addRow(QLabel("Isodose Level:"), self.iso_dose) layout.addRow(QLabel("Unit:"), self.iso_unit) layout.addRow(QLabel("Notes:"), self.iso_notes) layout.addWidget(buttonBox) buttonBox.accepted.connect(self.accepting) buttonBox.rejected.connect(self.reject) self.setWindowTitle("Isodose Levels") def getInputs(self): """ Return the inputs from the dialog box. :return: tuple of dialog inputs - (isodose level, isodose unit, isodose name, isodose notes) """ # Get appropriate name for unit selected if self.iso_unit.currentText() == "%": iso_name = str('ISOp_' + self.iso_dose.text()) else: iso_name = str('ISO' + self.iso_dose.text()) # Return inputs from dialog box return (self.iso_dose.text(), self.iso_unit.currentText(), iso_name, self.iso_notes.text()) def accepting(self): """ Process the event when the user clicks "ok" in the dialog box. """ # Make sure the isodose level is a number if (self.iso_dose.text() != ''): if re.match(r'^\d+$', self.iso_dose.text()): self.accept() else: buttonReply = QMessageBox.warning( self, "Error Message", "The Isodose level should to be a number!", QMessageBox.Ok) if buttonReply == QMessageBox.Ok: pass # Make sure the isodose level is not blank else: buttonReply = QMessageBox.warning( self, "Error Message", "The Isodose field should not be empty!", QMessageBox.Ok) if buttonReply == QMessageBox.Ok: pass