class TabLayout(QWidget): def __init__(self, toplabel): super().__init__() ## Get label from ctor args self.label = QLabel(toplabel) ## Create and bind spinbox to update function self.spinbox = QSpinBox() self.spinbox.setMinimum(1) self.spinbox.valueChanged.connect(self.update) ## Keep track of how many elements we have in sublayout 2 self.counter = 1 ## Layouts self.toplayout = QVBoxLayout() self.sublayout1 = QHBoxLayout() self.sublayout2 = QHBoxLayout() ## Build the first line with label and spinbox self.sublayout1.addWidget(self.label) self.sublayout1.addWidget(self.spinbox) ## Build the entity container self.sublayout2.addWidget( EntityData() ) ## Build top level layout self.toplayout.addLayout(self.sublayout1) self.toplayout.addLayout(self.sublayout2) ## Display self.setLayout(self.toplayout) def update(self): if self.spinbox.value() > self.counter: for i in range( 0, self.spinbox.value() - self.counter ): self.sublayout2.addWidget( EntityData() ) elif self.spinbox.value() < self.counter: # Delete all widgets while self.sublayout2.count() > self.spinbox.value(): item = self.sublayout2.takeAt( self.sublayout2.count() - 1 ) if not item: continue w = item.widget() if w: w.setParent(None) # Recreate all widgets #for i in range( 0, self.spinbox.value() ): # self.sublayout2.addWidget( EntityData() ) self.sublayout2.update() self.toplayout.update() self.counter = self.spinbox.value()
class NonArnheimStageWidget(BaseWidget): def __init__(self, *args, layer=None, **kwargs) -> None: super().__init__(*args, **kwargs) self.layer = layer self.layout = QHBoxLayout(self) self.uploadButton = QPushButton("Upload") self.uploadButton.clicked.connect(self.on_uploadButton_clicked) self.dialogs = [] self.layout.addWidget(self.uploadButton) self.layout.update() def on_uploadButton_clicked(self): dialog = UploadFileDialog(self, base=self.base, layer=self.layer) if dialog.exec_(): self.helper.openRepresentationAsLayer(rep=dialog.created_rep)
class EmptyStageWidget(BaseWidget): def __init__(self, *args, **kwargs) -> None: super().__init__(*args, **kwargs) self.layout = QHBoxLayout(self) generators = QueryList( """query { nodes(type: "GENERATOR") { id name } }""", Node).run() self.generators = GeneratorListWidget(generators, title="Generate Data", base=self.base) self.layout.addWidget(self.generators) self.layout.update()
class Example(QWidget): def __init__(self): super().__init__() self.initUI() self.file_path = None self.main_file = None self.folder_path = None self.results_f_path = None self.main_text_input = None self.secondary_text_input = None self.main_file_column_status = None self.if_column_found_checks = [] self.column_name_list = [] def initUI(self): self.text = "" QToolTip.setFont(QFont('SansSerif', 10)) self.setWindowTitle('Paieška') self.setGeometry(450, 450, 450, 350) self.setFixedSize(self.size()) self.hbox = QHBoxLayout() self.main_file_text_input_box() self.secondary_files_text_input_box() self.hbox.addStretch(1) self.file_button() self.folder_button() self.where_to_put_button() self.hbox.addWidget(self.exit_button()) self.hbox.addWidget(self.reset_button()) self.hbox.addWidget(self.start_button()) self.hbox.addWidget(self.export_button()) vbox = QVBoxLayout() vbox.addStretch(1) vbox.addLayout(self.hbox) self.text_field() self.setLayout(vbox) self.show() def start_button(self): self.start_btn = QPushButton("Pradėti paiešką") self.start_btn.clicked.connect(self.start_read) self.start_btn.setEnabled(False) return self.start_btn def exit_button(self): cancel_button = QPushButton("Atšaukti/Išeiti") cancel_button.clicked.connect(QApplication.instance().closeAllWindows) return cancel_button def reset_button(self): reset_button = QPushButton("Iš naujo") reset_button.clicked.connect(self.reset_UI) return reset_button def export_button(self): self.export_btn = QPushButton("Ieškoti atitikimų ir eksportuoti") self.export_btn.hide() self.export_btn.clicked.connect(self.export_start) return self.export_btn def reset_UI(self): self.file_btn.setText("Pasirinkti") self.folder_btn.setText("Pasirinkti") self.where_to_btn.setText("Pasirinkti") self.file_btn.setEnabled(True) self.folder_btn.setEnabled(False) self.where_to_btn.setEnabled(False) self.box.setPlainText("") self.text_input_one.setText("") self.text_input_two.setText("") self.text_input_one.setEnabled(False) self.text_input_two.setEnabled(False) self.file_path = None self.main_file = None self.folder_path = None self.results_f_path = None self.main_text_input = None self.secondary_text_input = None self.main_file_column_status = None self.if_column_found_checks = [] self.column_name_list = [] self.export_btn.hide() self.start_btn.show() self.start_btn.setEnabled(True if self.start_btn.setEnabled(False) else False) self.export_btn.setEnabled(True) self.export_btn.setText("Ieškoti atitikimų ir eksportuoti") Parsing.__init__() def export_start(self): try: Parsing.make_excel(self.results_f_path) except: print(traceback.format_exc()) if Parsing.found_status: self.box.appendPlainText(f"Sėkmingai eksportuoti rezultatai, " f"dokumento pavadinimas -\n" f"'{Parsing.result_file_name}'," f" aplanke '{os.path.basename(self.results_f_path)}'.") self.export_btn.setText("Eksportuota") else: self.box.appendPlainText(f"Nei vieno įrašo nerasta.") self.export_btn.setText("Nerasta") self.export_btn.setEnabled(False) self.box.verticalScrollBar().setValue(self.box.verticalScrollBar().maximum()) def start_read(self): if self.checks(): file_paths = Parsing.get_excel_list(self.folder_path) if "~$" not in str(file_paths): if "" is not self.text_input_one.text() and "" is not self.text_input_two.text(): self.find_and_parse_main_excel_file() self.find_and_parse_secondary_excel_files(file_paths) self.start_btn.hide() self.export_btn.show() self.hbox.update() else: QMessageBox.about(self, "Kažkas netaip", f"Pateikite stulpelio pavadinimą!") else: QMessageBox.about(self, "Kažkas netaip", f"Kažkuris dokumentas yra atidarytas!") def checks(self): checks = [self.file_path, self.folder_path, self.results_f_path] if not all(checks): QMessageBox.about(self, "Kažkas netaip", f"Visi laukai turi būti parinkti!") else: return True def executor_and_columns(self, directories): try: start = time.time() with ThreadPoolExecutor(max_workers=5) as p: a = {p.submit(self.find_secondary_file_columns, directory): directory for directory in directories} for future in as_completed(a): try: self.column_name_list.append(future.result()) except xlrd.biffh.XLRDError: print(traceback.format_exc()) continue end = time.time() print(f"Search and parse took: {round(end - start, 2)}s") except: print(traceback.format_exc()) # finally: # self.print_found() def find_and_parse_secondary_excel_files(self, directories): if directories: self.input_column_name = self.input_column_names_parse(self.text_input_two.text()) self.box.appendPlainText(f"Aplanke '{os.path.basename(self.folder_path)}' rasti šie dokumentai" f" ir jų stulpeliai:") self.executor_and_columns(directories) if self.main_file_column_status: self.box.appendPlainText("Jeigu viskas teisingai - spauskite " "'Ieškoti atitikimų ir eksportuoti' mygtuką.") if not all(self.if_column_found_checks): column_not_found_count = self.if_column_found_checks.count(False) self.box.appendPlainText(f"{column_not_found_count} dokument" f"{'ai' if column_not_found_count > 1 else 'as'} " f"neturėjo ieškomo stulpelio, " f"prašoma dar kartą patikrinti ar viską teisingai suvedėte.") else: self.box.appendPlainText("Klaida!\nPatikrinkite ar gerai įvedėte stuleplių pavadinimus" "/ar gerai parinkote reikalingą pagrindinį failą.\n" "Bandykite viską iš naujo.") else: self.box.appendPlainText(f"Aplanke '{os.path.basename(self.folder_path)}' nerasta excel failų.") self.export_btn.setEnabled(False) def print_found(self): for idx, (file_name, column_info) in enumerate(self.column_name_list, 1): try: column_info = ", ".join(column_info) except TypeError: column_info = " Reikalingas stulpelis nerastas." self.box.appendPlainText(f"{idx}. {file_name}:\n Stulpelis {column_info}.\n") def find_secondary_file_columns(self, directory): if str(self.main_file) not in str(directory) and "rezultatai" not in str(directory): file = str(directory).split("\\")[-1] try: column_abc, column_name = Parsing.find_needed_column(Path(directory), self.input_column_name) except TypeError: column_abc = None if column_abc is not None: self.if_column_found_checks.append(True) return file, [column_abc, column_name] else: self.if_column_found_checks.append(False) return file, None def find_and_parse_main_excel_file(self): input_column_name = self.input_column_names_parse(self.text_input_one.text()) self.box.appendPlainText(f"\nFaile '{self.main_file}' rastas šis stulpelis:") try: column_abc, column_header = Parsing.find_needed_column(Path(self.file_path), input_column_name, main=True) except TypeError: column_abc = None if column_abc is not None: self.box.appendPlainText(f"1. Stulpelis {column_abc}, {column_header}\n") self.main_file_column_status = True else: self.box.appendPlainText(f"1. Reikalingas stulpelis nerastas.\n") self.main_file_column_status = False self.export_btn.setEnabled(False) def input_column_names_parse(self, text): return text.split(" ") def main_file_text_input_box(self): self.main_text_input_label() self.text_input_one = QLineEdit(self) self.text_input_one.move(265, 35) self.text_input_one.resize(150, 20) self.text_input_one.setEnabled(False) def main_text_input_label(self): lbl1 = QLabel('Failo, pagal kurį ieškoma\nstulpelio pavadinimas:', self) lbl1.move(280, 5) lbl1.resize(150, 30) def secondary_files_text_input_box(self): self.secondary_text_input_label() self.text_input_two = QLineEdit(self) self.text_input_two.move(265, 85) self.text_input_two.resize(150, 20) self.text_input_two.setEnabled(False) def secondary_text_input_label(self): lbl1 = QLabel('Failo, kuriame ieškoma\nstulpelio pavadinimas:', self) lbl1.move(280, 55) lbl1.resize(150, 30) def center(self): qr = self.frameGeometry() cp = QDesktopWidget().availableGeometry().center() qr.moveCenter(cp) self.move(qr.TopLeft()) def text_field(self): self.box = QPlainTextEdit(self) self.box.insertPlainText(self.text) self.box.setReadOnly(True) self.box.move(10, 115) self.box.resize(430, 195) def file_button(self): lbl1 = QLabel('<b>1.</b>', self) lbl1.move(10, 10) lbl2 = QLabel("Pasirinkite failą:", self) lbl2.move(25, 9) self.file_btn = QPushButton('Pasirinkti', self) self.file_btn.setToolTip('Pasirinkite failą iš kurio bus ieškoma.') self.file_btn.clicked.connect(self.select_file) self.file_btn.resize(self.file_btn.sizeHint()) self.file_btn.move(150, 10) def folder_button(self): lbl1 = QLabel('<b>2.</b>', self) lbl1.move(10, 40) lbl2 = QLabel('Pasirinkite aplanką:', self) lbl2.move(25, 40) self.folder_btn = QPushButton('Pasirinkti', self) self.folder_btn.setToolTip('Pasirinkite aplanką kuriame bus ieškoma.') self.folder_btn.setEnabled(False) self.folder_btn.clicked.connect(self.select_folder) self.folder_btn.resize(self.folder_btn.sizeHint()) self.folder_btn.move(150, 42) def where_to_put_button(self): lbl1 = QLabel('<b>3.</b>', self) lbl1.move(10, 70) lbl2 = QLabel("Pasirinkite rastų\nrezultatų aplanką:", self) lbl2.move(25, 70) self.where_to_btn = QPushButton('Pasirinkti', self) self.where_to_btn.setToolTip('Pasirinkite aplanką kuriame bus išsaugoti rezultatai.') self.where_to_btn.setEnabled(False) self.where_to_btn.clicked.connect(self.select_where_to_put) self.where_to_btn.resize(self.where_to_btn.sizeHint()) self.where_to_btn.move(150, 74) def select_file(self): dialog = QFileDialog() file_path, _ = dialog.getOpenFileName(None, caption="Pasirinkite failą", directory=expanduser("~"), filter="Excel files (*.xlsx *.xls *.xlt)") if file_path: self.file_path = file_path file = file_path.split("/")[-1] self.main_file = file self.box.appendPlainText(f"Pasirinktas '{file}' kaip pagrindinis dokumentas.") self.folder_btn.setEnabled(True) self.file_btn.setText("Pasirinkta") self.file_btn.setEnabled(False) self.text_input_one.setEnabled(True) def select_folder(self): dialog = QFileDialog() folder_path = dialog.getExistingDirectory(None, caption="Pasirinkite aplanką", directory=expanduser("~")) if folder_path: self.folder_path = folder_path self.box.appendPlainText(f"Pasirinktas '{os.path.basename(folder_path)}' aplankas.") self.where_to_btn.setEnabled(True) self.folder_btn.setText("Pasirinkta") self.folder_btn.setEnabled(False) self.text_input_two.setEnabled(True) def select_where_to_put(self): dialog = QFileDialog() folder_path = dialog.getExistingDirectory(None, caption="Pasirinkite aplanką", directory=expanduser("~")) if folder_path: self.results_f_path = folder_path self.box.appendPlainText(f"Rezultatai bus talpinami '{os.path.basename(folder_path)}' aplanke.") self.where_to_btn.setText("Pasirinkta") self.where_to_btn.setEnabled(False) self.start_btn.setEnabled(True) def closeEvent(self, event): reply = QMessageBox.question(self, 'Uždarymo langas', 'Ar tikrai norite uždaryti programą?', QMessageBox.Yes | QMessageBox.No, QMessageBox.No) if reply == QMessageBox.Yes: event.accept() else: event.ignore()
class OptionsSelector(BaseSelector): options = None # can stay not used def __init__(self, *args, base, options=None, add_none=False, on_select=None, **kwargs): super().__init__(*args, base=base, **kwargs) self.add_none = add_none self.on_select = on_select self.options = options or self.options self.option_items = list(options.items()) self.options_selector = None assert self.options is not None, "Please provide either options as argument or subclass" self.layout = QHBoxLayout() self.setLayout(self.layout) self.buildOrReplaceSelector() def buildOrReplaceSelector(self): options_selector = QComboBox() if self.add_none: options_selector.addItem("-----") for key, option in self.option_items: options_selector.addItem(option) options_selector.currentIndexChanged.connect(self.indexChanged) if len(self.option_items) > 0 and not self.add_none: self.selected_option = self.option_items[0][ 0] # We automatically select the first item once rebuilding if not self.options_selector: self.layout.addWidget(options_selector) self.model_selector = options_selector else: self.layout.replaceWidget(self.options_selector, options_selector) self.model_selector.close() self.model_selector.setParent(None) self.model_selector = options_selector self.layout.update() return self.options_selector def indexChanged(self, index): if self.add_none: if index == 0: self.selected_option = None else: self.selected_option = self.option_items[index - 1][ 0] # First item is the key not the label else: self.selected_option = self.option_items[index][0] if self.on_select: self.on_select(self.selected_option) def getValue(self): return self.selected_option
class MainWindow(QMainWindow): def __init__(self, parent=None): QMainWindow.__init__(self, parent) self.is_playing = False self.animTimer = QTimer() self.play_speed_userDef = play_speed self.play_speed = play_speed # speed will be slowed down x30 for Kinect, since the images are furth apart in time self.animTimer.setInterval(self.play_speed) self.animTimer.timeout.connect( self.read_next_frame) # connect timeout signal to signal handler self.animTimer.stop() self.viewDataType = '' self.setup_data() self.ChangeDog(self.dog) self.UpdateDataAfterMotionChange(self.availableMotions[0]) self.setup_ui() print('self.camIdx', self.camIdx) self.ChangeCamera(self.camIdx) self.update_render() def setup_data(self): self.vidFile = '' self.frameRaw = None self.ax3d = None clrs = { 'red': (255, 0, 0), 'blue': (0, 0, 255), 'green': (0, 255, 0), 'yellow': (255, 255, 0), 'cyan': (0, 255, 255), 'magenta': (255, 0, 255), 'white': (255, 255, 255), 'darkerBlue': (39, 127, 255) } self.skelJntClr = clrs['red'] self.skelLeftRightClrs = [clrs['cyan'], clrs['magenta']] # [left, right] self.markerClr = [ clrs['cyan'], clrs['darkerBlue'], clrs['darkerBlue'] ] # [left, center, right] self.indivMarkerClr = clrs['red'] self.camColour = clrs['cyan'] self.plotCameras = True self.camIdx = 0 self.showMeshMask = False self.plotCalibs = True self.plotMarkers = False self.plotSkel = True self.availableDogs = utils_mc.GetDogs(pathToMainDataset) self.dog = self.availableDogs[0] def get_layout_region(self, control_set): layout_region = QVBoxLayout() scrollArea = QScrollArea() scrollArea.setWidgetResizable(True) scrollAreaWidgetContents = QWidget(scrollArea) scrollArea.setWidget(scrollAreaWidgetContents) scrollArea.setMinimumWidth(750) grid_layout = QGridLayout() for idx, (label, com_slider) in enumerate(control_set): grid_layout.addWidget(label, idx, 0) grid_layout.addWidget(com_slider, idx, 1) scrollAreaWidgetContents.setLayout(grid_layout) layout_region.addWidget(scrollArea) return layout_region def setup_ui(self): self.video_controls = [] self.camera_controls = [] self.displayData_controls = [] def ctrl_layout_add_separator(): line = QFrame() line.setFrameShape(QFrame.HLine) line.setFrameShadow(QFrame.Sunken) ctrl_layout.addWidget(line) def view_layout_add_separator(): line = QFrame() line.setFrameShape(QFrame.HLine) line.setFrameShadow(QFrame.Sunken) view_layout.addWidget(line) # ---------------- rgb video -------------- view_layout = QVBoxLayout() self.render_img_label = QLabel() # this is the RGB image view_layout.addWidget(self.render_img_label) # ---------------- rgb video -------------- fontSize = 10 fontWeight = QtGui.QFont.Bold fontType = "Times" # --------------- video controls ----------- # reset self.is_playing = False self.markerFrame = 0 self.markerFrame = 0 self.animTimer.stop() self.anim_frame = QFrame() self.anim_layout = QGridLayout() self.play_video_pb = QPushButton('Play') self.play_video_pb.clicked.connect(self.playPauseVideo) self.anim_layout.addWidget(self.play_video_pb, 0, 1) nextFrame_pb = QPushButton('Next Frame') nextFrame_pb.clicked.connect(partial(self.read_next_frame, True)) self.anim_layout.addWidget(nextFrame_pb, 0, 2) prevFrame_pb = QPushButton('Prev Frame') prevFrame_pb.clicked.connect(partial(self.read_next_frame, False)) self.anim_layout.addWidget(prevFrame_pb, 0, 0) # ----visibility controls ---- labelA = QLabel('Toggle Visible:') labelA.setFont(QtGui.QFont(fontType, fontSize, fontWeight)) self.anim_layout.addWidget(labelA, 0, 3) markerVis_pb = QPushButton('Markers') markerVis_pb.clicked.connect(partial(self.ToggleVisibility, 'markers')) self.anim_layout.addWidget(markerVis_pb, 0, 4) skelVis_pb = QPushButton('Skeleton') skelVis_pb.clicked.connect(partial(self.ToggleVisibility, 'skeleton')) self.anim_layout.addWidget(skelVis_pb, 0, 5) camVis_pb = QPushButton('Cameras') camVis_pb.clicked.connect(partial(self.ToggleVisibility, 'cameras')) self.anim_layout.addWidget(camVis_pb, 0, 6) maskVis_pb = QPushButton('Mask') maskVis_pb.clicked.connect(partial(self.ToggleVisibility, 'masks')) self.anim_layout.addWidget(maskVis_pb, 0, 7) # ---- visibility controls ---- self.anim_frame.setLayout(self.anim_layout) view_layout.addWidget(self.anim_frame) # ---- camera controls ------- self.cam_frame = self.UpdateCameraButtons() labelA = QLabel('Cameras:') labelA.setFont(QtGui.QFont(fontType, fontSize, fontWeight)) view_layout.addWidget(labelA) view_layout.addWidget(self.cam_frame) self.view_layout = view_layout # ---- camera controls ------- # ------- available dogs------- self.ctrl_layout = QVBoxLayout() dog_layout = QGridLayout() for idx, dog in enumerate(self.availableDogs): dog_pb = QPushButton(dog) dog_pb.clicked.connect(partial(self.ChangeDog_buttonClick, dog)) dog_layout.addWidget(dog_pb, idx, 0) self.dog_frame = QFrame() self.dog_frame.setLayout(dog_layout) labelDogs = QLabel('Dogs:') labelDogs.setFont(QtGui.QFont(fontType, fontSize, fontWeight)) self.ctrl_layout.addWidget(labelDogs) self.ctrl_layout.addWidget(self.dog_frame) # ------- available motions------- # ------- available motions------- self.motion_frame = self.UpdateMotionButtons() labelMotions = QLabel('Motions:') labelMotions.setFont(QtGui.QFont(fontType, fontSize, fontWeight)) self.ctrl_layout.addWidget(labelMotions) self.ctrl_layout.addWidget(self.motion_frame) # ------- available motions------- # ------- available modalities -------- self.modal_frame = self.UpdateModalitiesButtons() self.ctrl_layout.addWidget(self.modal_frame) # ------- available modalities -------- self.main_layout = QHBoxLayout() self.main_layout.addLayout(view_layout) self.main_layout.addLayout(self.ctrl_layout) self.main_widget = QWidget() self.main_widget.setLayout(self.main_layout) self.setCentralWidget(self.main_widget) # WINDOW self.window_title_stem = 'Data Viewer' self.setWindowTitle(self.window_title_stem) self.statusBar().showMessage('Ready...') self.showMaximized() def UpdateCameraButtons(self): cam_numRows = 2 cam_numCols = math.ceil(len(self.cams) / cam_numRows) cam_layout = QGridLayout() for idx, cam in enumerate(self.cams): cam_pb = QPushButton(cam) cam_pb.clicked.connect(partial(self.ChangeCamera, idx, True)) cam_layout.addWidget(cam_pb, (idx // cam_numCols), (idx % cam_numCols)) cam_frame = QFrame() cam_frame.setLayout(cam_layout) return cam_frame def UpdateModalitiesButtons(self): mod_layout = QGridLayout() for idx, modal in enumerate(self.availableModalities): mod_pb = QPushButton(modal) mod_pb.clicked.connect( partial(self.ChangeModality_buttonClick, modal)) mod_layout.addWidget(mod_pb, idx, 0) mod_frame = QFrame() mod_frame.setLayout(mod_layout) return mod_frame def UpdateMotionButtons(self): motion_layout = QGridLayout() for idx, motion in enumerate(self.availableMotions): motion_pb = QPushButton(motion) motion_pb.clicked.connect(partial(self.ChangeMotion, idx)) motion_layout.addWidget(motion_pb, idx, 0) motion_frame = QFrame() motion_frame.setLayout(motion_layout) return motion_frame def update_render(self, useRawFrame=False): if not useRawFrame: # update self.frameRaw if self.viewDataType == 'sony': [ret, self.vidFile ] = utils_mc.SetVideoToFrameNumber(self.vidFile, self.imageFrame) ret, frameRaw = self.vidFile.read() self.frameRaw = frameRaw[:, :, (2, 1, 0)] # reorder elif self.viewDataType == 'kinect_rgb': frameRaw = cv2.imread( join(self.pathToImageFolder_current, self.imageNames[self.imageFrame])) self.frameRaw = frameRaw[:, :, (2, 1, 0)] # reorder else: #if self.viewDataType == 'kinect_depth' frameRaw = cv2.imread( join(self.pathToImageFolder_current, self.imageNames[self.imageFrame]), -1) frameRaw = frameRaw.astype('float') / np.amax( frameRaw) # scaled 0-1 frameRaw = frameRaw * 255 frameRaw = frameRaw.astype('uint8') self.frameRaw = np.stack((frameRaw, ) * 3, axis=-1) s = 'Dog: %s, Motion: %s, Camera: %s, Frame: %d' % ( self.dog, self.motion, self.cams[self.camIdx], self.markerFrame) self.window_title_stem = s self.setWindowTitle(self.window_title_stem) if self.frameRaw is not None: self.frame = self.UpdatePlotData(self.frameRaw.copy()) frame_origSize = self.frame.copy() self.render_img_label.setPixmap( self.image_to_pixmap(self.frame, DISPLAY_SIZE)) self.render_img_label.update() def toggle_control(self, layout): sender = self.sender() layout.setHidden(not sender.isChecked()) def playPauseVideo(self): self.is_playing = not self.is_playing print('self.is_playing', self.is_playing) if self.is_playing: self.play_video_pb.setText('Pause') self.animTimer.start() else: self.play_video_pb.setText('Play') self.animTimer.stop() def nextFrame(self): self.read_next_frame(True) def prevFrame(self): self.read_next_frame(False) def updateFrame(self, fr, nextFrameGoingForward=True): # for the sony videos, we can just increment frame # for kinect videos, we increment the image frame normally, but the marker frame needs to find the next valid timecode if nextFrameGoingForward: fr += 1 if fr >= self.numFrames: fr = 0 else: fr -= 1 if fr < 0: fr = self.numFrames - 1 return self.allowableMarkerFrames[fr], fr def read_next_frame(self, nextFrameGoingForward=True): self.markerFrame, self.imageFrame = self.updateFrame( self.imageFrame, nextFrameGoingForward) self.update_render() def image_to_pixmap(self, img, img_size): qim = QImage(img.data, img.shape[1], img.shape[0], img.strides[0], QImage.Format_RGB888).copy() pixmap = QPixmap(qim) # return pixmap.scaled(img_size, img_size, QtCore.Qt.KeepAspectRatio) return pixmap.scaledToHeight(img_size) # this is called every time we go back/forward a frame, change camera, etc def UpdatePlotData(self, frame): if self.showMeshMask: mask = cv2.imread( join(self.pathToMasks % self.cams[self.camIdx], self.imageNames[self.imageFrame]), -1) mask = cv2.resize(mask, (0, 0), fx=self.postProjectionScale, fy=self.postProjectionScale, interpolation=cv2.INTER_NEAREST) mask = mask / np.amax(mask) mask = np.stack((mask.astype(np.uint8), ) * 3, axis=-1) frame = frame * mask if self.plotMarkers: points2d = self.GetProjectedPoints(self.markers[:, :, self.markerFrame]) points2d *= self.postProjectionScale frame = utils.Plot2d_markers(frame, points2d, connections=self.markerConn, lineThickness=self.markerPlotSize, radius=-1, markerNames=self.markerNames, markerClr=self.markerClr, indivMarkerClr=self.indivMarkerClr) if self.plotSkel: points2d = self.GetProjectedPoints( self.bvhJoints[:, :, self.markerFrame + 1]) points2d *= self.postProjectionScale frame = utils.Plot2d(frame, points2d, self.skelConnections, radius=self.skeletonRadiusSize, lineThickness=self.skeletonPlotSize, plotJoints=True, differentColoursForSides=True, markerClr=self.skelJntClr, leftRightClrs=self.skelLeftRightClrs) if self.plotCameras: cameraLoc_2d = self.GetProjectedPoints(self.cam_world_translation) cameraLoc_2d *= self.postProjectionScale cameraLoc_2d = np.round(cameraLoc_2d).astype(np.int) font = cv2.FONT_HERSHEY_SIMPLEX for camIdx, loc in enumerate(cameraLoc_2d): if loc[0] > -1 and loc[1] > -1 and loc[0] < frame.shape[ 1] and loc[1] < frame.shape[ 0] and camIdx != self.camIdx: frame = cv2.circle(frame, (loc[0], loc[1]), self.cameraPlotRadius, self.camColour, self.cameraPlotThickness, 1) frame = cv2.putText(frame, self.cams[camIdx], (loc[0], loc[1]), font, self.cameraFontScale, self.camColour, self.cameraFontThickness) return frame def ToggleVisibility(self, dataType): if dataType == 'markers': self.plotMarkers = not self.plotMarkers elif dataType == 'skeleton': self.plotSkel = not self.plotSkel elif dataType == 'cameras': self.plotCameras = not self.plotCameras elif dataType == 'masks': self.showMeshMask = not self.showMeshMask self.update_render(True) # don't go onto the next frame def GetProjectedPoints(self, points3d): #calibration data_dog rot3x1 = self.calibData['rot3x1'] t = self.calibData['t'] K = self.calibData['K'] distCoeffs = self.calibData['distCoeffs'] [points2d, jac] = cv2.projectPoints(points3d, rot3x1, t, K, distCoeffs) points2d = np.reshape(points2d, [points2d.shape[0], 2]) return points2d def ChangeDog_buttonClick(self, dog): self.ChangeDog(dog) # update the camera buttons self.view_layout.removeWidget(self.cam_frame) self.cam_frame.deleteLater() self.cam_frame = self.UpdateCameraButtons() self.view_layout.addWidget(self.cam_frame) # update the motion buttons self.ctrl_layout.removeWidget(self.motion_frame) self.motion_frame.deleteLater() # self.motion_frame = None self.motion_frame = self.UpdateMotionButtons() self.ctrl_layout.addWidget(self.motion_frame) self.main_layout.update() self.main_widget.update() self.ChangeMotion(0) def ChangeDog(self, dog): print(dog) self.dog = dog self.pathToDog = join(pathToMainDataset, dog) self.availableMotions = utils_mc.GetMotionsForDog(self.pathToDog) self.ChangeModality() # updates self.cams def ChangeModality_buttonClick(self, modal): print(modal) prev_model = self.viewDataType self.viewDataType = modal self.ChangeModality() self.UpdateDataAfterModalityChange() if not ('kinect' in prev_model and 'kinect' in modal): self.camIdx = 0 # else: keep the camera ID the same if flicking between kinect cameras markerFrame_prev = self.markerFrame imageFrame_prev = self.imageFrame self.ChangeCamera(self.camIdx, updateRender=False) if 'kinect' in prev_model and 'kinect' in modal: self.markerFrame = markerFrame_prev self.imageFrame = imageFrame_prev # else keep the image frame the same # update the camera buttons self.view_layout.removeWidget(self.cam_frame) self.cam_frame.deleteLater() self.cam_frame = self.UpdateCameraButtons() self.view_layout.addWidget(self.cam_frame) self.main_layout.update() self.main_widget.update() self.update_render() def ChangeModality(self): if self.viewDataType == '': # this is true when we first run the script availableModalities = utils_mc.GetModalityForMotion( join(pathToMainDataset, self.dog, 'motion_%s' % self.availableMotions[0])) self.viewDataType = availableModalities[ -1] # start with sony, if possible self.pathToCalibs = join(self.pathToDog, 'calibration', self.viewDataType) self.cams = utils_mc.GetCamerasForModality(self.pathToCalibs) assert len(self.pathToCalibs) > 0, 'no calibration path found' self.calibData_allCalibs_allCams = utils.GetCalibData( self.pathToCalibs, self.cams) assert len( self.calibData_allCalibs_allCams) > 0, 'no calibration data found' self.cam_world_rotations = np.zeros( (len(self.calibData_allCalibs_allCams), 3, 3)) self.cam_world_translation = np.zeros( (len(self.calibData_allCalibs_allCams), 3)) for idx, calib in enumerate(self.calibData_allCalibs_allCams): L = calib['calib']['L'] Linv = np.linalg.inv(L) self.cam_world_rotations[idx] = Linv[0:3, 0:3] self.cam_world_translation[idx] = Linv[0:3, 3] def UpdateDataAfterModalityChange(self): self.postProjectionScale = 1 self.pathToVid = '' # for sony self.pathToImageFolder_current = '' # for kinect self.imageNames = [] self.markerPlotSize = 3 self.skeletonPlotSize = 4 self.skeletonRadiusSize = 2 self.cameraPlotRadius = 5 self.cameraPlotThickness = 2 self.cameraFontScale = 2 self.cameraFontThickness = 3 if self.viewDataType == 'sony': self.pathToVid = join(self.pathToMotion, 'sony', 'camera%s', 'camera%s_2K.mp4') self.postProjectionScale = 0.5 # 4K calibration values but 2K video self.play_speed = self.play_speed_userDef self.imageFrame = 0 self.markerFrame = 0 else: self.pathToImageFolder = join(self.pathToMotion, self.viewDataType, 'camera%s', 'images') self.play_speed = self.play_speed_userDef * 30 if 'depth' in self.viewDataType: self.markerPlotSize = 2 self.skeletonPlotSize = 2 self.skeletonRadiusSize = 1 self.cameraPlotRadius = 3 self.cameraPlotThickness = 1 self.cameraFontScale = 0.75 self.cameraFontThickness = 1 self.animTimer.setInterval(self.play_speed) self.pathToMasks = join(self.pathToMotion, self.viewDataType, 'camera%s', 'masks') self.vidFiles = [] self.vidFilesPaths = [] self.numCams = len(self.cams) if self.viewDataType == 'sony': for c in self.cams: pathToCurrVid = self.pathToVid % (c, c) self.vidFilesPaths.append(pathToCurrVid) def ChangeMotion(self, motionIdx): self.motionIdx = motionIdx print('change motion to %s' % self.availableMotions[motionIdx]) self.UpdateDataAfterMotionChange(self.availableMotions[motionIdx]) self.ChangeCamera(self.camIdx) # update the modality buttons self.ctrl_layout.removeWidget(self.modal_frame) self.modal_frame.deleteLater() self.modal_frame = self.UpdateModalitiesButtons() self.ctrl_layout.addWidget(self.modal_frame) self.main_layout.update() self.main_widget.update() def UpdateDataAfterMotionChange(self, motion): self.statusBar().showMessage('Loading %s...' % motion) self.motion = motion dog = self.dog self.availableModalities = utils_mc.GetModalityForMotion( join(pathToMainDataset, dog, 'motion_%s' % motion)) if self.viewDataType is None or self.viewDataType not in self.availableModalities: self.viewDataType = self.availableModalities[0] fullPathToMotionCaptureFolder = join(pathToMainDataset, dog, 'motion_%s' % motion, 'motion_capture') self.timecodes = utils_mc.GetTimecodesForSequence( fullPathToMotionCaptureFolder) self.numFrames = len(self.timecodes) - 1 self.numFrames_skeletonTotal = self.numFrames self.videoIdxStart = 0 self.videoIdxEnd = self.numFrames self.pathToMotion = os.path.join(pathToMainDataset, dog, 'motion_%s' % motion) self.UpdateDataAfterModalityChange() # ----------------------------------- load the skeleton ----------------------------- bvhSkelFile = os.path.join(self.pathToMotion, 'motion_capture', 'skeleton.bvh') skelConnections_asNp = os.path.join(self.pathToMotion, 'motion_capture', 'skelConnections.npy') bvhSkelFile_asNp = bvhSkelFile[:bvhSkelFile.rfind('.')] + '.npy' print('loading skeleton...') if os.path.isfile(bvhSkelFile_asNp): bvhJoints = np.load(bvhSkelFile_asNp) skelConnections = np.load(skelConnections_asNp) else: bvhJoints, skelConnections, nodes = utils.ReadBvhFile( bvhSkelFile, False) bvhJoints = utils.MovePointsOutOfMayaCoordSystem(bvhJoints, 1) np.save(bvhSkelFile_asNp, bvhJoints) np.save(skelConnections_asNp, skelConnections) self.bvhJoints = bvhJoints self.skelConnections = skelConnections # ----------------------------------- load the markers ----------------------------- markerFile = os.path.join(self.pathToMotion, 'motion_capture', 'markers.json') markerFile_asNp = markerFile[:markerFile.rfind('.')] + '.npy' markerFile_namesText = markerFile[:markerFile.rfind('.' )] + '_names.txt' print('loading markers...') if os.path.isfile(markerFile_asNp): markers = np.load(markerFile_asNp) with open(markerFile_namesText, 'r') as f: markerNames_joined = f.read() markerNames = markerNames_joined.split(',') else: [markerNames, markers] = utils.GetPointsFromJsonFbx(markerFile) markers = utils.MovePointsOutOfMayaCoordSystem(markers) np.save(markerFile_asNp, markers) markerNames_joined = ','.join(markerNames) with open(markerFile_namesText, 'w') as f: f.write(markerNames_joined) self.markers = markers self.markerNames = markerNames # ----------------------------------- load the stick file that defines the relationship between the markers ----------------------------- # use the vskSticks.txt file to get the connection between markers vskSticks = os.path.join(pathToMainDataset, dog, 'meta', 'vskSticks.txt') markerConn = [] with open(vskSticks, 'r') as myFile: for f in myFile: res = [x.strip() for x in f.split(' ')] #convert from name to index markerConn.append( [markerNames.index(res[0]), markerNames.index(res[1])]) self.markerConn = markerConn self.imageFrame = 0 # this is the frame for the images. For sony, this is [0,1,2,...] for Kinect, this might be [2,5,10,13,...] self.markerFrame = 0 # markerFrame is the frame into the array of markers self.statusBar().showMessage('Loaded %s...' % motion) def ChangeCamera(self, camIdx, updateRender=True): self.camIdx = camIdx if self.viewDataType == 'sony': self.vidFile = cv2.VideoCapture(self.vidFilesPaths[self.camIdx]) [ret, self.vidFile ] = utils_mc.SetVideoToFrameNumber(self.vidFile, self.markerFrame) self.allowableMarkerFrames = np.arange( self.numFrames_skeletonTotal) self.numFrames = self.numFrames_skeletonTotal self.imageNames = utils_mc.GetFilesInFolder( self.pathToMasks % self.cams[self.camIdx], 'png') # keep marker and image frame the same, since all cameras have the same footage else: self.pathToImageFolder_current = self.pathToImageFolder % self.cams[ self.camIdx] self.imageNames = utils_mc.GetFilesInFolder( self.pathToImageFolder_current, 'png') self.allowableMarkerFrames = utils_mc.GetMarkerFramesForKinectCam( self.pathToImageFolder_current) # we might not have the same frame for this camera view, so go back to the start of the sequence self.markerFrame = self.allowableMarkerFrames[0] self.imageFrame = 0 self.numFrames = len(self.imageNames) print('setting calib data to camera', self.camIdx) self.calibData = self.calibData_allCalibs_allCams[self.camIdx] print('updateRender', updateRender) if updateRender: self.update_render()
class SkillGroupWidget(QWidget): def __init__(self, user_id, group, parent=None): QWidget.__init__(self, parent=parent) self.collapse = False # un/visible status of self.skills self.group = group # This group self.user_id = user_id self.skills = dbHandler.getGroupSkills( self.user_id, self.group.group_id) # List of Skills belonging to this group self.skillWidgets = [] self.total_sp = 0 self.sumSkillpoints() self.createSkillWidgets() self.setBackgroundColor() self.layout = QHBoxLayout() #self.layout.setAlignment(QtCore.Qt.AlignTop) self.layout.setContentsMargins(1, 1, 1, 1) self.layout.setSpacing(5) #self.layout.setSpacing(0) self.nameLabel = QLabel("Name") self.nameLabel.setFixedWidth(200) self.countLabel = QLabel("1 of 1 skills") self.countLabel.setFixedWidth(100) self.spLabel = QLabel("1.000.000 Points") self.spLabel.setFixedWidth(100) self.layout.addWidget(self.nameLabel) self.layout.addWidget(self.countLabel) self.layout.addWidget(self.spLabel) self.layout.addStretch(1) self.setLayout(self.layout) self.set_size_policy() self.setLabelStyle() self.updateLabels() def updateLabels(self): self.nameLabel.setText(self.group.name) total, known = dbHandler.getGroupSkillsCount(self.user_id, self.group.group_id) self.countLabel.setText(f'{known} of {total} skills') self.spLabel.setText(f'{tools.format(self.total_sp)} Points') self.layout.update() def setLabelStyle(self): self.nameLabel.setStyleSheet( 'QLabel { font-size: 12px; color: white; font-weight: bold}') self.countLabel.setStyleSheet('QLabel { color: white}') self.spLabel.setStyleSheet('QLabel { color: white}') def setBackgroundColor(self): self.setAutoFillBackground(True) # Background Color pal = QPalette() pal.setColor(self.backgroundRole(), QtCore.Qt.black) self.setPalette(pal) def set_size_policy(self): self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Maximum) def mousePressEvent(self, *args, **kwargs): self.toggleGroupCollapse() def toggleGroupCollapse(self): if self.collapse: for widget in self.skillWidgets: widget.setVisible(False) self.collapse = False else: for widget in self.skillWidgets: widget.setVisible(True) self.collapse = True def createSkillWidgets(self): for i, skill in enumerate(self.skills): widget = KnownSkillsItem(self.user_id, skill, i) widget.setVisible(False) #widget.setHidden(True) #widget.hide() self.skillWidgets.append(widget) def sumSkillpoints(self): self.total_sp = 0 for skill in self.skills: self.total_sp = self.total_sp + skill.skillpoints_in_skill def getChildWidgets(self): return self.skillWidgets
class QuantumGui(QMainWindow): def __init__(self): super().__init__() # The current loaded set self.currentSet = 1 #self.background = cv2.imread("test2.png", cv2.IMREAD_GRAYSCALE) # FOR TESTING self.title = 'Imaging' self.left = 5 self.top = 5 self.width = 800 self.height = 500 self.images = list() # [0, 1, 2, 3] // [0] = Big image - [1] to [3] = Smaller images self.imageLabels = list() # [0, 1, 2, 3] // [0] = Big image - [1] to [3] = Smaller images ---- These are PyQt5 Labels that gets updated. # Initializing the UI, loading images and rendering the objects self.initUI() # QTimer used for updating the images with a given time interval self.timer = QTimer() self.timer.timeout.connect(self.update) # Means that this timer will be calling the 'self.update()' method self.timer.start(settings.guiUpdateInterval) # Starts the timer and updates it at a given interval def initUI(self): # Assigning the title of the window self.setWindowTitle(self.title) # Assigning dimensions of this object self.setGeometry(self.left, self.top, self.width, self.height) # Basically initializing all image loading as well as rendering it self.createGridLayout(self.currentSet) self.show() """ This function loads the set of images specified, and renders them to the screen (It's only to be used when initiating the class) """ def createGridLayout(self, set): # Load the given set self.loadSet(set) # The grid self.hbox = QHBoxLayout() # Object that contains all the stuff to be displayed self.central_widget = QWidget() self.central_widget.setLayout(self.hbox) self.setCentralWidget(self.central_widget) # Left side = Big Image self.left = QSplitter(Qt.QtCore.Qt.Vertical) # Right side = 3 Small images self.right = QSplitter(Qt.QtCore.Qt.Vertical) # Puts the images onto the proper splitters for i in range(len(self.imageLabels)): label = self.imageLabels[i] if i == 3: # Big image is on index 3 in the images list print("Adding left side: ",label) self.left.addWidget(label) self.addToolBar(Qt.QtCore.Qt.BottomToolBarArea,NavigationToolbar(label, self)) else: # The smaller images are on index 0 through 2 in the images list print("Adding right side: ",label) self.right.addWidget(label) # Splitter is horizontal, first adding left side, then the right side self.splitter = QSplitter(Qt.QtCore.Qt.Horizontal) self.splitter.addWidget(self.left) self.splitter.addWidget(self.right) self.container = QSplitter(Qt.QtCore.Qt.Vertical) self.container.addWidget(self.splitter) # Adding the splitter, containg left and right sides, to the main container self.hbox.addWidget(self.container) """ This function loads the set of images specified and updates the image and image labels """ def loadSet(self, set): # Clear the old data self.images.clear() self.imageLabels.clear() # Dimensions of the window width = self.geometry().width() height = self.geometry().height() for i in range(settings.snapsPerSet): # Path to the image path = "img/snap_{},{}.tiff".format(self.currentSet, i+1) # Inserting the image object into the image list self.images.append(Image(path, int(width/3), int(height / 3 - 105))) print(path,":",self.images[i-1].cvimg) # Inserting the image (With text) into the list for image labels figure = showImage(self.images[i].cvimg, False) label = FigureCanvas(figure) self.imageLabels.append(label) label = FigureCanvas(showImage(opticalImageDepth(self.images[0].cvimg, self.images[1].cvimg, self.images[2].cvimg), True)) self.imageLabels.append(label) def update(self): if not settings.updateGui: return width = self.geometry().width() height = self.geometry().height() print(width,height) print("Updated") self.loadSet(self.currentSet) # Hide the old images (Because that's just how PyQt5 works) for c in self.left.children(): c.hide() for c in self.right.children(): c.hide() # Loop through newly loaded images, and insert them above the hidden old images for i in range(len(self.imageLabels)): label = self.imageLabels[i] if i == 3: #label.setPixmap(self.images[i].getPixmap().scaledToHeight(height - 105)) # Should be relative to the window size self.left.insertWidget(i, label) else: #label.setPixmap(self.images[i].getPixmap().scaledToHeight(height / 3 - 105)) # Should be relative to the window size self.right.insertWidget(i-1, label) # Update the containers self.left.update() self.right.update() self.splitter.update() self.container.update() self.hbox.update() settings.updateGui = False self.currentSet += 1
class ArnheimModelSelector(BaseSelector): list_query = None model = None new_form = None # can stay not used def __init__(self, *args, base, add_none=False, variables=None, with_form=True, on_select=None, **kwargs): super().__init__(*args, base=base, **kwargs) self.selected_model = None self.variables = variables self.selector = None self.model_selector = None self.with_form = with_form self.add_none = add_none self.on_select = on_select self.loadModels() self.layout = QHBoxLayout() self.setLayout(self.layout) self.buildOrReplaceSelector() self.buildButton() def loadModels(self): self.models = QueryList(self.list_query, self.model).run(variables=self.variables) def requestNewModel(self): form = self.new_form(base=self.base, parent=self) model = form.getModel() if model: self.models = [ model ] + self.models # We are adding it to the first list self.buildOrReplaceSelector() def buildOrReplaceSelector(self): assert self.models is not None, "Please load Models beforee" model_selector = QComboBox() if self.add_none: model_selector.addItem("-----") for model in self.models: model_selector.addItem(model.name) model_selector.currentIndexChanged.connect(self.indexChanged) if len(self.models) > 0: self.selected_model = self.models[ 0] # We automatically select the first item once rebuilding if not self.model_selector: self.layout.addWidget(model_selector) self.model_selector = model_selector else: self.layout.replaceWidget(self.model_selector, model_selector) self.model_selector.close() self.model_selector.setParent(None) self.model_selector = model_selector self.layout.update() return self.model_selector def buildButton(self): if self.new_form and self.with_form: new_model_button = QPushButton("+") new_model_button.clicked.connect(self.requestNewModel) self.layout.addWidget(new_model_button) self.layout.update() def indexChanged(self, index): if self.add_none: if index == 0: self.selected_model = None else: self.selected_model = self.models[index - 1] # First item is now add else: self.selected_model = self.models[index] if self.on_select: self.on_select(self.selected_model) def getValue(self): return str(self.selected_model.id ) if self.selected_model is not None else None
class Personenfenster(QWidget): def __init__(self): super().__init__() self.init() self.suche=False def string2list(self,tupel): retlist=[] for index in range(len(tupel)): string = tupel[index][0] retlist.append(string) return retlist def init(self): #Daten aus der Datenbank c.execute("SELECT nachname FROM personen") nachnamenlistealsstring=c.fetchall() c.execute("SELECT vorname FROM personen") vornamenlistealsstring=c.fetchall() c.execute("SELECT geburtsdatum FROM personen") geburtsdatenlistealsstring=c.fetchall() c.execute("SELECT person_id FROM personen") idlistealsstring=c.fetchall() nachnamenliste = self.string2list(nachnamenlistealsstring) vornamenliste = self.string2list(vornamenlistealsstring) geburtsdatenliste = self.string2list(geburtsdatenlistealsstring) idliste = self.string2list(idlistealsstring) self.scrollmatrix = [] for index,item in enumerate(vornamenliste): self.scrollmatrix.append([nachnamenliste[index],item, geburtsdatenliste[index],idliste[index]]) #Suchenfeld self.Input = QLineEdit(self) self.Input.setPlaceholderText("Suchen...") self.Input.returnPressed.connect(self.Inputtext) #+-Button self.AddButton = QPushButton("+") self.AddButton.clicked.connect(self.addPerson) self.clearButton = QPushButton("reset") self.clearButton.clicked.connect(self.clear) #HBox mit dem Suchen Feld ganz links und dem +-Button ganz rechts self.suchen = QHBoxLayout() self.suchen.addWidget(self.Input) self.suchen.addStretch(1) #self.suchen.addWidget(self.clearButton) self.suchen.addWidget(self.AddButton) #HBox mit den Überschriften für die einzelnen Zeilen: self.row0 = QGridLayout() self.row0.addWidget(QLabel("Nachname"),0,0,1,2) self.row0.addWidget(QLabel("Vorname"),0,2,1,2) self.row0.addWidget(QLabel("Geburtsdatum"),0,4,1,2) self.row0.addWidget(QLabel("Beten/Bearbeiten"),0,6,1,2) #Hier kommt die Personenanzeige self.scroll = QScrollArea() self.personenanzeige = QWidget() self.scroll.setWidgetResizable(True) #Hier kommen die Personen self.personenanzeigenLayout = QVBoxLayout(self.personenanzeige) for person in self.scrollmatrix: self.personenanzeigenLayout.addLayout(Row(person)) self.personenanzeigenLayout.addStretch(1) self.personenanzeige.setLayout(self.personenanzeigenLayout) self.scroll.setWidget(self.personenanzeige) #setzt alles in eine große VBox self.vbox = QVBoxLayout() self.vbox.addLayout(self.suchen) self.vbox.addLayout(self.row0) self.vbox.addWidget(self.scroll) self.setLayout(self.vbox) def Inputtext(self): text1 = self.Input.text() if text1!=None and text1!="": text1=str(text1) c.execute("SELECT nachname FROM personen") nachnamenlistealsstring=c.fetchall() c.execute("SELECT vorname FROM personen") vornamenlistealsstring=c.fetchall() c.execute("SELECT geburtsdatum FROM personen") geburtsdatenlistealsstring=c.fetchall() c.execute("SELECT person_id FROM personen") idlistealsstring=c.fetchall() nachnamenliste = self.string2list(nachnamenlistealsstring) vornamenliste = self.string2list(vornamenlistealsstring) geburtsdatenliste = self.string2list(geburtsdatenlistealsstring) idliste = self.string2list(idlistealsstring) searchednachname=[] for nachname in nachnamenliste: if nachname: if text1 in nachname: searchednachname.append(nachname) searchedvorname=[] for vorname in vornamenliste: if vorname: if text1 in vorname: searchedvorname.append(vorname) idliste=[] searchednachname=list(set(searchednachname)) searchedvorname=list(set(searchedvorname)) for i in searchednachname: c.execute("""SELECT person_id FROM personen WHERE nachname="{}" """.format(i)) a=c.fetchall() for j in a: idliste.append(j[0]) for i in searchedvorname: c.execute("""SELECT person_id FROM personen WHERE vorname="{}" """.format(i)) a=c.fetchall() for j in a: idliste.append(j[0]) idliste=list(set(idliste)) if len(idliste)>0: nachnamenliste=[] vornamenliste=[] geburtsdatenliste=[] for i in idliste: c.execute("""SELECT nachname FROM personen WHERE person_id={}""".format(i)) nachnamenliste.append(c.fetchall()[0][0]) c.execute("""SELECT vorname FROM personen WHERE person_id={}""".format(i)) vornamenliste.append(c.fetchall()[0][0]) c.execute("""SELECT geburtsdatum FROM personen WHERE person_id={}""".format(i)) geburtsdatenliste.append(c.fetchall()[0][0]) #Neugestaltung mit gesuchten Werten self.scrollmatrix = [] for index,item in enumerate(vornamenliste): self.scrollmatrix.append([nachnamenliste[index],item, geburtsdatenliste[index],idliste[index]]) self.vbox.removeWidget(self.scroll) self.scroll.close() #Hier kommt die Personenanzeige self.scroll = QScrollArea() self.personenanzeige = QWidget() self.scroll.setWidgetResizable(True) #Hier kommen die Personen self.personenanzeigenLayout = QVBoxLayout(self.personenanzeige) for person in self.scrollmatrix: self.personenanzeigenLayout.addLayout(Row(person)) self.personenanzeigenLayout.addStretch(1) self.personenanzeige.setLayout(self.personenanzeigenLayout) self.scroll.setWidget(self.personenanzeige) self.vbox.addWidget(self.scroll) self.vbox.update() else: self.vbox.removeWidget(self.scroll) self.scroll.close() noresults = QWidget() noresultslayout=QVBoxLayout() noresultslabel=QLabel("""Zu diesem Suchbegriff wurden leider keine Ergebnisse gefunden\n Versuchen Sie es mit einem anderen Suchbegriff oder fügen Sie die gesuchte Person hinzu""") noresultslabel.setAlignment(Qt.AlignCenter) noresultslayout.addWidget(noresultslabel) noresults.setLayout(noresultslayout) self.scroll = QScrollArea() self.scroll.setWidget(noresults) self.vbox.addWidget(self.scroll) self.vbox.update() self.suchen.removeWidget(self.AddButton) #self.suchen.removeWidget(self.clearButton) if not self.suche: self.breaksearchButton=QPushButton("Suche abbrechen") self.breaksearchButton.clicked.connect(self.breaksearch) self.suchen.addWidget(self.breaksearchButton) self.suche=True #self.suchen.addWidget(self.clearButton) self.suchen.addWidget(self.AddButton) self.suchen.update() def breaksearch(self): self.suchen.removeWidget(self.breaksearchButton) self.suche=False self.breaksearchButton.close() self.Input.setText("") self.suchen.update() self.updatedata() def clear(self): c.execute("DROP TABLE IF EXISTS personen") c.execute("""CREATE TABLE IF NOT EXISTS personen ( person_id INT(10) NOT NULL AUTO_INCREMENT, nachname VARCHAR(50) default null, vorname VARCHAR(50) not null, geburtsdatum date default null, primary key (person_id))""") c.execute("DROP TABLE IF EXISTS gebete") c.execute("""CREATE TABLE IF NOT EXISTS gebete ( gebets_id INT(10) NOT NULL AUTO_INCREMENT, person_id INT(10) NOT NULL, gebetsart VARCHAR(5) NOT NULL, anliegen VARCHAR(1000) NOT NULL, PRIMARY KEY (gebets_id) )""") c.execute("DROP TABLE IF EXISTS oldidlist") c.execute("""CREATE TABLE IF NOT EXISTS oldidlist ( ID INTEGER NOT NULL )""") conn.commit() self.updatedata() def updatedata(self): c.execute("SELECT nachname FROM personen") nachnamenlistealsstring=c.fetchall() c.execute("SELECT vorname FROM personen") vornamenlistealsstring=c.fetchall() c.execute("SELECT geburtsdatum FROM personen") geburtsdatenlistealsstring=c.fetchall() c.execute("SELECT person_id FROM personen") idlistealsstring=c.fetchall() nachnamenliste = self.string2list(nachnamenlistealsstring) vornamenliste = self.string2list(vornamenlistealsstring) geburtsdatenliste = self.string2list(geburtsdatenlistealsstring) idliste = self.string2list(idlistealsstring) self.scrollmatrix = [] for index,item in enumerate(vornamenliste): self.scrollmatrix.append([nachnamenliste[index],item, geburtsdatenliste[index],idliste[index]]) self.vbox.removeWidget(self.scroll) self.scroll.close() #Hier kommt die Personenanzeige self.scroll = QScrollArea() self.personenanzeige = QWidget() self.scroll.setWidgetResizable(True) #Hier kommen die Personen self.personenanzeigenLayout = QVBoxLayout(self.personenanzeige) for person in self.scrollmatrix: self.personenanzeigenLayout.addLayout(Row(person)) self.personenanzeigenLayout.addStretch(1) self.personenanzeige.setLayout(self.personenanzeigenLayout) self.scroll.setWidget(self.personenanzeige) self.vbox.addWidget(self.scroll) self.vbox.update() def addPerson(self): self.f = addPersonDialog(self)