class Ventanaprincipal(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.initGui()
def initGui(self):
self.setWindowTitle('Eliminacion de producto por ID')
self.setFixedSize(400, 400)
self.lbl_producto = QLabel('Producto:', self)
self.lbl_producto.move(60, 120)
self.txt_producto = QLineEdit(self)
self.txt_producto.move(140, 120)
self.txt_producto.setFixedWidth(200)
self.txt_producto.setValidator(QIntValidator())
self.btn_eliminar = QPushButton('Eliminar', self)
self.btn_eliminar.move(140, 170)
self.btn_eliminar.setFixedWidth(200)
self.btn_eliminar.clicked.connect(self.eliminar)
self.lbl_resultado = QLabel('Resultado:', self)
self.lbl_resultado.move(25, 250)
self.lbl_resultado = QLabel(self)
self.lbl_resultado.move(25, 270)
self.lbl_resultado.setFixedWidth(350)
#self.txt_resultado.setEnabled(False)
def eliminar(self):
confirmacion = QMessageBox(self)
confirmacion.setText(
f'Desea Eliminar el Producto con ID {self.txt_producto.text()}?')
confirmacion.setIcon(QMessageBox.Icon.Question)
confirmacion.setDetailedText(
'El producto se eliminará definitivamente...')
confirmacion.setWindowTitle('Confirmación...')
confirmacion.setStandardButtons(QMessageBox.StandardButton.Yes
| QMessageBox.StandardButton.No)
boton_yes = confirmacion.button(QMessageBox.StandardButton.Yes)
confirmacion.exec()
if confirmacion.clickedButton() == boton_yes:
self.lbl_resultado.setText(
f'Se ha eliminado el producto con ID {self.txt_producto.text()}.'
)
else:
self.lbl_resultado.setText(
f'No se ha eliminado el producto con ID {self.txt_producto.text()}.'
)
class Ventana_Calculadora(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.initUi()
def initUi(self):
self.setWindowTitle('Calculadora Suma')
self.setFixedSize(300, 400)
self.lbl_numero_1 = QLabel('Número 1: ', self)
self.lbl_numero_1.move(50, 50)
self.lbl_numero_2 = QLabel('Número 2: ', self)
self.lbl_numero_2.move(50, 100)
self.txt_numero_1 = QLineEdit(self)
self.txt_numero_1.setFixedWidth(100)
self.txt_numero_1.move(150, 50)
self.txt_numero_1.setValidator(QIntValidator())
self.txt_numero_2 = QLineEdit(self)
self.txt_numero_2.setFixedWidth(100)
self.txt_numero_2.move(150, 100)
self.txt_numero_2.setValidator(QIntValidator())
self.btn_sumar = QPushButton('Sumar', self)
self.btn_sumar.setFixedWidth(100)
self.btn_sumar.move(100, 170)
self.btn_sumar.clicked.connect(self.sumar) # Evento Click
self.lbl_resultado = QLabel('Resultado: ', self)
self.lbl_resultado.move(50, 250)
self.lbl_resultado = QLabel(self)
self.lbl_resultado.setFixedWidth(100)
self.lbl_resultado.move(150, 250)
#self.lbl_resultado.setEnabled(False)
def sumar(self):
numero_1 = int(self.txt_numero_1.text())
numero_2 = int(self.txt_numero_2.text())
suma = numero_1 + numero_2
self.lbl_resultado.setText(str(suma))
class VentanaPrincipal(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.initUi()
def initUi(self):
self.setWindowTitle('Demo QPushButton')
self.setFixedSize(400, 400)
self.btn_mostrar_mensaje = QPushButton('Mostrar mensaje', self)
self.btn_mostrar_mensaje.setFixedWidth(150)
self.btn_mostrar_mensaje.move(125, 150)
self.btn_mostrar_mensaje.clicked.connect(self.mostrar_mensaje)
def mostrar_mensaje(self):
print('\nEl usuario ha presionado el boton para mostrar mensaje...\n')
def gui_init(self):
logger.debug('GUI initialization')
self.setWindowTitle(f'{APP_NAME} {APP_VERSION}')
self.setWindowIcon(QIcon('media/icon.png'))
for x in range(SIZE):
row = []
for y in range(SIZE):
btn = QPushButton(text=f'')
btn.setFixedWidth(BUTTON_WIDTH)
btn.setFixedHeight(BUTTON_HEIGHT)
btn.setAccessibleName(f'{x}/{y}')
btn.setStyleSheet(REGULAR)
btn.clicked.connect(self.on_click)
row.append(btn)
self.layout.addWidget(btn, x, y)
self.field.append(row)
self.setLayout(self.layout)
logger.debug('GUI initialized')
class VentanaPrincipal(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.initUi()
def initUi(self):
self.setWindowTitle('Demo QMessageBox')
self.setFixedSize(400, 400)
self.btn_mostrar_mensaje = QPushButton('Mostrar mensaje', self)
self.btn_mostrar_mensaje.move(125, 150)
self.btn_mostrar_mensaje.setFixedWidth(150)
self.btn_mostrar_mensaje.clicked.connect(self.mostrar_mensaje)
def mostrar_mensaje(self):
mensaje = QMessageBox()
mensaje.setIcon(QMessageBox.Icon.Information) #Information, NoIcon, Question,Warning, Critical
mensaje.setText('Ha hecho Click sobre el botón!!!')
mensaje.setDetailedText('Hola..')
mensaje.setWindowTitle('sdf')
mensaje.exec()
class VentanaPrincipal(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.initUi()
def initUi(self):
self.setWindowTitle('Demo Ventana de Saludo!!!')
self.setFixedSize(400, 400)
self.lbl_nombre = QLabel('Nombre: ', self)
self.lbl_nombre.move(75, 50)
self.txt_nombre = QLineEdit(self)
self.txt_nombre.setFixedWidth(250)
self.txt_nombre.move(75, 80)
self.btn_saludar = QPushButton('Saludar', self)
self.btn_saludar.setFixedWidth(250)
self.btn_saludar.move(75, 120)
self.btn_saludar.clicked.connect(self.mostrar_saludo)
def mostrar_saludo(self):
nombre = self.txt_nombre.text().strip()
mensaje = QMessageBox()
mensaje.setWindowTitle('Bienvenido!!!')
if len(nombre):
mensaje.setText(f'Hola, {nombre}!!!')
mensaje.setIcon(QMessageBox.Icon.Information)
else:
mensaje.setText(f'No ha ingresado un nombre aún...')
mensaje.setIcon(QMessageBox.Icon.Warning)
mensaje.exec()
class Captura_Datos(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.initGui()
def initGui(self):
self.setWindowTitle('Aplicación Captura de Datos')
self.setFixedSize(400, 400)
#self.showFullScreen()
# Botones
self.btn_nombre = QPushButton('Nombre Completo', self)
self.btn_nombre.setFixedWidth(200)
self.btn_nombre.move(100, 30)
self.btn_nombre.clicked.connect(self.capturar_nombre)
self.btn_edad = QPushButton('Edad', self)
self.btn_edad.setFixedWidth(200)
self.btn_edad.move(100, 60)
self.btn_nombre.clicked.connect(self.capturar_edad)
self.btn_ahorros = QPushButton('Ahorros', self)
self.btn_ahorros.setFixedWidth(200)
self.btn_ahorros.move(100, 90)
self.btn_nombre.clicked.connect(self.capturar_ahorros)
self.btn_color = QPushButton('Color', self)
self.btn_color.setFixedWidth(200)
self.btn_color.move(100, 120)
self.btn_nombre.clicked.connect(self.capturar_color)
# Resultado
self.lbl_resultado = QLabel('Información personal:', self)
self.lbl_resultado.move(100, 180)
self.lbl_resultado.setFixedWidth(200)
# Etiquetas de datos
self.lbl_nombre = QLabel('Nombre Completo:', self)
self.lbl_nombre.move(50, 240)
self.lbl_nombre.setFixedWidth(200)
self.lbl_nombre = QLabel('Edad:', self)
self.lbl_nombre.move(50, 270)
self.lbl_nombre.setFixedWidth(200)
self.lbl_nombre = QLabel('Ahorros:', self)
self.lbl_nombre.move(50, 300)
self.lbl_nombre.setFixedWidth(200)
self.lbl_nombre = QLabel('Color:', self)
self.lbl_nombre.move(50, 330)
self.lbl_nombre.setFixedWidth(200)
# Etiquetas de resultados
self.lbl_nombre_result = QLabel(self)
self.lbl_nombre_result.move(200, 240)
self.lbl_nombre_result.setFixedWidth(200)
self.lbl_edad_result = QLabel(self)
self.lbl_edad_result.move(200, 270)
self.lbl_edad_result.setFixedWidth(200)
self.lbl_ahorros_result = QLabel(self)
self.lbl_ahorros_result.move(200, 300)
self.lbl_ahorros_result.setFixedWidth(200)
self.lbl_color_result = QLabel(self)
self.lbl_color_result.move(200, 330)
self.lbl_color_result.setFixedWidth(200)
# Menu
self.menu_principal = self.menuBar()
self.menu_archivo = self.menu_principal.addMenu('Archivo')
self.menu_operaciones = self.menu_principal.addMenu('Operaciones')
self.menu_ayuda = self.menu_principal.addMenu('Ayuda')
# Archivo
self.menu_item_salir = QAction('Salir', self)
self.menu_item_salir.setShortcut('⌘D')
self.menu_item_salir.triggered.connect(self.close)
self.menu_archivo.addAction(self.menu_item_salir)
# Operaciones
self.menu_item_operaciones = QAction('Operaciones', self)
self.menu_operaciones.addAction(self.menu_item_operaciones)
# Ayuda
self.menu_acerca_de = QAction('Acerca de Aplicación Captura de Datos.',
self)
self.menu_ayuda.addAction(self.menu_acerca_de)
self.menu_ayuda.triggered.connect(self.mostrar_acerca_de)
def mostrar_acerca_de(self):
mensaje = QMessageBox()
mensaje.setIcon(QMessageBox.Icon.Information)
mensaje.setText(
'A cerca de Aplicación captura de datos.\n\nAplicacion PyQt6.\nDesarrollador: Mauricio Posada.\nVersión: 1.0.0\n2021.'
)
mensaje.exec()
def capturar_nombre(self):
nombre, ok = QInputDialog.getText(self, 'Captura de datos.',
'Escribe tu nombre completo:')
if ok:
nombre = nombre.strip()
if len(nombre):
self.lbl_nombre_result.setText(nombre)
def capturar_edad(self):
edad, ok = QInputDialog.getInt(self, 'Captura de datos.',
'Escribe tu edad:', 10, 1, 80)
if ok:
self.lbl_edad_result.setText(str(edad))
def capturar_ahorros(self):
ahorros, ok = QInputDialog.getDouble(
self, 'Captura de datos.', 'Escribe tu cantidad de ahorros:', 0,
1000, 1000000) # Minimo, incremento, Maximo
if ok:
self.lbl_ahorros_result.setText(str(ahorros))
def capturar_color(self):
colores = [
'Amarillo', 'Azul', 'Blanco', 'Rojo', 'Verde', 'Negro', 'Morado'
]
color, ok = QInputDialog.getItem(
self, 'Captura de datos.', 'Selecciona un color.', colores, 0,
False
) # 0 inicia desde el color[0], False no permite editar la lista de colores
if ok:
self.lbl_color_result.setText(color)
class MainWindow(QMainWindow):
################################
# signals (aset ui --> aset api)
################################
create_document_base = pyqtSignal(str, list)
add_attribute = pyqtSignal(str, ASETDocumentBase)
remove_attribute = pyqtSignal(str, ASETDocumentBase)
forget_matches_for_attribute = pyqtSignal(str, ASETDocumentBase)
load_document_base_from_bson = pyqtSignal(str)
save_document_base_to_bson = pyqtSignal(str, ASETDocumentBase)
save_table_to_csv = pyqtSignal(str, ASETDocumentBase)
forget_matches = pyqtSignal(ASETDocumentBase)
load_preprocessing_phase_from_config = pyqtSignal(str)
save_preprocessing_phase_to_config = pyqtSignal(str, PreprocessingPhase)
load_matching_phase_from_config = pyqtSignal(str)
save_matching_phase_to_config = pyqtSignal(str, BaseMatchingPhase)
run_preprocessing_phase = pyqtSignal(ASETDocumentBase, PreprocessingPhase, Statistics)
run_matching_phase = pyqtSignal(ASETDocumentBase, BaseMatchingPhase, Statistics)
save_statistics_to_json = pyqtSignal(str, Statistics)
load_and_run_default_preprocessing_phase = pyqtSignal(ASETDocumentBase, Statistics)
load_and_run_default_matching_phase = pyqtSignal(ASETDocumentBase, Statistics)
##############################
# slots (aset api --> aset ui)
##############################
@pyqtSlot(str, float)
def status(self, message, progress):
logger.debug("Called slot 'status'.")
self.status_widget_message.setText(message)
if progress == -1:
self.status_widget_progress.setRange(0, 0)
else:
self.status_widget_progress.setRange(0, 100)
self.status_widget_progress.setValue(int(progress * 100))
@pyqtSlot(str)
def finished(self, message):
logger.debug("Called slot 'finished'.")
self.status_widget_message.setText(message)
self.status_widget_progress.setRange(0, 100)
self.status_widget_progress.setValue(100)
self.show_document_base_viewer_widget()
self.enable_global_input()
@pyqtSlot(str)
def error(self, message):
logger.debug("Called slot 'error'.")
self.status_widget_message.setText(message)
self.status_widget_progress.setRange(0, 100)
self.status_widget_progress.setValue(0)
self.show_document_base_viewer_widget()
self.enable_global_input()
@pyqtSlot(ASETDocumentBase)
def document_base_to_ui(self, document_base):
logger.debug("Called slot 'document_base_to_ui'.")
self.document_base = document_base
self.document_base_viewer_widget.update_document_base(self.document_base)
self._was_enabled.append(self.save_document_base_to_bson_action)
self._was_enabled.append(self.save_table_to_csv_action)
self._was_enabled.append(self.add_attribute_action)
self._was_enabled.append(self.remove_attribute_action)
self._was_enabled.append(self.forget_matches_for_attribute_action)
self._was_enabled.append(self.forget_matches_action)
self._was_enabled.append(self.load_and_run_default_preprocessing_phase_action)
self._was_enabled.append(self.load_and_run_default_matching_phase_action)
if self.preprocessing_phase is not None:
self._was_enabled.append(self.run_preprocessing_phase_action)
if self.matching_phase is not None:
self._was_enabled.append(self.run_matching_phase_action)
@pyqtSlot(PreprocessingPhase)
def preprocessing_phase_to_ui(self, preprocessing_phase):
logger.debug("Called slot 'preprocessing_phase_to_ui'.")
self.preprocessing_phase = preprocessing_phase
self._was_enabled.append(self.save_preprocessing_phase_to_config_action)
if self.document_base is not None:
self._was_enabled.append(self.run_preprocessing_phase_action)
@pyqtSlot(BaseMatchingPhase)
def matching_phase_to_ui(self, matching_phase):
logger.debug("Called slot 'matching_phase_to_ui'.")
self.matching_phase = matching_phase
self._was_enabled.append(self.save_matching_phase_to_config_action)
if self.document_base is not None:
self._was_enabled.append(self.run_preprocessing_phase_action)
@pyqtSlot(Statistics)
def statistics_to_ui(self, statistics):
logger.debug("Called slot 'statistics_to_ui'.")
self.statistics = statistics
@pyqtSlot(dict)
def feedback_request_to_ui(self, feedback_request):
logger.debug("Called slot 'feedback_request_to_ui'.")
self.interactive_matching_widget.handle_feedback_request(feedback_request)
# noinspection PyUnresolvedReferences
def _connect_slots_and_signals(self):
self.create_document_base.connect(self.api.create_document_base)
self.add_attribute.connect(self.api.add_attribute)
self.remove_attribute.connect(self.api.remove_attribute)
self.forget_matches_for_attribute.connect(self.api.forget_matches_for_attribute)
self.load_document_base_from_bson.connect(self.api.load_document_base_from_bson)
self.save_document_base_to_bson.connect(self.api.save_document_base_to_bson)
self.save_table_to_csv.connect(self.api.save_table_to_csv)
self.forget_matches.connect(self.api.forget_matches)
self.load_preprocessing_phase_from_config.connect(self.api.load_preprocessing_phase_from_config)
self.save_preprocessing_phase_to_config.connect(self.api.save_preprocessing_phase_to_config)
self.load_matching_phase_from_config.connect(self.api.load_matching_phase_from_config)
self.save_matching_phase_to_config.connect(self.api.save_matching_phase_to_config)
self.run_preprocessing_phase.connect(self.api.run_preprocessing_phase)
self.run_matching_phase.connect(self.api.run_matching_phase)
self.save_statistics_to_json.connect(self.api.save_statistics_to_json)
self.load_and_run_default_preprocessing_phase.connect(self.api.load_and_run_default_preprocessing_phase)
self.load_and_run_default_matching_phase.connect(self.api.load_and_run_default_matching_phase)
self.api.status.connect(self.status)
self.api.finished.connect(self.finished)
self.api.error.connect(self.error)
self.api.document_base_to_ui.connect(self.document_base_to_ui)
self.api.preprocessing_phase_to_ui.connect(self.preprocessing_phase_to_ui)
self.api.matching_phase_to_ui.connect(self.matching_phase_to_ui)
self.api.statistics_to_ui.connect(self.statistics_to_ui)
self.api.feedback_request_to_ui.connect(self.feedback_request_to_ui)
#######
# tasks
#######
def load_document_base_from_bson_task(self):
logger.info("Execute task 'load_document_base_from_bson_task'.")
path, ok = QFileDialog.getOpenFileName(self, "Choose a document collection .bson file!")
if ok:
self.disable_global_input()
# noinspection PyUnresolvedReferences
self.load_document_base_from_bson.emit(str(path))
def save_document_base_to_bson_task(self):
logger.info("Execute task 'save_document_base_to_bson_task'.")
if self.document_base is not None:
path, ok = QFileDialog.getSaveFileName(self, "Choose where to save the document collection .bson file!")
if ok:
self.disable_global_input()
# noinspection PyUnresolvedReferences
self.save_document_base_to_bson.emit(str(path), self.document_base)
def add_attribute_task(self):
logger.info("Execute task 'add_attribute_task'.")
if self.document_base is not None:
name, ok = QInputDialog.getText(self, "Create Attribute", "Attribute name:")
if ok:
self.disable_global_input()
# noinspection PyUnresolvedReferences
self.add_attribute.emit(str(name), self.document_base)
def remove_attribute_task(self):
logger.info("Execute task 'remove_attribute_task'.")
if self.document_base is not None:
name, ok = QInputDialog.getText(self, "Remove Attribute", "Attribute name:")
if ok:
self.disable_global_input()
# noinspection PyUnresolvedReferences
self.remove_attribute.emit(str(name), self.document_base)
def remove_attribute_with_given_name_task(self, attribute_name):
logger.info("Execute task 'remove_attribute_with_given_name_task'.")
if self.document_base is not None:
self.disable_global_input()
# noinspection PyUnresolvedReferences
self.remove_attribute.emit(str(attribute_name), self.document_base)
def forget_matches_for_attribute_task(self):
logger.info("Execute task 'forget_matches_for_attribute_task'.")
if self.document_base is not None:
name, ok = QInputDialog.getText(self, "Forget Matches for Attribute", "Attribute name:")
if ok:
self.disable_global_input()
# noinspection PyUnresolvedReferences
self.forget_matches_for_attribute.emit(str(name), self.document_base)
def forget_matches_for_attribute_with_given_name_task(self, attribute_name):
logger.info("Execute task 'forget_matches_for_attribute_with_given_name_task'.")
if self.document_base is not None:
self.disable_global_input()
# noinspection PyUnresolvedReferences
self.forget_matches_for_attribute.emit(attribute_name, self.document_base)
def forget_matches_task(self):
logger.info("Execute task 'forget_matches_task'.")
if self.document_base is not None:
self.disable_global_input()
# noinspection PyUnresolvedReferences
self.forget_matches.emit(self.document_base)
def enable_collect_statistics_task(self):
logger.info("Execute task 'task_enable_collect_statistics'.")
self.collect_statistics = True
self.enable_collect_statistics_action.setEnabled(False)
self.disable_collect_statistics_action.setEnabled(True)
def disable_collect_statistics_task(self):
logger.info("Execute task 'disable_collect_statistics_task'.")
self.collect_statistics = False
self.disable_collect_statistics_action.setEnabled(False)
self.enable_collect_statistics_action.setEnabled(True)
def save_statistics_to_json_task(self):
logger.info("Execute task 'save_statistics_to_json_task'.")
if self.statistics is not None:
path = str(QFileDialog.getSaveFileName(self, "Choose where to save the statistics .json file!")[0])
if path != "":
self.disable_global_input()
# noinspection PyUnresolvedReferences
self.save_statistics_to_json.emit(path, self.statistics)
def show_document_base_creator_widget_task(self):
logger.info("Execute task 'show_document_base_creator_widget_task'.")
self.disable_global_input()
self.document_base_creator_widget.enable_input()
self.document_base_creator_widget.initialize_for_new_document_base()
self.show_document_base_creator_widget()
self.document_base_creator_widget.path.setFocus()
def create_document_base_task(self, path, attribute_names):
logger.info("Execute task 'create_document_base_task'.")
self.disable_global_input()
# noinspection PyUnresolvedReferences
self.create_document_base.emit(path, attribute_names)
def save_table_to_csv_task(self):
logger.info("Execute task 'save_table_to_csv_task'.")
if self.document_base is not None:
path = str(QFileDialog.getSaveFileName(self, "Choose where to save the table .csv file!")[0])
if path != "":
self.disable_global_input()
# noinspection PyUnresolvedReferences
self.save_table_to_csv.emit(path, self.document_base)
def load_preprocessing_phase_from_config_task(self):
logger.info("Execute task 'load_preprocessing_phase_from_config_task'.")
path = str(QFileDialog.getOpenFileName(self, "Choose a configuration .json file!")[0])
if path != "":
self.disable_global_input()
# noinspection PyUnresolvedReferences
self.load_preprocessing_phase_from_config.emit(path)
def save_preprocessing_phase_to_config_task(self):
logger.info("Execute task 'save_preprocessing_phase_to_config_task'.")
if self.preprocessing_phase is not None:
path = str(QFileDialog.getSaveFileName(self, "Choose where to save the configuration .json file!")[0])
if path != "":
self.disable_global_input()
# noinspection PyUnresolvedReferences
self.save_preprocessing_phase_to_config.emit(path, self.preprocessing_phase)
def load_matching_phase_from_config_task(self):
logger.info("Execute task 'load_matching_phase_from_config_task'.")
path = str(QFileDialog.getOpenFileName(self, "Choose a configuration .json file!")[0])
if path != "":
self.disable_global_input()
# noinspection PyUnresolvedReferences
self.load_matching_phase_from_config.emit(path)
def save_matching_phase_to_config_task(self):
logger.info("Execute task 'save_matching_phase_to_config_task'.")
if self.matching_phase is not None:
path = str(QFileDialog.getSaveFileName(self, "Choose where to save the configuration .json file!")[0])
if path != "":
self.disable_global_input()
# noinspection PyUnresolvedReferences
self.save_matching_phase_to_config.emit(path, self.matching_phase)
def run_preprocessing_phase_task(self):
logger.info("Execute task 'run_preprocessing_phase_task'.")
if self.document_base is not None and self.preprocessing_phase is not None:
self.statistics = Statistics(self.collect_statistics)
self.save_statistics_to_json_action.setEnabled(self.collect_statistics)
self.disable_global_input()
# noinspection PyUnresolvedReferences
self.run_preprocessing_phase.emit(self.document_base, self.preprocessing_phase, self.statistics)
def run_matching_phase_task(self):
logger.info("Execute task 'run_matching_phase_task'.")
if self.document_base is not None and self.matching_phase is not None:
self.statistics = Statistics(self.collect_statistics)
self.save_statistics_to_json_action.setEnabled(self.collect_statistics)
self.disable_global_input()
self.interactive_matching_widget.enable_input()
self.show_interactive_matching_widget()
# noinspection PyUnresolvedReferences
self.run_matching_phase.emit(self.document_base, self.matching_phase, self.statistics)
def give_feedback_task(self, feedback):
logger.info("Execute task 'give_feedback_task'.")
self.api.feedback = feedback
self.feedback_cond.wakeAll()
def load_and_run_default_preprocessing_phase_task(self):
logger.info("Execute task 'load_and_run_default_preprocessing_phase_task'.")
if self.document_base is not None:
self.statistics = Statistics(self.collect_statistics)
self.save_statistics_to_json_action.setEnabled(self.collect_statistics)
self.disable_global_input()
# noinspection PyUnresolvedReferences
self.load_and_run_default_preprocessing_phase.emit(self.document_base, self.statistics)
def load_and_run_default_matching_phase_task(self):
logger.info("Execute task 'load_and_run_default_matching_phase_task'.")
if self.document_base is not None:
self.statistics = Statistics(self.collect_statistics)
self.save_statistics_to_json_action.setEnabled(self.collect_statistics)
self.disable_global_input()
self.interactive_matching_widget.enable_input()
self.show_interactive_matching_widget()
# noinspection PyUnresolvedReferences
self.load_and_run_default_matching_phase.emit(self.document_base, self.statistics)
##################
# controller logic
##################
def enable_global_input(self):
for action in self._was_enabled:
action.setEnabled(True)
self.document_base_creator_widget.enable_input()
self.document_base_viewer_widget.enable_input()
self.interactive_matching_widget.enable_input()
self._was_enabled = []
def disable_global_input(self):
for action in self._all_actions:
if action.isEnabled():
self._was_enabled.append(action)
action.setEnabled(False)
self.document_base_creator_widget.disable_input()
self.document_base_viewer_widget.disable_input()
self.interactive_matching_widget.disable_input()
def show_document_base_viewer_widget(self):
if self.document_base_viewer_widget.isHidden():
self.central_widget_layout.setAlignment(Qt.AlignmentFlag.AlignLeft)
self.start_menu_widget.hide()
self.interactive_matching_widget.hide()
self.document_base_creator_widget.hide()
self.central_widget_layout.removeWidget(self.start_menu_widget)
self.central_widget_layout.removeWidget(self.interactive_matching_widget)
self.central_widget_layout.removeWidget(self.document_base_creator_widget)
self.central_widget_layout.addWidget(self.document_base_viewer_widget)
self.document_base_viewer_widget.show()
self.central_widget_layout.update()
def show_interactive_matching_widget(self):
if self.interactive_matching_widget.isHidden():
self.central_widget_layout.setAlignment(Qt.AlignmentFlag.AlignLeft)
self.start_menu_widget.hide()
self.document_base_viewer_widget.hide()
self.document_base_creator_widget.hide()
self.central_widget_layout.removeWidget(self.start_menu_widget)
self.central_widget_layout.removeWidget(self.document_base_viewer_widget)
self.central_widget_layout.removeWidget(self.document_base_creator_widget)
self.central_widget_layout.addWidget(self.interactive_matching_widget)
self.interactive_matching_widget.show()
self.central_widget_layout.update()
def show_document_base_creator_widget(self):
if self.document_base_creator_widget.isHidden():
self.central_widget_layout.setAlignment(Qt.AlignmentFlag.AlignLeft)
self.start_menu_widget.hide()
self.document_base_viewer_widget.hide()
self.interactive_matching_widget.hide()
self.central_widget_layout.removeWidget(self.start_menu_widget)
self.central_widget_layout.removeWidget(self.document_base_viewer_widget)
self.central_widget_layout.removeWidget(self.interactive_matching_widget)
self.central_widget_layout.addWidget(self.document_base_creator_widget)
self.document_base_creator_widget.show()
self.central_widget_layout.update()
def show_start_menu_widget(self):
if self.start_menu_widget.isHidden():
self.central_widget_layout.setAlignment(Qt.AlignmentFlag.AlignCenter)
self.document_base_viewer_widget.hide()
self.document_base_creator_widget.hide()
self.interactive_matching_widget.hide()
self.central_widget_layout.removeWidget(self.document_base_viewer_widget)
self.central_widget_layout.removeWidget(self.document_base_creator_widget)
self.central_widget_layout.removeWidget(self.interactive_matching_widget)
self.central_widget_layout.addWidget(self.start_menu_widget)
self.start_menu_widget.show()
self.central_widget_layout.update()
def __init__(self) -> None:
super(MainWindow, self).__init__()
self.setWindowTitle("ASET")
self.document_base = None
self.preprocessing_phase = None
self.matching_phase = None
self.statistics = Statistics(True)
self.collect_statistics = True
# set up the api_thread and api and connect slots and signals
self.feedback_mutex = QMutex()
self.feedback_cond = QWaitCondition()
self.api = ASETAPI(self.feedback_mutex, self.feedback_cond)
self.api_thread = QThread()
self.api.moveToThread(self.api_thread)
self._connect_slots_and_signals()
self.api_thread.start()
# set up the status bar
self.status_bar = self.statusBar()
self.status_bar.setFont(STATUS_BAR_FONT)
self.status_widget = QWidget(self.status_bar)
self.status_widget_layout = QHBoxLayout(self.status_widget)
self.status_widget_layout.setContentsMargins(0, 0, 0, 0)
self.status_widget_message = QLabel()
self.status_widget_message.setFont(STATUS_BAR_FONT)
self.status_widget_message.setMinimumWidth(10)
self.status_widget_layout.addWidget(self.status_widget_message)
self.status_widget_progress = QProgressBar()
self.status_widget_progress.setMinimumWidth(10)
self.status_widget_progress.setMaximumWidth(200)
self.status_widget_progress.setTextVisible(False)
self.status_widget_progress.setMaximumHeight(20)
self.status_widget_layout.addWidget(self.status_widget_progress)
self.status_bar.addPermanentWidget(self.status_widget)
# set up the actions
self._all_actions = []
self._was_enabled = []
self.exit_action = QAction("&Exit", self)
self.exit_action.setIcon(QIcon("aset_ui/resources/leave.svg"))
self.exit_action.setStatusTip("Exit the application.")
self.exit_action.triggered.connect(QApplication.instance().quit)
self._all_actions.append(self.exit_action)
self.show_document_base_creator_widget_action = QAction("&Create new document base", self)
self.show_document_base_creator_widget_action.setIcon(QIcon("aset_ui/resources/two_documents.svg"))
self.show_document_base_creator_widget_action.setStatusTip(
"Create a new document base from a collection of .txt files and a list of attribute names."
)
self.show_document_base_creator_widget_action.triggered.connect(self.show_document_base_creator_widget_task)
self._all_actions.append(self.show_document_base_creator_widget_action)
self.add_attribute_action = QAction("&Add attribute", self)
self.add_attribute_action.setIcon(QIcon("aset_ui/resources/plus.svg"))
self.add_attribute_action.setStatusTip("Add a new attribute to the document base.")
self.add_attribute_action.triggered.connect(self.add_attribute_task)
self.add_attribute_action.setEnabled(False)
self._all_actions.append(self.add_attribute_action)
self.remove_attribute_action = QAction("&Remove attribute", self)
self.remove_attribute_action.setIcon(QIcon("aset_ui/resources/trash.svg"))
self.remove_attribute_action.setStatusTip("Remove an attribute from the document base.")
self.remove_attribute_action.triggered.connect(self.remove_attribute_task)
self.remove_attribute_action.setEnabled(False)
self._all_actions.append(self.remove_attribute_action)
self.forget_matches_for_attribute_action = QAction("&Forget matches for attribute", self)
self.forget_matches_for_attribute_action.setIcon(QIcon("aset_ui/resources/redo.svg"))
self.forget_matches_for_attribute_action.setStatusTip("Forget the matches for a single attribute.")
self.forget_matches_for_attribute_action.triggered.connect(self.forget_matches_for_attribute_task)
self.forget_matches_for_attribute_action.setEnabled(False)
self._all_actions.append(self.forget_matches_for_attribute_action)
self.load_document_base_from_bson_action = QAction("&Load document base", self)
self.load_document_base_from_bson_action.setIcon(QIcon("aset_ui/resources/folder.svg"))
self.load_document_base_from_bson_action.setStatusTip("Load an existing document base from a .bson file.")
self.load_document_base_from_bson_action.triggered.connect(self.load_document_base_from_bson_task)
self._all_actions.append(self.load_document_base_from_bson_action)
self.save_document_base_to_bson_action = QAction("&Save document base", self)
self.save_document_base_to_bson_action.setIcon(QIcon("aset_ui/resources/save.svg"))
self.save_document_base_to_bson_action.setStatusTip("Save the document base in a .bson file.")
self.save_document_base_to_bson_action.triggered.connect(self.save_document_base_to_bson_task)
self.save_document_base_to_bson_action.setEnabled(False)
self._all_actions.append(self.save_document_base_to_bson_action)
self.save_table_to_csv_action = QAction("&Export table to CSV", self)
self.save_table_to_csv_action.setIcon(QIcon("aset_ui/resources/table.svg"))
self.save_table_to_csv_action.setStatusTip("Save the table to a .csv file.")
self.save_table_to_csv_action.triggered.connect(self.save_table_to_csv_task)
self.save_table_to_csv_action.setEnabled(False)
self._all_actions.append(self.save_table_to_csv_action)
self.forget_matches_action = QAction("&Forget all matches", self)
self.forget_matches_action.setIcon(QIcon("aset_ui/resources/redo.svg"))
self.forget_matches_action.setStatusTip("Forget the matches for all attributes.")
self.forget_matches_action.triggered.connect(self.forget_matches_task)
self.forget_matches_action.setEnabled(False)
self._all_actions.append(self.forget_matches_action)
self.load_and_run_default_preprocessing_phase_action = QAction(
"&Load and run default preprocessing phase", self
)
self.load_and_run_default_preprocessing_phase_action.setStatusTip(
"Load the default preprocessing phase and run it on the document collection."
)
self.load_and_run_default_preprocessing_phase_action.setIcon(QIcon("aset_ui/resources/run_run.svg"))
self.load_and_run_default_preprocessing_phase_action.setDisabled(True)
self.load_and_run_default_preprocessing_phase_action.triggered.connect(
self.load_and_run_default_preprocessing_phase_task
)
self._all_actions.append(self.load_and_run_default_preprocessing_phase_action)
self.load_preprocessing_phase_from_config_action = QAction("&Load preprocessing phase", self)
self.load_preprocessing_phase_from_config_action.setStatusTip(
"Load a preprocessing phase from a .json configuration file."
)
self.load_preprocessing_phase_from_config_action.triggered.connect(
self.load_preprocessing_phase_from_config_task
)
self._all_actions.append(self.load_preprocessing_phase_from_config_action)
self.save_preprocessing_phase_to_config_action = QAction("&Save preprocessing phase", self)
self.save_preprocessing_phase_to_config_action.setStatusTip(
"Save the preprocessing phase in a .json configuration file."
)
self.save_preprocessing_phase_to_config_action.triggered.connect(self.save_preprocessing_phase_to_config_task)
self.save_preprocessing_phase_to_config_action.setEnabled(False)
self._all_actions.append(self.save_preprocessing_phase_to_config_action)
self.run_preprocessing_phase_action = QAction("Run preprocessing phase", self)
self.run_preprocessing_phase_action.setIcon(QIcon("aset_ui/resources/run.svg"))
self.run_preprocessing_phase_action.setStatusTip("Run the preprocessing phase on the document collection.")
self.run_preprocessing_phase_action.triggered.connect(self.run_preprocessing_phase_task)
self.run_preprocessing_phase_action.setEnabled(False)
self._all_actions.append(self.run_preprocessing_phase_action)
self.load_and_run_default_matching_phase_action = QAction(
"&Load and run default matching phase", self
)
self.load_and_run_default_matching_phase_action.setStatusTip(
"Load the default matching phase and run it on the document collection."
)
self.load_and_run_default_matching_phase_action.setIcon(QIcon("aset_ui/resources/run_run.svg"))
self.load_and_run_default_matching_phase_action.setDisabled(True)
self.load_and_run_default_matching_phase_action.triggered.connect(
self.load_and_run_default_preprocessing_phase_task
)
self._all_actions.append(self.load_and_run_default_matching_phase_action)
self.load_matching_phase_from_config_action = QAction("&Load matching phase", self)
self.load_matching_phase_from_config_action.setStatusTip(
"Load a matching phase from a .json configuration file."
)
self.load_matching_phase_from_config_action.triggered.connect(self.load_matching_phase_from_config_task)
self._all_actions.append(self.load_matching_phase_from_config_action)
self.save_matching_phase_to_config_action = QAction("&Save matching phase", self)
self.save_matching_phase_to_config_action.setStatusTip("Save the matching phase in a .json configuration file.")
self.save_matching_phase_to_config_action.triggered.connect(self.save_matching_phase_to_config_task)
self.save_matching_phase_to_config_action.setEnabled(False)
self._all_actions.append(self.save_matching_phase_to_config_action)
self.run_matching_phase_action = QAction("Run matching phase", self)
self.run_matching_phase_action.setIcon(QIcon("aset_ui/resources/run.svg"))
self.run_matching_phase_action.setStatusTip("Run the matching phase on the document collection.")
self.run_matching_phase_action.triggered.connect(self.run_matching_phase_task)
self.run_matching_phase_action.setEnabled(False)
self._all_actions.append(self.run_matching_phase_action)
self.enable_collect_statistics_action = QAction("&Enable statistics", self)
self.enable_collect_statistics_action.setIcon(QIcon("aset_ui/resources/statistics.svg"))
self.enable_collect_statistics_action.setStatusTip("Enable collecting statistics.")
self.enable_collect_statistics_action.triggered.connect(self.enable_collect_statistics_task)
self.enable_collect_statistics_action.setEnabled(False)
self._all_actions.append(self.enable_collect_statistics_action)
self.disable_collect_statistics_action = QAction("&Disable statistics", self)
self.disable_collect_statistics_action.setIcon(QIcon("aset_ui/resources/statistics_incorrect.svg"))
self.disable_collect_statistics_action.setStatusTip("Disable collecting statistics.")
self.disable_collect_statistics_action.triggered.connect(self.disable_collect_statistics_task)
self._all_actions.append(self.disable_collect_statistics_action)
self.save_statistics_to_json_action = QAction("&Save statistics", self)
self.save_statistics_to_json_action.setIcon(QIcon("aset_ui/resources/statistics_save.svg"))
self.save_statistics_to_json_action.setStatusTip("Save the statistics to a .json file.")
self.save_statistics_to_json_action.triggered.connect(self.save_statistics_to_json_task)
self.save_statistics_to_json_action.setEnabled(False)
self._all_actions.append(self.save_statistics_to_json_action)
# set up the menu bar
self.menubar = self.menuBar()
self.menubar.setFont(MENU_FONT)
self.file_menu = self.menubar.addMenu("&File")
self.file_menu.setFont(MENU_FONT)
self.file_menu.addAction(self.exit_action)
self.document_base_menu = self.menubar.addMenu("&Document Base")
self.document_base_menu.setFont(MENU_FONT)
self.document_base_menu.addAction(self.show_document_base_creator_widget_action)
self.document_base_menu.addSeparator()
self.document_base_menu.addAction(self.load_document_base_from_bson_action)
self.document_base_menu.addAction(self.save_document_base_to_bson_action)
self.document_base_menu.addSeparator()
self.document_base_menu.addAction(self.save_table_to_csv_action)
self.document_base_menu.addSeparator()
self.document_base_menu.addAction(self.add_attribute_action)
self.document_base_menu.addAction(self.remove_attribute_action)
self.document_base_menu.addSeparator()
self.document_base_menu.addAction(self.forget_matches_for_attribute_action)
self.document_base_menu.addAction(self.forget_matches_action)
self.preprocessing_menu = self.menubar.addMenu("&Preprocessing")
self.preprocessing_menu.setFont(MENU_FONT)
self.preprocessing_menu.addAction(self.load_and_run_default_preprocessing_phase_action)
self.preprocessing_menu.addSeparator()
self.preprocessing_menu.addAction(self.load_preprocessing_phase_from_config_action)
self.preprocessing_menu.addAction(self.save_preprocessing_phase_to_config_action)
self.preprocessing_menu.addSeparator()
self.preprocessing_menu.addAction(self.run_preprocessing_phase_action)
self.matching_menu = self.menubar.addMenu("&Matching")
self.matching_menu.setFont(MENU_FONT)
self.matching_menu.addAction(self.load_and_run_default_matching_phase_action)
self.matching_menu.addSeparator()
self.matching_menu.addAction(self.load_matching_phase_from_config_action)
self.matching_menu.addAction(self.save_matching_phase_to_config_action)
self.matching_menu.addSeparator()
self.matching_menu.addAction(self.run_matching_phase_action)
self.statistics_menu = self.menubar.addMenu("&Statistics")
self.statistics_menu.setFont(MENU_FONT)
self.statistics_menu.addAction(self.enable_collect_statistics_action)
self.statistics_menu.addAction(self.disable_collect_statistics_action)
self.statistics_menu.addSeparator()
self.statistics_menu.addAction(self.save_statistics_to_json_action)
# start menu
self.start_menu_widget = QWidget()
self.start_menu_layout = QVBoxLayout(self.start_menu_widget)
self.start_menu_layout.setContentsMargins(0, 0, 0, 0)
self.start_menu_layout.setSpacing(30)
self.start_menu_layout.setAlignment(Qt.AlignmentFlag.AlignTop)
self.start_menu_widget.setMaximumWidth(400)
self.start_menu_header = QLabel("Welcome to ASET!")
self.start_menu_header.setFont(HEADER_FONT)
self.start_menu_layout.addWidget(self.start_menu_header)
self.start_menu_create_new_document_base_widget = QWidget()
self.start_menu_create_new_document_base_layout = QVBoxLayout(self.start_menu_create_new_document_base_widget)
self.start_menu_create_new_document_base_layout.setContentsMargins(0, 0, 0, 0)
self.start_menu_create_new_document_base_layout.setSpacing(10)
self.start_menu_layout.addWidget(self.start_menu_create_new_document_base_widget)
self.start_menu_create_new_document_base_subheader = QLabel("Create a new document base.")
self.start_menu_create_new_document_base_subheader.setFont(SUBHEADER_FONT)
self.start_menu_create_new_document_base_layout.addWidget(self.start_menu_create_new_document_base_subheader)
self.start_menu_create_new_document_base_wrapper_widget = QWidget()
self.start_menu_create_new_document_base_wrapper_layout = QHBoxLayout(
self.start_menu_create_new_document_base_wrapper_widget)
self.start_menu_create_new_document_base_wrapper_layout.setContentsMargins(0, 0, 0, 0)
self.start_menu_create_new_document_base_wrapper_layout.setSpacing(20)
self.start_menu_create_new_document_base_wrapper_layout.setAlignment(Qt.AlignmentFlag.AlignLeft)
self.start_menu_create_new_document_base_layout.addWidget(
self.start_menu_create_new_document_base_wrapper_widget)
self.start_menu_create_document_base_button = QPushButton()
self.start_menu_create_document_base_button.setFixedHeight(45)
self.start_menu_create_document_base_button.setFixedWidth(45)
self.start_menu_create_document_base_button.setIcon(QIcon("aset_ui/resources/two_documents.svg"))
self.start_menu_create_document_base_button.clicked.connect(self.show_document_base_creator_widget_task)
self.start_menu_create_new_document_base_wrapper_layout.addWidget(self.start_menu_create_document_base_button)
self.start_menu_create_document_base_label = QLabel(
"Create a new document base from a directory\nof .txt files and a list of attribute names.")
self.start_menu_create_document_base_label.setFont(LABEL_FONT)
self.start_menu_create_new_document_base_wrapper_layout.addWidget(self.start_menu_create_document_base_label)
self.start_menu_load_document_base_widget = QWidget()
self.start_menu_load_document_base_layout = QVBoxLayout(self.start_menu_load_document_base_widget)
self.start_menu_load_document_base_layout.setContentsMargins(0, 0, 0, 0)
self.start_menu_load_document_base_layout.setSpacing(10)
self.start_menu_layout.addWidget(self.start_menu_load_document_base_widget)
self.start_menu_load_document_base_subheader = QLabel("Load an existing document base.")
self.start_menu_load_document_base_subheader.setFont(SUBHEADER_FONT)
self.start_menu_load_document_base_layout.addWidget(self.start_menu_load_document_base_subheader)
self.start_menu_load_document_base_wrapper_widget = QWidget()
self.start_menu_load_document_base_wrapper_layout = QHBoxLayout(
self.start_menu_load_document_base_wrapper_widget)
self.start_menu_load_document_base_wrapper_layout.setContentsMargins(0, 0, 0, 0)
self.start_menu_load_document_base_wrapper_layout.setSpacing(20)
self.start_menu_load_document_base_wrapper_layout.setAlignment(Qt.AlignmentFlag.AlignLeft)
self.start_menu_load_document_base_layout.addWidget(self.start_menu_load_document_base_wrapper_widget)
self.start_menu_load_document_base_button = QPushButton()
self.start_menu_load_document_base_button.setFixedHeight(45)
self.start_menu_load_document_base_button.setFixedWidth(45)
self.start_menu_load_document_base_button.setIcon(QIcon("aset_ui/resources/folder.svg"))
self.start_menu_load_document_base_button.clicked.connect(self.load_document_base_from_bson_task)
self.start_menu_load_document_base_wrapper_layout.addWidget(self.start_menu_load_document_base_button)
self.start_menu_load_document_base_label = QLabel("Load an existing document base\nfrom a .bson file.")
self.start_menu_load_document_base_label.setFont(LABEL_FONT)
self.start_menu_load_document_base_wrapper_layout.addWidget(self.start_menu_load_document_base_label)
# main UI
self.central_widget = QWidget(self)
self.central_widget_layout = QHBoxLayout(self.central_widget)
self.central_widget_layout.setAlignment(Qt.AlignmentFlag.AlignCenter)
self.setCentralWidget(self.central_widget)
self.document_base_creator_widget = DocumentBaseCreatorWidget(self)
self.document_base_viewer_widget = DocumentBaseViewerWidget(self)
self.interactive_matching_widget = InteractiveMatchingWidget(self)
self.document_base_creator_widget.hide()
self.document_base_viewer_widget.hide()
self.interactive_matching_widget.hide()
self.central_widget_layout.addWidget(self.start_menu_widget)
self.central_widget_layout.update()
self.resize(1400, 800)
self.show()
logger.info("Initialized MainWindow.")
class Ventana_Calculadora(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.initUi()
def initUi(self):
self.setWindowTitle('Calculadora Suma 💻')
self.setFixedSize(300, 400)
self.lbl_numero_1 = QLabel('Número 1: ', self)
self.lbl_numero_1.move(50, 50)
self.lbl_numero_2 = QLabel('Número 2: ', self)
self.lbl_numero_2.move(50, 100)
self.txt_numero_1 = QLineEdit(self)
self.txt_numero_1.setFixedWidth(100)
self.txt_numero_1.move(150, 50)
self.txt_numero_2 = QLineEdit(self)
self.txt_numero_2.setFixedWidth(100)
self.txt_numero_2.move(150, 100)
self.btn_sumar = QPushButton('Sumar', self)
self.btn_sumar.setFixedWidth(100)
self.btn_sumar.move(100, 170)
self.btn_sumar.clicked.connect(self.sumar) # Evento Click
self.lbl_resultado = QLabel('Resultado: ', self)
self.lbl_resultado.move(50, 250)
self.lbl_resultado = QLabel(self)
self.lbl_resultado.setFixedWidth(100)
self.lbl_resultado.move(150, 250)
#self.lbl_resultado.setEnabled(False)
def sumar(self):
numero_1 = self.txt_numero_1.text().strip()
numero_2 = self.txt_numero_2.text().strip()
mensaje = QMessageBox()
mensaje.setWindowTitle('Algo salió mal...')
if len(numero_1):
if len(numero_2):
try:
numero_1 = float(numero_1)
except:
mensaje.setIcon(QMessageBox.Icon.Warning)
mensaje.setText(
'El número 1 debe ser un valor numérico...')
mensaje.exec()
return
try:
numero_2 = float(numero_2)
except:
mensaje.setIcon(QMessageBox.Icon.Warning)
mensaje.setText(
'El número 2 debe ser un valor numérico...')
mensaje.exec()
return
resultado = numero_1 + numero_2
self.lbl_resultado.setText(str(resultado))
else:
mensaje.setIcon(QMessageBox.Icon.Warning)
mensaje.setText('Debes digitar el Número 2...')
mensaje.exec()
else:
mensaje.setIcon(QMessageBox.Icon.Warning)
mensaje.setText('Debes digitar el Número 1...')
mensaje.exec()
class VideoWindow(QMainWindow):
def __init__(self, parent=None):
super(VideoWindow, self).__init__(parent)
self.setWindowTitle("StudioProject")
self.statusBar = QStatusBar()
self.setStatusBar(self.statusBar)
self.gScene = QGraphicsScene(self)
self.gView = GraphicView(self.gScene, self)
self.gView.viewport().setAttribute(
Qt.WidgetAttribute.WA_AcceptTouchEvents, False)
# self.gView.setBackgroundBrush(QBrush(Qt.black))
self.videoStartDatetime = None
self.videoCurrentDatetime = None
self.projectFile = ''
self.graphicsFile = ''
self.videoFile = ''
self.obsTb = ObsToolbox(self)
# # ===================== Setting video item ==============================
# self.videoItem = QGraphicsVideoItem()
# self.videoItem.setAspectRatioMode(Qt.KeepAspectRatio)
# self.gScene.addItem(self.videoItem)
# self.videoItem.mouseMoveEvent = self.gView.mouseMoveEvent
self.mediaPlayer = QMediaPlayer(self)
# self.mediaPlayer.setVideoOutput(self.videoItem)
self.mediaPlayer.playbackStateChanged.connect(self.mediaStateChanged)
self.mediaPlayer.positionChanged.connect(self.positionChanged)
self.mediaPlayer.durationChanged.connect(self.durationChanged)
self.mediaPlayer.errorOccurred.connect(self.handleError)
# self.mediaPlayer.setMuted(True)
# self.mediaPlayer.setNotifyInterval(100)
self.playButton = QPushButton()
self.playButton.setEnabled(False)
self.playButton.setIcon(self.style().standardIcon(
QStyle.StandardPixmap.SP_MediaPlay))
self.playButton.clicked.connect(self.play)
self.changePlayRateBtn = QPushButton('1x')
self.changePlayRateBtn.setFixedWidth(40)
# self.incrPlayRateBtn.setEnabled(False)
self.changePlayRateBtn.clicked.connect(self.changePlayRate)
self.positionSlider = QSlider(Qt.Orientation.Horizontal)
self.positionSlider.setRange(0, 0)
self.positionSlider.sliderMoved.connect(self.setPosition)
self.timerLabel = QLabel()
self.timerLabel.setText('--:--:--')
self.timerLabel.setFixedWidth(58)
self.dateLabel = QLabel()
self.dateLabel.setText('Video date: --')
self.statusBar.addPermanentWidget(self.dateLabel)
# Create open action
self.openVideoAction = QAction(QIcon('icons/video-file.png'),
'Open video', self)
self.openVideoAction.setShortcut('Ctrl+O')
self.openVideoAction.setStatusTip('Open video file')
self.openVideoAction.triggered.connect(self.openVideoFile)
# Create observation action
obsTbAction = QAction(QIcon('icons/checklist.png'),
'Observation toolbox', self)
obsTbAction.setStatusTip('Open observation toolbox')
obsTbAction.triggered.connect(self.openObsToolbox)
self.drawPointAction = QAction(QIcon('icons/drawPoint.png'),
'Draw point', self)
self.drawPointAction.setStatusTip('Draw point over the video')
self.drawPointAction.setCheckable(True)
self.drawPointAction.setEnabled(False)
self.drawPointAction.triggered.connect(self.drawingClick)
self.drawLineAction = QAction(QIcon('icons/drawLine.png'), 'Draw line',
self)
self.drawLineAction.setStatusTip('Draw line over the video')
self.drawLineAction.setCheckable(True)
self.drawLineAction.setEnabled(False)
self.drawLineAction.triggered.connect(self.drawingClick)
self.drawZoneAction = QAction(QIcon('icons/drawZone.png'), 'Draw zone',
self)
self.drawZoneAction.setStatusTip('Draw zone over the video')
self.drawZoneAction.setCheckable(True)
self.drawZoneAction.setEnabled(False)
self.drawZoneAction.triggered.connect(self.drawingClick)
self.maskGenAction = QAction(QIcon('icons/mask.png'),
'Generate mask file', self)
self.maskGenAction.setStatusTip(
'Generate mask file for TrafficIntelligence')
self.maskGenAction.setCheckable(True)
self.maskGenAction.setEnabled(False)
self.maskGenAction.triggered.connect(self.generateMask)
actionGroup = QActionGroup(self)
actionGroup.addAction(self.drawPointAction)
actionGroup.addAction(self.drawLineAction)
actionGroup.addAction(self.drawZoneAction)
openProjectAction = QAction(QIcon('icons/open-project.png'),
'Open project', self)
openProjectAction.setStatusTip('Open project')
openProjectAction.triggered.connect(self.openProject)
self.saveProjectAction = QAction(QIcon('icons/save-project.png'),
'Save project', self)
self.saveProjectAction.setStatusTip('Save project')
self.saveProjectAction.setEnabled(False)
self.saveProjectAction.triggered.connect(self.saveProject)
self.saveGraphAction = QAction(QIcon('icons/save-graphics.png'),
'Save graphics', self)
self.saveGraphAction.setStatusTip('Save graphics to database')
self.saveGraphAction.setEnabled(False)
self.saveGraphAction.triggered.connect(self.saveGraphics)
self.loadGraphAction = QAction(QIcon('icons/folders.png'),
'Load graphics', self)
self.loadGraphAction.setStatusTip('Load graphics from database')
self.loadGraphAction.setEnabled(False)
self.loadGraphAction.triggered.connect(self.loadGraphics)
# Create exit action
exitAction = QAction(QIcon('icons/close.png'), 'Exit', self)
exitAction.setShortcut('Ctrl+Q')
exitAction.setStatusTip('Exit application')
exitAction.triggered.connect(self.exitCall) # self.exitCall
# Create menu bar and add action
# menuBar = self.menuBar()
# menuBar.setNativeMenuBar(False)
# fileMenu = menuBar.addMenu('&File')
# fileMenu.addAction(openVideoAction)
# fileMenu.addAction(obsTbAction)
# fileMenu.addAction(exitAction)
self.toolbar = self.addToolBar('Tools')
self.toolbar.setIconSize(QSize(24, 24))
self.toolbar.addAction(openProjectAction)
self.toolbar.addAction(self.saveProjectAction)
self.toolbar.addAction(self.openVideoAction)
# self.toolbar.insertSeparator(self.loadGraphAction)
# self.toolbar.addAction(self.loadGraphAction)
# self.toolbar.addAction(self.saveGraphAction)
# self.toolbar.addAction(self.drawPointAction)
# self.toolbar.addAction(self.drawLineAction)
# self.toolbar.addAction(self.drawZoneAction)
self.toolbar.addAction(self.maskGenAction)
# self.toolbar.insertSeparator(self.drawPointAction)
self.toolbar.insertSeparator(obsTbAction)
self.toolbar.addAction(obsTbAction)
self.toolbar.insertSeparator(exitAction)
self.toolbar.addAction(exitAction)
# Create a widget for window contents
wid = QWidget(self)
self.setCentralWidget(wid)
# Create layouts to place inside widget
controlLayout = QHBoxLayout()
controlLayout.setContentsMargins(0, 0, 0, 0)
# controlLayout.addWidget(self.decrPlayRateBtn)
controlLayout.addWidget(self.playButton)
controlLayout.addWidget(self.changePlayRateBtn)
controlLayout.addWidget(self.timerLabel)
controlLayout.addWidget(self.positionSlider)
# controlLayout.addWidget(self.durationLabel)
layout = QVBoxLayout()
layout.addWidget(self.gView)
layout.addLayout(controlLayout)
# Set widget to contain window contents
wid.setLayout(layout)
# def showEvent(self, event):
# self.gView.fitInView(self.videoItem, Qt.KeepAspectRatio)
def openVideoFile(self):
# self.mediaPlayer.setMedia(QMediaContent())
if self.sender() == self.openVideoAction:
self.videoFile, _ = QFileDialog.getOpenFileName(
self, "Open video", QDir.homePath())
# if self.videoFile != '':
# self.setWindowTitle('{} - {}'.format(os.path.basename(self.videoFile),
# os.path.basename(self.projectFile)))
if self.videoFile != '':
self.setWindowTitle('{} - {}'.format(
os.path.basename(self.videoFile),
os.path.basename(self.projectFile)))
self.saveProjectAction.setEnabled(True)
self.maskGenAction.setEnabled(True)
# self.loadGraphAction.setEnabled(True)
# self.saveGraphAction.setEnabled(True)
# self.drawPointAction.setEnabled(True)
# self.drawLineAction.setEnabled(True)
# self.drawZoneAction.setEnabled(True)
creation_datetime, width, height = getVideoMetadata(self.videoFile)
self.videoStartDatetime = self.videoCurrentDatetime = creation_datetime
self.dateLabel.setText(creation_datetime.strftime('%a, %b %d, %Y'))
self.gView.setSceneRect(0, 0, width, height)
self.videoItem = QGraphicsVideoItem()
self.videoItem.setAspectRatioMode(
Qt.AspectRatioMode.KeepAspectRatio)
self.gScene.addItem(self.videoItem)
self.videoItem.mouseMoveEvent = self.gView.mouseMoveEvent
self.videoItem.setSize(QSizeF(width, height))
self.mediaPlayer.setVideoOutput(self.videoItem)
self.mediaPlayer.setSource(QUrl.fromLocalFile(self.videoFile))
self.gView.labelSize = width / 50
self.playButton.setEnabled(True)
# self.gView.setViewport(QOpenGLWidget())
self.mediaPlayer.pause()
def exitCall(self):
# sys.exit(app.exec())
# self.mediaPlayer.pause()
self.close()
def play(self):
# self.gView.fitInView(self.videoItem, Qt.KeepAspectRatio)
if self.mediaPlayer.playbackState(
) == QMediaPlayer.PlaybackState.PlayingState:
self.mediaPlayer.pause()
else:
self.mediaPlayer.play()
def changePlayRate(self):
if self.mediaPlayer.playbackRate() < 2:
r = self.mediaPlayer.playbackRate() + 0.5
self.mediaPlayer.setPlaybackRate(r)
self.changePlayRateBtn.setText('{:g}x'.format(r))
self.statusBar.showMessage('Play back rate = {:g}x'.format(r),
2000)
elif self.mediaPlayer.playbackRate() == 2:
self.mediaPlayer.setPlaybackRate(1)
self.changePlayRateBtn.setText('{}x'.format(1))
self.statusBar.showMessage('Play back rate = {}x'.format(1), 2000)
def mediaStateChanged(self, state):
if self.mediaPlayer.playbackState(
) == QMediaPlayer.PlaybackState.PlayingState:
self.playButton.setIcon(self.style().standardIcon(
QStyle.StandardPixmap.SP_MediaPause))
else:
self.playButton.setIcon(self.style().standardIcon(
QStyle.StandardPixmap.SP_MediaPlay))
def positionChanged(self, position):
self.positionSlider.setValue(position)
s, m, h = self.convertMillis(position)
self.videoCurrentDatetime = self.videoStartDatetime + \
timedelta(hours=h, minutes=m, seconds=s)
self.timerLabel.setText('{:02d}:{:02d}:{:02d}'.format(
self.videoCurrentDatetime.time().hour,
self.videoCurrentDatetime.time().minute,
self.videoCurrentDatetime.time().second))
def durationChanged(self, duration):
self.positionSlider.setRange(0, duration)
# s, m, h = self.convertMillis(duration)
# self.durationLabel.setText('{:02d}:{:02d}'.format(m, s))
def setPosition(self, position):
self.mediaPlayer.setPosition(position)
def handleError(self):
self.playButton.setEnabled(False)
# self.errorLabel.setText("Error: " + self.mediaPlayer.errorString())
def openObsToolbox(self):
if not self.obsTb.isVisible():
self.obsTb.show()
def drawingClick(self):
# if self.sender() == self.drawLineAction:
# self.labelingAction.setChecked(False)
# else:
# self.drawLineAction.setChecked(False)
cursor = QCursor(Qt.CursorShape.CrossCursor)
self.gView.setCursor(cursor)
def generateMask(self):
if not self.sender().isChecked():
self.gView.unsetCursor()
return
cursor = QCursor(Qt.CursorShape.CrossCursor)
self.gView.setCursor(cursor)
# dbfilename = self.obsTb.dbFilename
# if dbfilename != None:
# self.session = connectDatabase(dbfilename)
# else:
# msg = QMessageBox()
# msg.setIcon(QMessageBox.Information)
# msg.setText('The database file is not defined.')
# msg.setInformativeText('In order to set the database file, open the Observation Toolbox')
# msg.setIcon(QMessageBox.Critical)
# msg.exec_()
# return
# if self.gView.unsavedLines == [] and self.gView.unsavedZones == [] and \
# self.gView.unsavedPoints == []:
# QMessageBox.information(self, 'Save', 'There is no polygon to generate mask!')
# return
def saveMaskFile(self):
creation_datetime, width, height = getVideoMetadata(self.videoFile)
item = self.gView.gPolyItem #self.gView.unsavedZones[0]
mask_polygon = item.polygon()
xy = []
for p in mask_polygon:
xy.append((p.x(), p.y()))
img = Image.new('RGB', (width, height), color='black')
img1 = ImageDraw.Draw(img)
img1.polygon(xy, fill="white", outline="white")
fileName, _ = QFileDialog.getSaveFileName(self, "Open database file",
QDir.homePath(),
"PNG files (*.png)")
if fileName != '':
img.save(fileName)
self.gView.scene().removeItem(item)
self.gView.unsavedZones = []
def openProject(self):
self.projectFile, _ = QFileDialog.getOpenFileName(
self, "Open project file", QDir.homePath(), "Project (*.prj)")
if self.projectFile == '':
return
self.saveProjectAction.setEnabled(True)
self.maskGenAction.setEnabled(True)
# self.loadGraphAction.setEnabled(True)
# self.saveGraphAction.setEnabled(True)
# self.drawPointAction.setEnabled(True)
# self.drawLineAction.setEnabled(True)
# self.drawZoneAction.setEnabled(True)
tree = ET.parse(self.projectFile)
root = tree.getroot()
gItems = []
for elem in root:
subEelTexts = {}
for subelem in elem:
subEelTexts[subelem.tag] = subelem.text
gItems.append([elem.tag, subEelTexts])
for key in gItems:
if key[0] == 'database':
item = key[1]
if item['fileName'] is not None:
self.obsTb.dbFilename = item['fileName']
self.obsTb.opendbFile()
elif key[0] == 'video':
item = key[1]
if item['fileName'] is not None:
self.videoFile = item['fileName']
self.openVideoFile()
self.mediaPlayer.setPosition(int(item['sliderValue']))
if item['fileName'] is not None:
self.loadGraphics()
elif key[0] == 'trajectory':
item = key[1]
if item['metadata'] != None:
self.obsTb.mdbFileLedit.setText(item['metadata'])
self.obsTb.openMdbFile()
self.obsTb.siteNameCombobx.setCurrentIndex(
int(item['site']))
self.obsTb.camViewCombobx.setCurrentIndex(
int(item['cam_view']))
self.obsTb.trjDbCombobx.setCurrentIndex(
int(item['traj_db']))
elif key[0] == 'window':
item = key[1]
x, y = item['mainWin_pos'].split(',')
w, h = item['mainWin_size'].split(',')
self.setGeometry(int(x), int(y), int(w), int(h))
if item['obsTbx_open'] == 'True':
self.obsTb.show()
x, y = item['obsTbx_pos'].split(',')
w, h = item['obsTbx_size'].split(',')
self.obsTb.setGeometry(int(x), int(y), int(w), int(h))
# self.setWindowTitle('{} - {}'.format(os.path.basename(self.videoFile),
# os.path.basename(self.projectFile)))
def saveProject(self):
if self.projectFile == '':
fileDir = QDir.homePath()
else:
fileDir = self.projectFile
self.projectFile, _ = QFileDialog.getSaveFileName(
self, "Save project file", fileDir, "Project (*.prj)")
# fileName = "/Users/Abbas/project.xml"
if self.projectFile == '':
return
file = QFile(self.projectFile)
if (not file.open(QIODevice.OpenModeFlag.WriteOnly
| QIODevice.OpenModeFlag.Text)):
return
xmlWriter = QXmlStreamWriter(file)
xmlWriter.setAutoFormatting(True)
xmlWriter.writeStartDocument()
xmlWriter.writeStartElement('project')
xmlWriter.writeStartElement('database')
xmlWriter.writeTextElement("fileName", self.obsTb.dbFilename)
xmlWriter.writeEndElement()
xmlWriter.writeStartElement('video')
xmlWriter.writeTextElement(
"fileName",
self.videoFile) #mediaPlayer.media().canonicalUrl().path())
xmlWriter.writeTextElement("sliderValue",
str(self.mediaPlayer.position()))
xmlWriter.writeEndElement()
xmlWriter.writeStartElement('trajectory')
xmlWriter.writeTextElement("metadata", self.obsTb.mdbFileLedit.text())
xmlWriter.writeTextElement(
"site", str(self.obsTb.siteNameCombobx.currentIndex()))
xmlWriter.writeTextElement(
"cam_view", str(self.obsTb.camViewCombobx.currentIndex()))
xmlWriter.writeTextElement("traj_db",
str(self.obsTb.trjDbCombobx.currentIndex()))
xmlWriter.writeEndElement()
xmlWriter.writeStartElement('window')
xmlWriter.writeTextElement(
"mainWin_size", "{},{}".format(int(self.width()),
int(self.height())))
xmlWriter.writeTextElement(
"mainWin_pos", "{},{}".format(int(self.x()), int(self.y())))
xmlWriter.writeTextElement("obsTbx_open", str(self.obsTb.isVisible()))
xmlWriter.writeTextElement(
"obsTbx_size", "{},{}".format(int(self.obsTb.width()),
int(self.obsTb.height())))
xmlWriter.writeTextElement(
"obsTbx_pos", "{},{}".format(int(self.obsTb.x()),
int(self.obsTb.y())))
xmlWriter.writeEndElement()
xmlWriter.writeEndElement()
self.setWindowTitle('{} - {}'.format(
os.path.basename(self.videoFile),
os.path.basename(self.projectFile)))
if self.obsTb.dbFilename != None:
self.obsTb.setWindowTitle('{} - {}'.format(
os.path.basename(self.obsTb.dbFilename),
os.path.basename(self.projectFile)))
def saveGraphics(self):
dbfilename = self.obsTb.dbFilename
if dbfilename != None:
self.session = connectDatabase(dbfilename)
else:
msg = QMessageBox()
msg.setIcon(QMessageBox.Information)
msg.setText('The database file is not defined.')
msg.setInformativeText(
'In order to set the database file, open the Observation Toolbox'
)
msg.setIcon(QMessageBox.Critical)
msg.exec_()
return
if self.gView.unsavedLines == [] and self.gView.unsavedZones == [] and \
self.gView.unsavedPoints == []:
QMessageBox.information(self, 'Save',
'No new graphical items to save!')
return
for item in self.gView.unsavedLines:
x1 = round(item.line().x1(), 2)
y1 = round(item.line().y1(), 2)
x2 = round(item.line().x2(), 2)
y2 = round(item.line().y2(), 2)
line = Line(None, None, x1, y1, x2, y2)
self.session.add(line)
self.session.flush()
label = self.generate_itemGroup([x1, x2], [y1, y2], line.idx)
self.gView.scene().addItem(label)
for item in self.gView.unsavedZones:
xs = []
ys = []
for p in item.polygon():
xs.append(round(p.x(), 2))
ys.append(round(p.y(), 2))
zone = Zone(None, None, xs, ys)
self.session.add(zone)
self.session.flush()
label = self.generate_itemGroup(xs, ys, zone.idx)
self.gView.scene().addItem(label)
for item in self.gView.unsavedPoints:
x = round(item.rect().center().x(), 2)
y = round(item.rect().center().y(), 2)
point = Point(x, y)
self.session.add(point)
self.session.flush()
label = self.generate_itemGroup([x], [y], point.idx)
self.gView.scene().removeItem(item)
self.gView.scene().addItem(label)
QMessageBox.information(
self, 'Save',
'{} point(s), {} line(s) and {} zone(s) saved to database successfully!'
.format(len(self.gView.unsavedPoints),
len(self.gView.unsavedLines),
len(self.gView.unsavedZones)))
self.gView.unsavedLines = []
self.gView.unsavedZones = []
self.gView.unsavedPoints = []
self.session.commit()
def generate_itemGroup(self, xs, ys, label, type):
gItemGroup = QGraphicsItemGroup()
pointBbx = QRectF()
pointBbx.setSize(QSizeF(self.gView.labelSize, self.gView.labelSize))
textLabel = QGraphicsTextItem(label)
if len(xs) == 1:
pointBbx.moveCenter(QPointF(xs[0], ys[0]))
textLabel.setPos(xs[0] - (textLabel.boundingRect().width() / 2),
ys[0] - (textLabel.boundingRect().height() / 2))
pointShape = QGraphicsEllipseItem(pointBbx)
shapeColor = Qt.GlobalColor.white
textColor = Qt.GlobalColor.black
tooltip = 'P{}:{}'
elif len(xs) == 2:
pointBbx.moveCenter(QPointF(xs[1], ys[1]))
textLabel.setPos(xs[1] - (textLabel.boundingRect().width() / 2),
ys[1] - (textLabel.boundingRect().height() / 2))
r, g, b = np.random.choice(range(256), size=3)
line_item = QGraphicsLineItem(xs[0], ys[0], xs[1], ys[1])
line_item.setPen(
QPen(QColor(r, g, b, 128), self.gView.labelSize / 6))
gItemGroup.addToGroup(line_item)
# line_end = QGraphicsEllipseItem(xs[1], ys[1],
# int(self.gView.labelSize/3), int(self.gView.labelSize/3))
# line_end.setPen(QPen(QColor(r, g, b), 0.5))
# line_end.setBrush(QBrush(QColor(r, g, b)))
# gItemGroup.addToGroup(line_end)
pointShape = QGraphicsEllipseItem(pointBbx)
shapeColor = QColor(r, g, b, 128)
textColor = Qt.GlobalColor.black
tooltip = 'L{}:{}'
# textLabel.setRotation(np.arctan((ys[1] - ys[0])/(xs[1] - xs[0]))*(180/3.14))
else:
pointBbx.moveCenter(QPointF(np.mean(xs), np.mean(ys)))
textLabel.setPos(
np.mean(xs) - (textLabel.boundingRect().width() / 2),
np.mean(ys) - (textLabel.boundingRect().height() / 2))
points = [QPointF(x, y) for x, y in zip(xs, ys)]
polygon = QPolygonF(points)
r, g, b = np.random.choice(range(256), size=3)
zone_item = QGraphicsPolygonItem(polygon)
zone_item.setPen(QPen(QColor(r, g, b), self.gView.labelSize / 10))
zone_item.setBrush(QBrush(QColor(r, g, b, 40)))
gItemGroup.addToGroup(zone_item)
pointShape = QGraphicsRectItem(pointBbx)
shapeColor = Qt.GlobalColor.darkBlue
textColor = Qt.GlobalColor.white
tooltip = 'Z{}:{}'
pointShape.setPen(QPen(Qt.GlobalColor.white, 0.5))
pointShape.setBrush(QBrush(shapeColor))
# self.gView.scene().addEllipse(pointBbx, QPen(Qt.white, 0.5), QBrush(Qt.black))
gItemGroup.setToolTip(tooltip.format(label, type))
gItemGroup.addToGroup(pointShape)
labelFont = QFont()
labelFont.setPointSize(round(self.gView.labelSize / 2))
labelFont.setBold(True)
textLabel.setFont(labelFont)
textLabel.setDefaultTextColor(textColor)
gItemGroup.addToGroup(textLabel)
return gItemGroup
def loadGraphics(self):
dbfilename = self.obsTb.dbFilename
if dbfilename != None:
self.session = connectDatabase(dbfilename)
else:
msg = QMessageBox()
# msg.setIcon(QMessageBox.Icon.Information)
msg.setText('The database file is not defined.')
msg.setInformativeText(
'In order to set the database file, open the Observation Toolbox'
)
msg.setIcon(QMessageBox.Icon.Critical)
msg.exec()
return
for gitem in self.gView.scene().items():
if isinstance(gitem, QGraphicsItemGroup):
self.gView.scene().removeItem(gitem)
q_line = self.session.query(Line)
q_zone = self.session.query(Zone)
if q_line.all() == [] and q_zone.all() == []:
QMessageBox.information(self, 'Warning!',
'There is no graphics to load!')
return
line_items = []
for line in q_line:
p1 = line.points[0]
p2 = line.points[1]
if line.type != None:
lineType = line.type.name
else:
lineType = None
gItmGroup = self.generate_itemGroup([p1.x, p2.x], [p1.y, p2.y],
str(line.idx), lineType)
self.gScene.addItem(gItmGroup)
line_items.append(str(line.idx))
self.obsTb.line_list_wdgt.clear()
self.obsTb.line_list_wdgt.addItems(line_items)
self.obsTb.line_list_wdgt.setCurrentRow(0)
self.obsTb.line_newRecButton.setEnabled(False)
self.obsTb.line_saveButton.setEnabled(True)
self.obsTb.line_saveButton.setText('Edit line(s)')
self.obsTb.line_saveButton.setIcon(QIcon('icons/edit.png'))
zone_items = []
for zone in q_zone:
if zone.type != None:
zoneType = zone.type.name
else:
zoneType = None
gItmGroup = self.generate_itemGroup(
[point.x for point in zone.points],
[point.y for point in zone.points], str(zone.idx), zoneType)
self.gScene.addItem(gItmGroup)
zone_items.append(str(zone.idx))
self.obsTb.zone_list_wdgt.clear()
self.obsTb.zone_list_wdgt.addItems(zone_items)
self.obsTb.zone_list_wdgt.setCurrentRow(0)
self.obsTb.zone_newRecButton.setEnabled(False)
self.obsTb.zone_saveButton.setEnabled(True)
self.obsTb.zone_saveButton.setText('Edit zone(s)')
self.obsTb.zone_saveButton.setIcon(QIcon('icons/edit.png'))
@staticmethod
def convertMillis(millis):
seconds = int(millis / 1000) % 60
minutes = int(millis / (1000 * 60)) % 60
hours = int(millis / (1000 * 60 * 60)) % 24
return seconds, minutes, hours