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)
