def draw_navmesh_neighbor_line(self, scene: QGraphicsScene, poly: Polygon,
begin: ShapelyPoint) -> None:
vertex = Point(begin.x, begin.y)
centroid = poly.centroid
direction = Point(centroid.x, centroid.y)
end = vertex.point_from_heading(
vertex.heading_between_point(direction),
nautical_miles(2).meters)
scene.addLine(
QLineF(QPointF(*self._transform_point(vertex)),
QPointF(*self._transform_point(end))),
CONST.COLORS["yellow"])
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.dibujar.clicked.connect(self.dibujar)
self.ui.limpiar.clicked.connect(self.limpiar)
self.scene = QGraphicsScene()
self.ui.graphicsView.setScene(self.scene)
def wheelEvent(self, event):
print(event.delta())
if event.delta() > 0:
self.ui.graphicsView.scale(1.2, 1.2)
else:
self.ui.graphicsView.scale(0.8, 0.8)
@Slot()
def dibujar(self):
print('dibujar')
pen = QPen()
pen.setWidth(2)
for i in range(0, 100):
r = randint(0, 255)
g = randint(0, 255)
b = randint(0, 255)
color = QColor(r, g, b)
pen.setColor(color)
x_origen = randint(0, 500)
y_origen = randint(0, 500)
x_destin = randint(0, 500)
y_destin = randint(0, 500)
self.scene.addEllipse(x_origen, y_origen, 6, 6, pen)
self.scene.addEllipse(x_destin, y_destin, 6, 6, pen)
self.scene.addLine(x_origen + 3, y_origen + 3, x_destin + 3,
y_destin + 3, pen)
@Slot()
def limpiar(self):
print('limpiar')
self.scene.clear()
self.ui.graphicsView.setTransform(QTransform())
def __init__(self, start_state: GridGameState):
super().__init__(start_state)
self.start_state: GridGameState = start_state
self.spaces = [] # self.spaces[i][j] holds row i, column j
self.column_dividers = []
self.row_dividers = []
self.column_labels = []
self.row_labels = []
self.text_x = self.text_y = 0
ui = self.ui = Ui_GridControls()
ui.setupUi(self)
scene = QGraphicsScene()
ui.game_display.setScene(scene)
scene.setBackgroundBrush(self.background_colour)
self.player1_icon = self.create_icon(self.player1_colour)
self.player2_icon = self.create_icon(self.player2_colour)
ui.black_count_pixmap.setText('')
ui.white_count_pixmap.setText('')
ui.black_count.setText('')
ui.white_count.setText('')
for _ in range(start_state.board_height - 1):
self.row_dividers.append(scene.addLine(0, 0, 1, 1))
for _ in range(start_state.board_width - 1):
self.column_dividers.append(scene.addLine(0, 0, 1, 1))
for i in range(start_state.board_height):
self.row_labels.append(scene.addSimpleText(f'{i + 1}'))
for j in range(start_state.board_width):
self.column_labels.append(scene.addSimpleText(chr(65 + j)))
self.to_move = scene.addEllipse(0,
0,
1,
1,
brush=self.get_player_brush(
self.start_state.X_PLAYER))
self.to_move.setVisible(False)
self.move_text = ui.move_text
for i in range(self.start_state.board_height):
row: typing.List[QGraphicsItem] = []
self.spaces.append(row)
for j in range(self.start_state.board_width):
piece = GraphicsPieceItem(i, j, self)
scene.addItem(piece)
piece.setBrush(self.background_colour)
piece.setPen(self.background_colour)
row.append(piece)
self.debug_message = ''
def draw_shortest_path(self, scene: QGraphicsScene, navmesh: NavMesh,
destination: Point, player: bool) -> None:
for line in self.shortest_path_segments:
try:
scene.removeItem(line)
except RuntimeError:
pass
if player:
origin = self.game.theater.player_points()[0]
else:
origin = self.game.theater.enemy_points()[0]
prev_pos = self._transform_point(origin.position)
try:
path = navmesh.shortest_path(origin.position, destination)
except ValueError:
return
for waypoint in path[1:]:
new_pos = self._transform_point(waypoint)
flight_path_pen = self.flight_path_pen(player, selected=True)
# Draw the line to the *middle* of the waypoint.
offset = self.WAYPOINT_SIZE // 2
self.shortest_path_segments.append(
scene.addLine(prev_pos[0] + offset, prev_pos[1] + offset,
new_pos[0] + offset, new_pos[1] + offset,
flight_path_pen))
self.shortest_path_segments.append(
scene.addEllipse(new_pos[0], new_pos[1], self.WAYPOINT_SIZE,
self.WAYPOINT_SIZE, flight_path_pen,
flight_path_pen))
prev_pos = new_pos
def draw_flight_path(self, scene: QGraphicsScene,
pos0: Tuple[float, float], pos1: Tuple[float, float],
player: bool, selected: bool) -> None:
flight_path_pen = self.flight_path_pen(player, selected)
# Draw the line to the *middle* of the waypoint.
offset = self.WAYPOINT_SIZE // 2
self.flight_path_items.append(
scene.addLine(pos0[0] + offset, pos0[1] + offset, pos1[0] + offset,
pos1[1] + offset, flight_path_pen))
def draw_bezier_frontline(
self, scene: QGraphicsScene, pen: QPen, frontline: FrontLine
) -> None:
"""
Thanks to Alquimista for sharing a python implementation of the bezier algorithm this is adapted from.
https://gist.github.com/Alquimista/1274149#file-bezdraw-py
"""
bezier_fixed_points = []
for segment in frontline.segments:
bezier_fixed_points.append(self._transform_point(segment.point_a))
bezier_fixed_points.append(self._transform_point(segment.point_b))
old_point = bezier_fixed_points[0]
for point in bezier_curve_range(
int(len(bezier_fixed_points) * 2), bezier_fixed_points
):
scene.addLine(old_point[0], old_point[1], point[0], point[1], pen=pen)
old_point = point
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.dibujar.clicked.connect(self.dibujar)
self.ui.limpiar.clicked.connect(self.limpiar)
self.scene = QGraphicsScene()
self.ui.graphicsView.setScene(self.scene)
def wheelEvent(self, event):
if event.delta() > 0:
self.ui.graphicsView.scale(1.2, 1.2)
else:
self.ui.graphicsView.scale(0.8, 0.8)
@Slot()
def dibujar(self):
pen = QPen()
pen.setWidth(2)
for i in range(200):
r = randint(0, 255)
g = randint(0, 255)
b = randint(0, 255)
color = QColor(r, g, b)
pen.setColor(color)
origen_x = randint(0, 500)
origen_y = randint(0, 500)
destino_x = randint(0, 500)
destino_y = randint(0, 500)
self.scene.addEllipse(origen_x, origen_y, 3, 3, pen)
self.scene.addEllipse(destino_x, destino_y, 3, 3, pen)
self.scene.addLine(origen_x+3, origen_y+3, destino_x, destino_y, pen)
@Slot()
def limpiar(self):
self.scene.clear()
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.particulas = AdminParticula() #instancia en la clase MainWindow
self.ui = Ui_MainWindow() #crear un objeto de una vista del designer
self.ui.setupUi(self) #Las configuraciones que se hacen se incrustan en el objeto
self.ui.agregar_inicio_pushButton.clicked.connect(self.click_agregar_inicio) #Decirle que cuando le de click se conecte a la función
self.ui.agregar_final_pushButton.clicked.connect(self.click_agregar_final)
self.ui.mostrar_pushButton.clicked.connect(self.mostrar) #Conectar el evento del boton a la función
#Conectar eventos al presionar respectivos botones abrir y guardar
#Triggered -> Disparó
self.ui.actionAbrir.triggered.connect(self.action_abrir_archivo)
self.ui.actionGuardar.triggered.connect(self.action_guardar_archivo)
#Conexión a botones tabla
self.ui.mostrar_tabla_pushButton.clicked.connect(self.action_mostrar_tabla)
self.ui.buscar_pushButton.clicked.connect(self.action_buscar_id)
#Conexión a botones dibujar
self.ui.draw_pushButton.clicked.connect(self.action_dibujar)
self.ui.clear_pushButton.clicked.connect(self.action_limpiar)
#Crear Escena
self.scene = QGraphicsScene() #Crear escena
self.ui.graphicsView.setScene(self.scene) #Insertar scene
#Button sort Plane and Edit
self.ui.sort_plane_pushButton.clicked.connect(self.action_sort_plane)
#Button Busquedas en profundidad y en anchura
self.ui.busqueda_grafo_pushButton.clicked.connect(self.action_busqueda_grafo)
#Busqueda en grafo profundidad y anchura
@Slot()
def action_busqueda_grafo(self):
grafo = self.particulas.get_grafo()
listAux = list(grafo.keys())
arista_x = self.ui.nodo_x_spinBox.value()
arista_y = self.ui.nodo_y_spinBox.value()
profundidad = False
if arista_x == 0 and arista_y == 0:
if self.ui.tipo_busqueda_comboBox.currentText() == "Profundidad":
recorrido_grafo = busqueda_profundidad(grafo, listAux[0])
profundidad = True
elif self.ui.tipo_busqueda_comboBox.currentText() == "Anchura":
recorrido_grafo = busqueda_amplitud(grafo, listAux[0])
else:
return -1
else:
origen = (arista_x, arista_y)
if self.ui.tipo_busqueda_comboBox.currentText() == "Profundidad":
recorrido_grafo = busqueda_profundidad(grafo, origen)
profundidad = True
elif self.ui.tipo_busqueda_comboBox.currentText() == "Anchura":
recorrido_grafo = busqueda_amplitud(grafo, origen)
else:
return -1
self.ui.mostrar_grafo_plainTextEdit.clear()
if profundidad:
self.ui.mostrar_grafo_plainTextEdit.insertPlainText("Profundidad: \n")
else:
self.ui.mostrar_grafo_plainTextEdit.insertPlainText("Anchura: \n")
for i in recorrido_grafo:
self.ui.mostrar_grafo_plainTextEdit.insertPlainText(str(i))
self.ui.mostrar_grafo_plainTextEdit.insertPlainText("\n")
#self.ui.mostrar_grafo_plainTextEdit.insertPlainText(pformat(recorrido_grafo, width=20))
#print(recorrido_grafo)
#Odenamientos sort()
@Slot()
def action_sort_plane(self):
if self.ui.desicion_plane_comboBox.currentText() == "Id (ascendente)":
self.particulas.sort_id()
elif self.ui.desicion_plane_comboBox.currentText() == "Distancia (descendente)":
self.particulas.sort_distancia()
elif self.ui.desicion_plane_comboBox.currentText() == "Velocidad (ascendente)":
self.particulas.sort_velocidad()
else:
return -1
if len(self.particulas) > 0:
QMessageBox.information(
self,
"Éxito",
"Se ordeno con éxito"
)
def wheelEvent(self, event):
if event.delta() > 0:
self.ui.graphicsView.scale(1.2, 1.2)
else:
self.ui.graphicsView.scale(0.8, 0.8)
@Slot()
def action_dibujar(self):
if len(self.particulas) > 0:
pen = QPen() #Definir una pluma
pen.setWidth(2) #Tamaño en pixelex del ancho de la pluma
#Ingresar el color
for particula in self.particulas:
color = QColor(particula.red, particula.green, particula.blue)
pen.setColor(color)
self.scene.addEllipse(particula.origen_x, particula.origen_y, 3, 3, pen) #Dibujar un elipse -> (0, 0, 3, 3) ->posX, posY, radio, radio
self.scene.addEllipse(particula.destino_x, particula.destino_y, 3, 3, pen)
self.scene.addLine(particula.origen_x, particula.origen_y, particula.destino_x, particula.destino_y, pen) #Agregar linea entre los dos elipses
else:
QMessageBox.warning(
self,
"Atención",
'No hay partículas registradas'
)
@Slot()
def action_limpiar(self):
self.scene.clear()
#Reestablecer la escala al predeterminado
self.ui.graphicsView.setTransform(QTransform())
@Slot()
def action_buscar_id(self):
busca_id = self.ui.buscar_lineEdit.text() #Obtener el texto del lineEdit
if(len(busca_id) > 0):
busca_id = int(busca_id)
encontrado = False
for particula in self.particulas:
if busca_id == particula.id:
self.ui.table.clear() #Limpiar tabla
self.table_add_column()
self.ui.table.setRowCount(1)
self.table_widget(0, particula)
encontrado = True
return
if not encontrado:
QMessageBox.warning(
self,
"Atención",
f'La partícula con el id "{busca_id}" no fue encontrada'
)
@Slot()
def action_mostrar_tabla(self):
self.table_add_column()
self.ui.table.setRowCount(len(self.particulas)) #Agregar filas a la tabla
row = 0 #Contador de filas
for particula in self.particulas:
self.table_widget(row, particula)
row += 1
def table_widget(self, row, particula:Particula):
#construcción de Widgets
id_widget = QTableWidgetItem(str(particula.id))
origen_x_widget = QTableWidgetItem(str(particula.origen_x))
origen_y_widget = QTableWidgetItem(str(particula.origen_y))
destino_x_widget = QTableWidgetItem(str(particula.destino_x))
destino_y_widget = QTableWidgetItem(str(particula.destino_y))
velocidad_widget = QTableWidgetItem(str(particula.velocidad))
red_widget = QTableWidgetItem(str(particula.red))
green_widget = QTableWidgetItem(str(particula.green))
blue_widget = QTableWidgetItem(str(particula.blue))
distancia_widget = QTableWidgetItem(str(particula.distancia))
#Ingresar información en la tabla
self.ui.table.setItem(row, 0, id_widget)
self.ui.table.setItem(row, 1, origen_x_widget)
self.ui.table.setItem(row, 2, origen_y_widget)
self.ui.table.setItem(row, 3, destino_x_widget)
self.ui.table.setItem(row, 4, destino_y_widget)
self.ui.table.setItem(row, 5, velocidad_widget)
self.ui.table.setItem(row, 6, red_widget)
self.ui.table.setItem(row, 7, green_widget)
self.ui.table.setItem(row, 8, blue_widget)
self.ui.table.setItem(row, 9, distancia_widget)
def table_add_column(self):
self.ui.table.setColumnCount(10) #Generar columnas en la tabla
#Nombre de los headers en una lista
headers = ["Id", "Origen x", "Origen y", "Destino x", "Destino y", "Velocidad", "Red", "Green", "Blue", "Distancia"]
self.ui.table.setHorizontalHeaderLabels(headers) #Ingresar el nombre de las columnas
@Slot()
def action_abrir_archivo(self):
#print("Abrir archivo")
ubicacion = QFileDialog.getOpenFileName( #Regresa ubicación del archivo modo de apertura
self,
'Abrir Archivo',
'.', #Decirle desde la carpeta que se esta trabajando
'JSON (*.json)'
)[0]
if self.particulas.abrir(ubicacion):
self.particulas.mandar_particulas_grafo()
QMessageBox.information(
self,
"Éxito",
"Se abrió el archivo " + ubicacion
)
else:
QMessageBox.critical(
self,
"Error",
"Error al abrir el archivo " + ubicacion
)
@Slot()
def action_guardar_archivo(self):
#print('Guardar Archivo')
ubicacion = QFileDialog.getSaveFileName( #Método para regresar la ubicación
self,
'Guardar Archivo',
'.',
'JSON (*.json)'
)[0] #pirmera posición de la tupla
#print(ubicacion)
if self.particulas.guardar(ubicacion): #invocar método de AdminParticula()
QMessageBox.information(
self,
"Éxito",
"Se pudo crear el archivo " + ubicacion
)
else:
QMessageBox.critical(
self,
"Error",
"No se pudo crear el archivo " + ubicacion
)
def limpiar(self):
self.ui.id_spinBox.setValue(0)
self.ui.origenx_spinBox.setValue(0)
self.ui.origeny_spinBox.setValue(0)
self.ui.destinox_spinBox.setValue(0)
self.ui.destinoy_spinBox.setValue(0)
self.ui.velocidad_spinBox.setValue(0)
self.ui.red_spinBox.setValue(0)
self.ui.green_spinBox.setValue(0)
self.ui.blue_spinBox.setValue(0)
def entrada_datos(self):
id = self.ui.id_spinBox.value()
origen_x = self.ui.origenx_spinBox.value()
origen_y = self.ui.origeny_spinBox.value()
destino_x = self.ui.destinox_spinBox.value()
destino_y = self.ui.destinoy_spinBox.value()
velocidad = self.ui.velocidad_spinBox.value()
red = self.ui.red_spinBox.value()
green = self.ui.green_spinBox.value()
blue = self.ui.blue_spinBox.value()
particula = Particula(id, origen_x, origen_y, destino_x, destino_y, velocidad, red, green, blue)
return particula
@Slot() #Decirle que la siguiente función detectara eventos click
def click_agregar_inicio(self):
self.particulas.agregar_inicio(self.entrada_datos())
self.limpiar()
@Slot()
def click_agregar_final(self):
self.particulas.agregar_final(self.entrada_datos())
self.limpiar()
@Slot()
def mostrar(self):
self.ui.salida.clear()
self.ui.salida.insertPlainText(str(self.particulas))
self.ui.salida_plainTextEdit.clear()
self.ui.salida_plainTextEdit.insertPlainText(self.particulas.mostrar_grafo())
print("Grafo: ", self.particulas.mostrar_grafo())
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.particula = Particula()
self.organizador = Organizador()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.abInicio.clicked.connect(self.click_agregar_inicio)
self.ui.abFinal.clicked.connect(self.click_agregar_final)
self.ui.abMostrar.clicked.connect(self.click_mostrar)
self.ui.actionGuardar_.triggered.connect(self.guardar)
self.ui.actionAbrir_.triggered.connect(self.abrir)
self.ui.abMostrarParticulas.clicked.connect(
self.mostrarParticulasTodas)
self.ui.abBuscar.clicked.connect(self.buscarParticulaId)
self.ui.abLimpiar.clicked.connect(self.limpiar)
self.scene = QGraphicsScene()
self.ui.graphicsView.setScene(self.scene)
def wheelEvent(self, event):
if event.delta() > 0:
self.ui.graphicsView.scale(1.2, 1.2)
else:
self.ui.graphicsView.scale(0.8, 0.8)
@Slot()
def click_mostrar(self):
if (not self.ui.rBId.isChecked()
and not self.ui.rBDistancia.isChecked()
and not self.ui.rBVelocidad.isChecked()):
QMessageBox.about(self, "Advertencia",
"Seleccione alguna de las siguientes opciones.")
self.click_mostrar_grafico()
lista = []
if (self.ui.rBId.isChecked()):
lista = sorted(self.organizador.organizador,
key=lambda particula: particula.Id,
reverse=False)
elif (self.ui.rBDistancia.isChecked()):
lista = sorted(self.organizador.organizador,
key=lambda particula: particula.distancia,
reverse=True)
elif (self.ui.rBVelocidad.isChecked()):
lista = sorted(self.organizador.organizador,
key=lambda particula: particula.velocidad,
reverse=False)
#self.click_mostrar_ordenacion(lista)
self.click_mostrar_grafo()
@Slot()
def click_mostrar_grafico(self):
pen = QPen()
pen.setWidth(2)
for item in self.organizador.organizador:
pen.setColor(item.color())
origen_x = item.Xi()
origen_y = item.Yi()
destino_x = item.Xf()
destino_y = item.Yf()
self.scene.addEllipse(origen_x, origen_y, 3, 3, pen)
self.scene.addEllipse(destino_x, destino_y, 3, 3, pen)
self.scene.addLine(origen_x + 3, origen_y + 3, destino_x,
destino_y, pen)
@Slot()
def click_mostrar_ordenacion(self, lista):
cadenas = ""
self.ui.plainTextEdit.clear()
for particula in lista:
cadenas += str(particula) + "\n"
self.ui.plainTextEdit.insertPlainText(cadenas)
@Slot()
def click_mostrar_grafo(self):
grafo = dict()
for particula in self.organizador.organizador:
grafo[particula.origenInicial()] = []
grafo[particula.destinoFinal()] = []
for particula in self.organizador.organizador:
grafo[particula.origenInicial()].append(
(particula.destinoFinal(), particula.distancia))
grafo[particula.destinoFinal()].append(
(particula.origenInicial(), particula.distancia))
str = pformat(grafo, width=40, indent=1)
self.ui.plainTextEdit.clear()
self.ui.plainTextEdit.insertPlainText(str)
print(str)
@Slot()
def click_agregar_inicio(self):
id = self.ui.id.value()
origen_x = self.ui.origenX.value()
origen_y = self.ui.origenY.value()
destino_x = self.ui.destinoX.value()
destino_y = self.ui.destinoY.value()
velocidad = self.ui.velocidad.value()
rojo = self.ui.rojo.value()
verde = self.ui.verde.value()
azul = self.ui.azul.value()
particula = Particula(id, origen_x, origen_y, destino_x, destino_y,
velocidad, rojo, verde, azul)
self.organizador.agregar_inicio(particula)
@Slot()
def click_agregar_final(self):
id = self.ui.id.value()
origen_x = self.ui.origenX.value()
origen_y = self.ui.origenY.value()
destino_x = self.ui.destinoX.value()
destino_y = self.ui.destinoY.value()
velocidad = self.ui.velocidad.value()
rojo = self.ui.rojo.value()
verde = self.ui.verde.value()
azul = self.ui.azul.value()
particula = Particula(id, origen_x, origen_y, destino_x, destino_y,
velocidad, rojo, verde, azul)
self.organizador.agregar_final(particula)
@Slot()
def guardar(self):
ubicacion = QFileDialog.getSaveFileName(self, 'Guardar', '.',
'JSON (*.json)')
with open(ubicacion[0], 'w') as archivo:
json.dump(self.organizador.guardar(), archivo, indent=4)
@Slot()
def abrir(self):
ubicacion = QFileDialog.getOpenFileName(self, 'Abrir', '.',
'JSON (*.json)')
with open(ubicacion[0], 'r') as archivo:
self.organizador.get(json.load(archivo))
@Slot()
def buscarParticulaId(self):
id = self.ui.lineaBuscar.text()
encontrado = False
for item in self.organizador.organizador:
if id == item.getId():
self.ui.tableWidget.clear()
self.ui.tableWidget.setRowCount(1)
headers = [
"Id", "Origen", "Destino", "Velocidad", "Color",
"Distancia"
]
self.ui.tableWidget.setHorizontalHeaderLabels(headers)
id = QTableWidgetItem(item.getId())
origen = QTableWidgetItem(item.getOrigen())
destino = QTableWidgetItem(item.getDestino())
velocidad = QTableWidgetItem(item.getVelocidad())
color = QTableWidgetItem(item.getColor())
distancia = QTableWidgetItem(item.getDistancia())
self.ui.tableWidget.setItem(0, 0, id)
self.ui.tableWidget.setItem(0, 1, origen)
self.ui.tableWidget.setItem(0, 2, destino)
self.ui.tableWidget.setItem(0, 3, velocidad)
self.ui.tableWidget.setItem(0, 4, color)
self.ui.tableWidget.setItem(0, 5, distancia)
encontrado = True
return
if not encontrado:
QMessageBox.warning(
self, "Atención",
f'La partícula con identificador "{id}" no fue encontrada')
@Slot()
def mostrarParticulasTodas(self):
row = 0
self.ui.tableWidget.clear()
self.ui.tableWidget.setRowCount(len(self.organizador.organizador))
headers = [
"Id", "Origen", "Destino", "Velocidad", "Color", "Distancia"
]
self.ui.tableWidget.setHorizontalHeaderLabels(headers)
for item in self.organizador.organizador:
id = QTableWidgetItem(item.getId())
origen = QTableWidgetItem(item.getOrigen())
destino = QTableWidgetItem(item.getDestino())
velocidad = QTableWidgetItem(item.getVelocidad())
color = QTableWidgetItem(item.getColor())
distancia = QTableWidgetItem(item.getDistancia())
self.ui.tableWidget.setItem(row, 0, id)
self.ui.tableWidget.setItem(row, 1, origen)
self.ui.tableWidget.setItem(row, 2, destino)
self.ui.tableWidget.setItem(row, 3, velocidad)
self.ui.tableWidget.setItem(row, 4, color)
self.ui.tableWidget.setItem(row, 5, distancia)
row += 1
@Slot()
def limpiar(self):
self.scene.clear()
self.ui.plainTextEdit.clear()
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.particulas = Admin_particulas()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.Agregar_Inicio_pushButton.clicked.connect(self.click_agregar_inicio)
self.ui.Agregar_Final_pushButton.clicked.connect(self.click_agregar_final)
self.ui.Mostrar_pushButton.clicked.connect(self.click_mostrar)
self.ui.Ordenar_ID_pushButton.clicked.connect(self.ordenar_ID)
self.ui.Ordenar_Distancia_pushButton.clicked.connect(self.ordenar_Distancia)
self.ui.Ordenar_Velocidad_pushButton.clicked.connect(self.ordenar_Velocidad)
self.ui.Dibujar_Grafo_pushButton.clicked.connect(self.dibujar_Grafo)
self.ui.Recorrido_Profundidad_pushButton.clicked.connect(self.recorrido_profundidad)
self.ui.Recorrido_Amplitud_pushButton.clicked.connect(self.recorrido_amplitud)
self.ui.actionAbrir_Archivo.triggered.connect(self.action_abrir_archivo)
self.ui.actionGuardar_Archivo.triggered.connect(self.action_guardar_archivo)
self.ui.Buscar_pushButton.clicked.connect(self.buscar_ID)
self.ui.Dibujar_pushButton.clicked.connect(self.dibujar_particulas)
self.ui.Limpiar_pushButton.clicked.connect(self.limpiar_pantalla)
self.scene = QGraphicsScene()
self.ui.graphicsView.setScene(self.scene)
def wheelEvent(self, event):
if event.delta() > 0:
self.ui.graphicsView.scale(1.2, 1.2)
else:
self.ui.graphicsView.scale(0.8, 0.8)
@Slot()
def ordenar_ID(self):
if len(self.particulas) == 0:
QMessageBox.warning(
self,
"Atención",
'No se han detectado partículas existentes'
)
else:
self.particulas.sort(1)
self.click_mostrar()
@Slot()
def ordenar_Distancia(self):
if len(self.particulas) == 0:
QMessageBox.warning(
self,
"Atención",
'No se han detectado partículas existentes'
)
else:
self.particulas.sort(2)
self.click_mostrar()
@Slot()
def ordenar_Velocidad(self):
if len(self.particulas) == 0:
QMessageBox.warning(
self,
"Atención",
'No se han detectado partículas existentes'
)
else:
self.particulas.sort(3)
self.click_mostrar()
@Slot()
def dibujar_Grafo(self):
if len(self.particulas) == 0:
QMessageBox.warning(
self,
"Atención",
'No se han detectado particulas existentes'
)
else:
grafo = dict()
for particula in self.particulas:
origen = (particula.origen_x, particula.origen_y)
destino = (particula.destino_x, particula.destino_y)
peso = particula.distancia
arista_o_d = (destino, peso)
arista_d_o = (origen, peso)
if origen in grafo:
grafo[origen].append(arista_o_d)
else:
grafo[origen] = [arista_o_d]
if destino in grafo:
grafo[destino].append(arista_d_o)
else:
grafo[destino] = [arista_d_o]
self.dibujar_particulas()
str = pformat(grafo, width=80, indent=1)
self.ui.Pantalla_Diccionarios.clear()
self.ui.Pantalla_Diccionarios.insertPlainText(str)
@Slot()
def recorrido_profundidad(self):
if len(self.particulas) == 0:
QMessageBox.warning(
self,
"Atención",
'No se han detectado particulas existentes'
)
else:
grafo = dict()
for particula in self.particulas:
origen = (particula.origen_x, particula.origen_y)
destino = (particula.destino_x, particula.destino_y)
peso = particula.distancia
arista_o_d = (destino, peso)
arista_d_o = (origen, peso)
if origen in grafo:
grafo[origen].append(arista_o_d)
else:
grafo[origen] = [arista_o_d]
if destino in grafo:
grafo[destino].append(arista_d_o)
else:
grafo[destino] = [arista_d_o]
keys = list(grafo.keys())
elementos = list(grafo.items())
visitados = [keys[0]]
pila = [keys[0]]
recorrido = []
while pila:
recorrido.append(pila[len(pila)-1])
i = 0
for key in keys:
if key == pila[len(pila)-1]:
break
i += 1
pila.pop()
for elemento in elementos[i][1]:
if not elemento[0] in visitados:
visitados.append(elemento[0])
pila.append(elemento[0])
self.ui.Pantalla_Recorridos.clear()
self.ui.Pantalla_Recorridos.insertPlainText("\n\n Recorrido Profundidad ")
for vertice in recorrido:
if vertice != recorrido[len(recorrido)-1]:
self.ui.Pantalla_Recorridos.insertPlainText(str(vertice)+", ")
else:
self.ui.Pantalla_Recorridos.insertPlainText(str(vertice))
self.mostrar_dict()
@Slot()
def recorrido_amplitud(self):
if len(self.particulas) == 0:
QMessageBox.warning(
self,
"Atención",
'No se han detectado particulas existentes'
)
else:
grafo = dict()
for particula in self.particulas:
origen = (particula.origen_x, particula.origen_y)
destino = (particula.destino_x, particula.destino_y)
peso = particula.distancia
arista_o_d = (destino, peso)
arista_d_o = (origen, peso)
if origen in grafo:
grafo[origen].append(arista_o_d)
else:
grafo[origen] = [arista_o_d]
if destino in grafo:
grafo[destino].append(arista_d_o)
else:
grafo[destino] = [arista_d_o]
keys = list(grafo.keys())
elementos = list(grafo.items())
visitados = [keys[0]]
cola = [keys[0]]
recorrido = []
while cola:
recorrido.append(cola[0])
i = 0
for key in keys:
if key == cola[0]:
break
i += 1
cola.pop(0)
for elemento in elementos[i][1]:
if not elemento[0] in visitados:
visitados.append(elemento[0])
cola.append(elemento[0])
self.ui.Pantalla_Recorridos.clear()
self.ui.Pantalla_Recorridos.insertPlainText("\n\n Recorrido Amplitud ")
for vertice in recorrido:
if vertice != recorrido[len(recorrido)-1]:
self.ui.Pantalla_Recorridos.insertPlainText(str(vertice)+", ")
else:
self.ui.Pantalla_Recorridos.insertPlainText(str(vertice))
self.mostrar_dict()
@Slot()
def mostrar_dict(self):
grafo = dict()
for particula in self.particulas:
origen = (particula.origen_x, particula.origen_y)
destino = (particula.destino_x, particula.destino_y)
peso = particula.distancia
arista_o_d = (destino, peso)
arista_d_o = (origen, peso)
if origen in grafo:
grafo[origen].append(arista_o_d)
else:
grafo[origen] = [arista_o_d]
if destino in grafo:
grafo[destino].append(arista_d_o)
else:
grafo[destino] = [arista_d_o]
str = pformat(grafo, width=80, indent=1)
self.ui.Pantalla_Diccionarios.clear()
self.ui.Pantalla_Diccionarios.insertPlainText(str)
@Slot()
def dibujar_particulas(self):
if len(self.particulas) == 0:
QMessageBox.warning(
self,
"Atención",
'No se han detectado particulas existentes'
)
else:
for particula in self.particulas:
pen = QPen()
color = QColor(particula.red, particula.green, particula.blue)
pen.setColor(color)
pen.setWidth(2)
self.scene.addEllipse(particula.origen_x, particula.origen_y, 3, 3, pen)
self.scene.addEllipse(particula.destino_x, particula.destino_y, 3, 3, pen)
self.scene.addLine(particula.origen_x + 3, particula.origen_y, particula.destino_x + 3, particula.destino_y, pen)
@Slot()
def limpiar_pantalla(self):
self.scene.clear()
@Slot()
def buscar_ID(self):
id = self.ui.Buscar_lineEdit.text()
encontrado = False
for particula in self.particulas:
if id == str(particula.id):
self.ui.Table.clear()
self.ui.Table.setRowCount(1)
ID_widget = QTableWidgetItem(str(particula.id))
Origen_X_widget = QTableWidgetItem(str(particula.origen_x))
Origen_Y_widget = QTableWidgetItem(str(particula.origen_y))
Destino_X_widget = QTableWidgetItem(str(particula.destino_x))
Destino_Y_widget = QTableWidgetItem(str(particula.destino_y))
Velocidad_widget = QTableWidgetItem(str(particula.velocidad))
Red_widget = QTableWidgetItem(str(particula.red))
Green_widget = QTableWidgetItem(str(particula.green))
Blue_widget = QTableWidgetItem(str(particula.blue))
Distancia_widget = QTableWidgetItem(str(particula.distancia))
self.ui.Table.setItem(0, 0, ID_widget)
self.ui.Table.setItem(0, 1, Origen_X_widget)
self.ui.Table.setItem(0, 2, Origen_Y_widget)
self.ui.Table.setItem(0, 3, Destino_X_widget)
self.ui.Table.setItem(0, 4, Destino_Y_widget)
self.ui.Table.setItem(0, 5, Velocidad_widget)
self.ui.Table.setItem(0, 6, Red_widget)
self.ui.Table.setItem(0, 7, Green_widget)
self.ui.Table.setItem(0, 8, Blue_widget)
self.ui.Table.setItem(0, 9, Distancia_widget)
encontrado = True
return
if not encontrado:
QMessageBox.warning(
self,
"Atención",
f'La particula con el ID "{id}" no fue encontrada'
)
@Slot()
def mostrar_tabla(self):
self.ui.Table.setColumnCount(10)
headers = ["ID", "Origen en X", "Origen en Y", "Destino en X", "Destino en Y", "Velocidad", "Red", "Green", "Blue", "Distancia"]
self.ui.Table.setHorizontalHeaderLabels(headers)
self.ui.Table.setRowCount(len(self.particulas))
row = 0
for particula in self.particulas:
ID_widget = QTableWidgetItem(str(particula.id))
Origen_X_widget = QTableWidgetItem(str(particula.origen_x))
Origen_Y_widget = QTableWidgetItem(str(particula.origen_y))
Destino_X_widget = QTableWidgetItem(str(particula.destino_x))
Destino_Y_widget = QTableWidgetItem(str(particula.destino_y))
Velocidad_widget = QTableWidgetItem(str(particula.velocidad))
Red_widget = QTableWidgetItem(str(particula.red))
Green_widget = QTableWidgetItem(str(particula.green))
Blue_widget = QTableWidgetItem(str(particula.blue))
Distancia_widget = QTableWidgetItem(str(particula.distancia))
self.ui.Table.setItem(row, 0, ID_widget)
self.ui.Table.setItem(row, 1, Origen_X_widget)
self.ui.Table.setItem(row, 2, Origen_Y_widget)
self.ui.Table.setItem(row, 3, Destino_X_widget)
self.ui.Table.setItem(row, 4, Destino_Y_widget)
self.ui.Table.setItem(row, 5, Velocidad_widget)
self.ui.Table.setItem(row, 6, Red_widget)
self.ui.Table.setItem(row, 7, Green_widget)
self.ui.Table.setItem(row, 8, Blue_widget)
self.ui.Table.setItem(row, 9, Distancia_widget)
row +=1
@Slot()
def action_abrir_archivo(self):
ubicacion = QFileDialog.getOpenFileName(
self,
'Abrir Archivo',
'.',
'JSON (*.json)'
)[0]
if self.particulas.abrir(ubicacion):
QMessageBox.information(
self,
"Éxito",
"Apertura exitosa del archivo en " + ubicacion
)
else:
QMessageBox.critical(
self,
"Error",
"Fallo al intentar abir el archivo en " + ubicacion
)
@Slot()
def action_guardar_archivo(self):
ubicacion = QFileDialog.getSaveFileName(
self,
'Guardar Archivo',
'.',
'JSON (*.json)'
)[0]
if self.particulas.guardar(ubicacion):
QMessageBox.information(
self,
"Éxito",
"Archivo creado correctamente en " + ubicacion
)
else:
QMessageBox.critical(
self,
"Error",
"No se pudo crear el archivo en " + ubicacion
)
@Slot()
def click_agregar_inicio(self):
Id = self.ui.ID_spinBox.value()
Origen_X = self.ui.Origen_X_spinBox.value()
Origen_Y = self.ui.Origen_Y_spinBox.value()
Destino_X = self.ui.Destino_X_spinBox.value()
Destino_Y = self.ui.Destino_Y_spinBox.value()
Velocidad = self.ui.Velocidad_spinBox.value()
Red = self.ui.Red_spinBox.value()
Green = self.ui.Green_spinBox.value()
Blue = self.ui.Blue_spinBox.value()
particula = Particula(Id, Origen_X, Origen_Y, Destino_X, Destino_Y, Velocidad, Red, Green, Blue)
self.particulas.agregar_inicio(particula)
@Slot()
def click_agregar_final(self):
Id = self.ui.ID_spinBox.value()
Origen_X = self.ui.Origen_X_spinBox.value()
Origen_Y = self.ui.Origen_Y_spinBox.value()
Destino_X = self.ui.Destino_X_spinBox.value()
Destino_Y = self.ui.Destino_Y_spinBox.value()
Velocidad = self.ui.Velocidad_spinBox.value()
Red = self.ui.Red_spinBox.value()
Green = self.ui.Green_spinBox.value()
Blue = self.ui.Blue_spinBox.value()
particula = Particula(Id, Origen_X, Origen_Y, Destino_X, Destino_Y, Velocidad, Red, Green, Blue)
self.particulas.agregar_final(particula)
@Slot()
def click_mostrar(self):
if len(self.particulas) == 0:
QMessageBox.warning(
self,
"Atención",
'No se han detectado partículas existentes'
)
else:
self.ui.Salida.clear()
self.ui.Salida.insertPlainText(str(self.particulas))
self.mostrar_tabla()
class QPOIViewer(QWidget):
"""
POI Viewer QWidget
"""
TAG_SPACING = 50
LEGEND_X = -50
LEGEND_Y = 0
LEGEND_WIDTH = 10
TRACE_FUNC_X = 0
TRACE_FUNC_Y = 0
TRACE_FUNC_WIDTH = 50
TRACE_FUNC_MINHEIGHT = 1000
TAB_HEADER_SIZE = 40
MAX_WINDOW_SIZE = 500
MARK_X = LEGEND_X
MARK_WIDTH = TRACE_FUNC_X - LEGEND_X + TRACE_FUNC_WIDTH
MARK_HEIGHT = 1
POIID_COLUMN = 0
CRASH_COLUMN = 1
CATEGORY_COLUMN = 2
DIAGNOSE_COLUMN = 3
COLUMN_FIELD = ['id', 'bbl', 'category', 'diagnose']
def __init__(self, workspace, parent=None, diagnose_handler=None):
super().__init__(parent=parent)
self.workspace = workspace
self._diagnose_handler = diagnose_handler
self.mark = None
self.legend = None
self.legend_height = 0
self.legend_img = None
self.trace_func_unit_height = 0
self.trace_func = None
self.trace_id = None
self.tabView = None
self.traceView = None
self.traceScene = None
self.POITraceTab = None
self.multiPOITab : QWidget = None
self.multiPOIList : QTableWidget = None
self.mark = None
self.curr_position = 0
self._use_precise_position = False
self._selected_traces = []
self._selected_poi = None
self._init_widgets()
self.selected_ins.am_subscribe(self._subscribe_select_ins)
self.poi_trace.am_subscribe(self._subscribe_set_trace)
self.multi_poi.am_subscribe(self._subscribe_add_poi)
self.multiPOIList.cellDoubleClicked.connect(self._on_cell_double_click)
self.multiPOIList.itemChanged.connect(self._on_diagnose_change)
#
# Forwarding properties
#
@property
def disasm_view(self):
"""
Get the current disassembly view (if there is one), or create a new one as needed.
"""
view = self.workspace.view_manager.current_view_in_category("disassembly")
if view is None:
view = self.workspace._get_or_create_disassembly_view()
return view
@property
def poi_trace(self):
return self.workspace.instance.poi_trace
@property
def multi_poi(self):
return self.workspace.instance.multi_poi
@property
def selected_ins(self):
return self.disasm_view.infodock.selected_insns
def _init_widgets(self):
_l.debug("QPOI Viewer Initiating")
self.tabView = QTabWidget() # QGraphicsView()
self.tabView.setContentsMargins(0, 0, 0, 0)
#
# POI trace Tab
#
self.POITraceTab = QWidget()
self.POITraceTab.setContentsMargins(0, 0, 0, 0)
singleLayout = QVBoxLayout()
singleLayout.setSpacing(0)
singleLayout.setContentsMargins(0, 0, 0, 0)
self.traceView = QGraphicsView()
self.traceScene = QGraphicsScene()
self.traceView.setScene(self.traceScene)
singleLayout.addWidget(self.traceView)
self.POITraceTab.setLayout(singleLayout)
#
# multiPOI Tab
#
self.multiPOITab = QMultiPOITab(self)
# self.multiPOITab = QWidget()
multiLayout = QVBoxLayout()
multiLayout.setSpacing(0)
multiLayout.setContentsMargins(0, 0, 0, 0)
self.multiPOIList = QTableWidget(0, 4) # row, col
self.multiPOIList.setHorizontalHeaderItem(0, QTableWidgetItem("ID"))
self.multiPOIList.setHorizontalHeaderItem(1, QTableWidgetItem("Crash Point"))
self.multiPOIList.setHorizontalHeaderItem(2, QTableWidgetItem("Tag"))
self.multiPOIList.setHorizontalHeaderItem(3, QTableWidgetItem("Diagnose"))
self.multiPOIList.horizontalHeader().setStretchLastSection(True)
self.multiPOIList.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeToContents)
self.multiPOIList.setSelectionBehavior(QAbstractItemView.SelectRows)
multiLayout.addWidget(self.multiPOIList)
self.multiPOITab.setLayout(multiLayout)
self.tabView.addTab(self.multiPOITab, "POI List")
self.tabView.addTab(self.POITraceTab, "POI Trace")
self.POI_TRACE = 1
self.MULTI_POI = 0
layout = QVBoxLayout()
layout.addWidget(self.tabView)
layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(layout)
self.show()
def _reset(self):
self.traceScene.clear() #clear items
self.mark = None
self.legend = None
self.legend_height = 0
self.trace_func = QGraphicsItemGroup()
self.trace_id = QGraphicsItemGroup()
self.traceScene.addItem(self.trace_func)
self.hide()
#
# Event
#
def _on_cell_double_click(self, row, _):
_l.debug("row %d is double clicked", row)
first_cell = self.multiPOIList.item(row, 0)
if first_cell is None:
return
poi_id = first_cell.text()
poi = self.multi_poi.am_obj.get_poi_by_id(poi_id)
if poi is None:
return
# sanity checks
if not isinstance(poi, dict):
return
if 'output' not in poi or not isinstance(poi['output'], dict):
return
if 'bbl_history' not in poi['output']:
return
trace = poi['output']['bbl_history']
if self._selected_poi != poi_id and trace is not None:
# render the trace
self.poi_trace.am_obj = TraceStatistics(self.workspace, trace, trace_id=poi_id)
# show the trace statistic in POI trace
self.poi_trace.am_event()
# show covered basic blocks and functions
self.multi_poi.am_obj.reload_heatmap(poi_id)
# redraw function view
view = self.workspace.view_manager.first_view_in_category('functions')
if view is not None:
view.refresh()
# redraw disassembly view
view = self.workspace.view_manager.first_view_in_category('disassembly')
if view is not None:
view.redraw_current_graph()
if trace is not None:
# switch to POI trace tab
self.tabView.setCurrentIndex(self.POI_TRACE)
self._selected_poi = poi_id
second_cell = self.multiPOIList.item(row, 1)
crash_addr = None
if second_cell is not None:
try:
crash_addr = int(second_cell.text(), 16)
except ValueError:
pass
if crash_addr is not None:
# show the crashing address
view = self.workspace.view_manager.first_view_in_category('disassembly')
if view is not None:
crash_func = self._get_func_from_addr(crash_addr)
if crash_func is not None:
self.workspace.on_function_selected(crash_func)
self.selected_ins.clear()
self.selected_ins.update([crash_addr])
self.selected_ins.am_event()
view.current_graph.show_instruction(crash_addr)
def _on_diagnose_change(self, item: QTableWidgetItem):
column = item.column()
row = item.row()
poi_id = self.multiPOIList.item(row, self.POIID_COLUMN).text()
content = item.text()
original_content = self.multi_poi.am_obj.get_content_by_id_column(poi_id, column)
_l.debug('updaing %s, content: %s, original: %s', poi_id, content, original_content)
if not self._is_identical(content, original_content):
updated_poi = self.multi_poi.update_poi(poi_id, column, content)
self._diagnose_handler.submit_updated_poi(poi_id, updated_poi)
def _subscribe_add_poi(self):
_l.debug('add a poi to multi poi list')
if self.multi_poi.am_none:
self.multi_poi.am_obj = MultiPOI(self.workspace)
poi_ids = self.multi_poi.am_obj.get_all_poi_ids()
self.multiPOIList.clearContents()
self._populate_poi_table(self.multiPOIList, poi_ids)
self.show()
def _subscribe_set_trace(self):
_l.debug('on set trace in poi trace viewer')
self._reset()
if self.poi_trace.am_none:
return
_l.debug('minheight: %d, count: %d', self.TRACE_FUNC_MINHEIGHT,
self.poi_trace.count)
if self.poi_trace.count <= 0:
_l.warning("No valid addresses found in trace to show. Check base address offsets?")
self.poi_trace.am_obj = None
self.poi_trace.am_event()
return
if self.TRACE_FUNC_MINHEIGHT < self.poi_trace.count * 15:
self.trace_func_unit_height = 15
show_func_tag = True
else:
self.trace_func_unit_height = self.TRACE_FUNC_MINHEIGHT / self.poi_trace.count
show_func_tag = True
self.legend_height = int(self.poi_trace.count * self.trace_func_unit_height)
self._show_trace_func(show_func_tag)
self._show_legend()
self._set_mark_color()
self._refresh_multi_list()
# boundingSize = self.traceScene.itemsBoundingRect().width()
# windowSize = boundingSize
# if boundingSize > self.MAX_WINDOW_SIZE:
# windowSize = self.MAX_WINDOW_SIZE
# self.traceScene.setSceneRect(self.traceScene.itemsBoundingRect()) #resize
# if windowSize > self.width():
# self.setMinimumWidth(windowSize)
self.show()
def _subscribe_select_ins(self, **kwargs): # pylint: disable=unused-argument
if self.poi_trace.am_none:
return
if self.mark is not None:
for i in self.mark.childItems():
self.mark.removeFromGroup(i)
self.traceScene.removeItem(i)
self.traceScene.removeItem(self.mark)
self.mark = QGraphicsItemGroup()
self.traceScene.addItem(self.mark)
if self.selected_ins:
addr = next(iter(self.selected_ins))
positions = self.poi_trace.get_positions(addr)
if positions: #if addr is in list of positions
# handle case where insn was selected from disas view
if not self._use_precise_position:
self.curr_position = positions[0] - self.poi_trace.count
for p in positions:
color = self._get_mark_color(p, self.poi_trace.count)
y = self._get_mark_y(p)
if p == self.poi_trace.count + self.curr_position: #add thicker line for 'current' mark
self.mark.addToGroup(self.traceScene.addRect(self.MARK_X, y, self.MARK_WIDTH,
self.MARK_HEIGHT*4,
QPen(QColor('black')), QBrush(color)))
else:
self.mark.addToGroup(self.traceScene.addRect(self.MARK_X, y, self.MARK_WIDTH,
self.MARK_HEIGHT, QPen(color), QBrush(color)))
self.traceScene.update() #force redraw of the traceScene
self.scroll_to_position(self.curr_position)
def _get_func_from_addr(self, addr):
if self.workspace.instance.cfg.am_none:
return None
bbl = self.workspace.instance.cfg.get_any_node(addr, anyaddr=True)
function_addr = bbl.function_address
return self.workspace.instance.project.kb.functions.get(function_addr)
def _populate_poi_table(self, view, poi_ids):
view.clearContents()
view.setRowCount(len(poi_ids))
row = 0 #start after label row
for poi_id in poi_ids:
poi = self.multi_poi.am_obj.get_poi_by_id(poi_id)
_l.debug('populating poi: %s', poi)
category = poi['category']
output = poi['output']
crash_addr = output['bbl']
if crash_addr is not None:
crash = hex(crash_addr)
else:
crash = None
diagnose = output.get('diagnose')
_l.debug('poi_ids: %s', poi_ids)
_l.debug('current poi id: %s', poi_id)
self._set_item(view, row, self.POIID_COLUMN, poi_id, editable=False)
self._set_item(view, row, self.CRASH_COLUMN, crash, editable=True)
self._set_item(view, row, self.CATEGORY_COLUMN, category, editable=True)
self._set_item(view, row, self.DIAGNOSE_COLUMN, diagnose, editable=True)
row += 1
_l.debug('poi_ids: %s', poi_ids)
@staticmethod
def _set_item(view, row, column, text, editable=True):
if not text:
text = ""
item = QTableWidgetItem(text)
if not editable:
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
view.setItem(row, column, item)
def _refresh_multi_list(self):
multiPOI = self.multi_poi.am_obj
trace_ids = multiPOI.get_all_poi_ids()
self.multiPOIList.clearContents()
self._populate_poi_table(self.multiPOIList, trace_ids)
if self._selected_traces and self.multiPOIList.rowCount() > 0:
self.multiPOIList.item(0, 0).setSelected(True)
self.multiPOIList.item(0, 1).setSelected(True)
else:
for row in range(self.multiPOIList.rowCount()):
item = self.multiPOIList.item(row, 0)
inputItem = self.multiPOIList.item(row, 1)
if item.text() in self._selected_traces:
item.setSelected(True)
inputItem.setSelected(True)
self.multi_poi.am_event()
def _on_tab_change(self):
multiPOI = self.multi_poi.am_obj
if self.tabView.currentIndex() == self.MULTI_POI:
multiPOI.is_active_tab = True
self._refresh_multi_list()
elif self.tabView.currentIndex() == self.POI_TRACE:
multiPOI = self.multi_poi.am_obj
multiPOI.is_active_tab = False
# self._show_trace_ids()
def scroll_to_position(self, position):
relative_pos = self.poi_trace.count + position
y_offset = self._get_mark_y(relative_pos)
scrollValue = 0
if y_offset > 0.5 * self.traceView.size().height():
scrollValue = y_offset - 0.5 * self.traceView.size().height()
scrollValue = min(scrollValue, self.traceView.verticalScrollBar().maximum())
self.traceView.verticalScrollBar().setValue(scrollValue)
self._use_precise_position = False
def jump_next_insn(self):
# for some reason indexing is done backwards
if self.curr_position + self.poi_trace.count < self.poi_trace.count - 1:
self.curr_position += 1
self._use_precise_position = True
bbl_addr = self.poi_trace.get_bbl_from_position(self.curr_position)
func = self.poi_trace.get_func_from_position(self.curr_position)
self._jump_bbl(func, bbl_addr)
def jump_prev_insn(self):
if self.curr_position + self.poi_trace.count > 0:
self.curr_position -= 1
self._use_precise_position = True
bbl_addr = self.poi_trace.get_bbl_from_position(self.curr_position)
func = self.poi_trace.get_func_from_position(self.curr_position)
self._jump_bbl(func, bbl_addr)
def mousePressEvent(self, event):
button = event.button()
pos = self._to_logical_pos(event.pos())
if button == Qt.LeftButton and self.tabView.currentIndex() == self.POI_TRACE and self._at_legend(pos):
func = self._get_func_from_y(pos.y())
bbl_addr = self._get_bbl_from_y(pos.y())
self._use_precise_position = True
self.curr_position = self._get_position(pos.y())
self._jump_bbl(func, bbl_addr)
def _jump_bbl(self, func, bbl_addr):
disasm_view = self.disasm_view
if disasm_view is not None:
all_insn_addrs = self.workspace.instance.project.factory.block(bbl_addr).instruction_addrs
# TODO: replace this with am_events perhaps?
self.workspace.on_function_selected(func)
self.selected_ins.clear()
self.selected_ins.update(all_insn_addrs)
self.selected_ins.am_event()
# TODO: this ought to happen automatically as a result of the am_event
disasm_view.current_graph.show_instruction(bbl_addr)
def _get_mark_color(self, i, total):
relative_gradient_pos = i * 1000 // total
return self.legend_img.pixelColor(self.LEGEND_WIDTH // 2,
relative_gradient_pos)
def _get_mark_y(self, i):
return self.TRACE_FUNC_Y + self.trace_func_unit_height * i
def _show_trace_func(self, show_func_tag=True):
x = self.TRACE_FUNC_X
y = self.TRACE_FUNC_Y
prev_name = None
for position in self.poi_trace.trace_func:
func_name = position.func_name
color = self.poi_trace.get_func_color(func_name)
self.trace_func.addToGroup(self.traceScene.addRect(x, y,
self.TRACE_FUNC_WIDTH, self.trace_func_unit_height,
QPen(color), QBrush(color)))
if show_func_tag is True and func_name != prev_name:
tag = self.traceScene.addText(func_name, QFont("Source Code Pro", 7))
tag.setPos(x + self.TRACE_FUNC_WIDTH +
self.TAG_SPACING, y -
tag.boundingRect().height() // 2)
self.trace_func.addToGroup(tag)
anchor = self.traceScene.addLine(
self.TRACE_FUNC_X + self.TRACE_FUNC_WIDTH, y,
x + self.TRACE_FUNC_WIDTH + self.TAG_SPACING, y)
self.trace_func.addToGroup(anchor)
prev_name = func_name
y += self.trace_func_unit_height
@staticmethod
def _make_legend_gradient(x1, y1, x2, y2):
gradient = QLinearGradient(x1, y1, x2, y2)
gradient.setColorAt(0.0, Qt.red)
gradient.setColorAt(0.4, Qt.yellow)
gradient.setColorAt(0.6, Qt.green)
gradient.setColorAt(0.8, Qt.blue)
gradient.setColorAt(1.0, Qt.darkBlue)
return gradient
def _show_legend(self):
pen = QPen(Qt.transparent)
gradient = self._make_legend_gradient(self.LEGEND_X, self.LEGEND_Y,
self.LEGEND_X, self.LEGEND_Y + self.legend_height)
brush = QBrush(gradient)
self.legend = self.traceScene.addRect(self.LEGEND_X, self.LEGEND_Y,
self.LEGEND_WIDTH, self.legend_height, pen, brush)
reference_gradient = self._make_legend_gradient(0, 0, self.LEGEND_WIDTH, 1000)
base_img = QImage(self.LEGEND_WIDTH, 1000, QImage.Format.Format_ARGB32)
p = QPainter(base_img)
p.fillRect(base_img.rect(),reference_gradient)
self.legend_img = base_img #reference shade
def _set_mark_color(self):
_l.debug('trace count: %d', self.poi_trace.count)
for p in range(self.poi_trace.count):
color = self._get_mark_color(p, self.poi_trace.count)
self.poi_trace.set_mark_color(p, color)
def _at_legend(self, pos):
x = pos.x()
y = pos.y()
return self.TRACE_FUNC_X + self.LEGEND_X < x < self.traceView.width() and \
self.TRACE_FUNC_Y < y < self.TRACE_FUNC_Y + self.legend_height
def _to_logical_pos(self, pos):
x_offset = self.traceView.horizontalScrollBar().value()
y_offset = self.traceView.verticalScrollBar().value()
return QPoint(pos.x() + x_offset, pos.y() + y_offset)
def _get_position(self, y):
y_relative = y - self.legend_height - self.TAB_HEADER_SIZE
return int(y_relative // self.trace_func_unit_height)
def _get_bbl_from_y(self, y):
position = self._get_position(y)
return self.poi_trace.get_bbl_from_position(position)
def _get_func_from_y(self, y):
position = self._get_position(y)
func = self.poi_trace.get_func_from_position(position)
return func
#
# Context Menu
#
def menu_add_empty_poi(self):
_l.debug('adding a new empty poi item')
if self._diagnose_handler.get_image_id() is None:
QMessageBox.warning(self.workspace.main_window,
"No CHESS target available",
"No angr project is loaded, or you did not associate the current project with a CHESS "
"target. Please load a binary and associate it with a CHESS target before creating "
"POIs.")
return
poi_id = str(uuid4())
if self.multi_poi.am_none:
self.multi_poi.am_obj = MultiPOI(self.workspace)
empty_poi = deepcopy(EMPTY_POI)
self.multi_poi.add_poi(poi_id, empty_poi)
self.multi_poi.am_event()
self._diagnose_handler.submit_updated_poi(poi_id, empty_poi)
def menu_remove_poi(self):
items = self.multiPOIList.selectedItems()
row = items.pop().row()
poi_id = self.multiPOIList.item(row, 0).text()
_l.debug('removing ID %s', poi_id)
self.multi_poi.remove_poi(poi_id)
self.multi_poi.am_event()
@staticmethod
def _is_identical(content, original_content):
if content == original_content:
return True
if content == '' and original_content is None:
return True
try:
if int(content, 16) == int(original_content):
return True
except (TypeError, ValueError):
return False
return False
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.administrador = Administrador()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.agregar_final_pushButton.clicked.connect(self.click_agregar)
self.ui.agregar_inicio_pushButton.clicked.connect(
self.click_agregar_inicio)
self.ui.mostrar_pushButton.clicked.connect(self.click_mostrar)
self.ui.actionAbrir.triggered.connect(self.action_abrir_archivo)
self.ui.actionGuardar.triggered.connect(self.action_guardar_archivo)
self.ui.mostrar_tabla_pushButton.clicked.connect(self.mostrar_tabla)
self.ui.buscar_pushButton.clicked.connect(self.buscar_id)
self.ui.dibujar.clicked.connect(self.dibujar)
self.ui.limpiar.clicked.connect(self.limpiar)
self.scene = QGraphicsScene()
self.ui.graphicsView.setScene(self.scene)
def wheelEvent(self, event):
if event.delta() > 0:
self.ui.graphicsView.scale(1.2, 1.2)
else:
self.ui.graphicsView.scale(0.8, 0.8)
@Slot()
def dibujar(self):
pen = QPen()
pen.setWidth(2)
for particula in self.administrador:
r = particula.red
g = particula.green
b = particula.blue
color = QColor(r, g, b)
pen.setColor(color)
self.scene.addEllipse(particula.origen_x, particula.origen_y, 3, 3,
pen)
self.scene.addEllipse(particula.destino_x, particula.destino_y, 3,
3, pen)
self.scene.addLine(particula.origen_x + 3, particula.origen_y + 3,
particula.destino_x, particula.destino_y, pen)
@Slot()
def limpiar(self):
self.scene.clear()
@Slot()
def buscar_id(self):
id = self.ui.buscar_lineEdit.text()
encontrado = False
for particula in self.administrador:
if id == particula.id:
self.ui.tabla.clear()
self.ui.tabla.setRowCount(1)
id_widget = QTableWidgetItem(particula.id)
origen_x_widget = QTableWidgetItem(str(particula.origen_x))
origen_y_widget = QTableWidgetItem(str(particula.origen_y))
destino_x_widget = QTableWidgetItem(str(particula.destino_x))
destino_y_widget = QTableWidgetItem(str(particula.destino_y))
velocidad_widget = QTableWidgetItem(particula.velocidad)
red_widget = QTableWidgetItem(str(particula.red))
green_widget = QTableWidgetItem(str(particula.green))
blue_widget = QTableWidgetItem(str(particula.blue))
distancia_widget = QTableWidgetItem(str(particula.distancia))
self.ui.tabla.setItem(0, 0, id_widget)
self.ui.tabla.setItem(0, 1, origen_x_widget)
self.ui.tabla.setItem(0, 2, origen_y_widget)
self.ui.tabla.setItem(0, 3, destino_x_widget)
self.ui.tabla.setItem(0, 4, destino_y_widget)
self.ui.tabla.setItem(0, 5, velocidad_widget)
self.ui.tabla.setItem(0, 6, red_widget)
self.ui.tabla.setItem(0, 7, green_widget)
self.ui.tabla.setItem(0, 8, blue_widget)
self.ui.tabla.setItem(0, 9, distancia_widget)
encontrado = True
return
if not encontrado:
QMessageBox.warning(
self, "Atención",
f'La particula con el id "{id}" no fue encontrada')
@Slot()
def mostrar_tabla(self):
self.ui.tabla.setColumnCount(10)
headers = [
"Id", "Origen_x", "Origen_y", "Destino_x", "Destino_y",
"Velocidad", "Red", "Green", "Blue", "Distancia"
]
self.ui.tabla.setHorizontalHeaderLabels(headers)
self.ui.tabla.setRowCount(len(self.administrador))
row = 0
for particula in self.administrador:
id_widget = QTableWidgetItem(particula.id)
origen_x_widget = QTableWidgetItem(str(particula.origen_x))
origen_y_widget = QTableWidgetItem(str(particula.origen_y))
destino_x_widget = QTableWidgetItem(str(particula.destino_x))
destino_y_widget = QTableWidgetItem(str(particula.destino_y))
velocidad_widget = QTableWidgetItem(particula.velocidad)
red_widget = QTableWidgetItem(str(particula.red))
green_widget = QTableWidgetItem(str(particula.green))
blue_widget = QTableWidgetItem(str(particula.blue))
distancia_widget = QTableWidgetItem(str(particula.distancia))
self.ui.tabla.setItem(row, 0, id_widget)
self.ui.tabla.setItem(row, 1, origen_x_widget)
self.ui.tabla.setItem(row, 2, origen_y_widget)
self.ui.tabla.setItem(row, 3, destino_x_widget)
self.ui.tabla.setItem(row, 4, destino_y_widget)
self.ui.tabla.setItem(row, 5, velocidad_widget)
self.ui.tabla.setItem(row, 6, red_widget)
self.ui.tabla.setItem(row, 7, green_widget)
self.ui.tabla.setItem(row, 8, blue_widget)
self.ui.tabla.setItem(row, 9, distancia_widget)
row += 1
@Slot()
def action_abrir_archivo(self):
ubicacion = QFileDialog.getOpenFileName(self, 'Abrir Archivo', '.',
'JSON (*.json)')[0]
if self.administrador.abrir(ubicacion):
QMessageBox.information(self, "Éxito",
"Se abrió el archivo" + ubicacion)
else:
QMessageBox.critical(self, "Error",
"Error al abrir el archivo" + ubicacion)
@Slot()
def action_guardar_archivo(self):
ubicacion = QFileDialog.getSaveFileName(self, 'Guardar Archivo', '.',
'JSON (*.json)')[0]
print(ubicacion)
if self.administrador.guardar(ubicacion):
QMessageBox.information(self, "Éxito",
"Se pudo crear el archivo" + ubicacion)
else:
QMessageBox.critical(self, "Error", "No se pudo crear el archivo")
@Slot()
def click_mostrar(self):
#self.administrador.mostrar()
self.ui.salida.clear()
self.ui.salida.insertPlainText(str(self.administrador))
@Slot()
def click_agregar(self):
id = self.ui.id_lineEdit.text()
origen_x = self.ui.origen_x_spinBox.value()
origen_y = self.ui.origen_y_spinBox.value()
destino_x = self.ui.destino_x_spinBox.value()
destino_y = self.ui.destino_y_spinBox.value()
velocidad = self.ui.velocidad_lineEdit.text()
red = self.ui.red_spinBox.value()
green = self.ui.green_spinBox.value()
blue = self.ui.blue_spinBox.value()
particula = Particula(id, origen_x, origen_y, destino_x, destino_y,
velocidad, red, green, blue)
self.administrador.agregar_final(particula)
#print (id, origen_x, origen_y, destino_x, destino_y, velocidad, red, green, blue)
#self.ui.salida.insertPlainText (id + str(origen_x) + str(origen_y) + str(destino_x) + str(destino_y) +
#velocidad + str(red) + str(green) + str(blue))
@Slot()
def click_agregar_inicio(self):
id = self.ui.id_lineEdit.text()
origen_x = self.ui.origen_x_spinBox.value()
origen_y = self.ui.origen_y_spinBox.value()
destino_x = self.ui.destino_x_spinBox.value()
destino_y = self.ui.destino_y_spinBox.value()
velocidad = self.ui.velocidad_lineEdit.text()
red = self.ui.red_spinBox.value()
green = self.ui.green_spinBox.value()
blue = self.ui.blue_spinBox.value()
particula = Particula(id, origen_x, origen_y, destino_x, destino_y,
velocidad, red, green, blue)
self.administrador.agregar_inicio(particula)
class Apartment2D(object):
def __init__(self, ui):
#self.ui = ui
#self.ui.guiDlg.resize(QDesktopWidget().availableGeometry(self).size() * 0.6)
self.scene = QGraphicsScene()
self.dim = {
"HMIN": -3000,
"VMIN": -4000,
"WIDTH": 6000,
"HEIGHT": 8000
}
self.scene.setSceneRect(self.dim['HMIN'], self.dim['VMIN'],
self.dim['WIDTH'], self.dim['HEIGHT'])
ui.graphicsView.setScene(self.scene)
self.boxes = []
#self.ui.graphicsView.setViewport(QGLWidget())
ui.graphicsView.scale(1, -1)
ui.graphicsView.fitInView(self.scene.sceneRect(), Qt.KeepAspectRatio)
ui.graphicsView.setTransformationAnchor(QGraphicsView.NoAnchor)
ui.graphicsView.setResizeAnchor(QGraphicsView.NoAnchor)
self.persons = {}
self.pixmapSize = (0, 0)
self.initializeWorld()
def addPerson(self, pos, angle=0, color=-1, size=100):
colors = QColor.colorNames()
color = colors[random.randint(0,
len(colors) -
1)] if color == -1 else color
pos = [pos[0], pos[2]] if len(pos) > 2 else pos
p = self.scene.addEllipse(pos[0] - size // 2,
pos[1] - size // 2,
size,
size,
pen=QPen(QColor(color), 20),
brush=QBrush(color=QColor(color)))
# pixmap
pixmap = QPixmap("person.png").scaled(600, 300)
self.pixmapSize = (pixmap.width() / 2, pixmap.height() / 2)
pixItem = QGraphicsPixmapItem(pixmap)
pixItem.setTransformOriginPoint(pixItem.boundingRect().center())
pixItem.setZValue(20)
self.scene.addItem(pixItem)
self.persons[p] = pixItem
return p
def movePerson(self, elipse, pos, size=100):
#elipse.setPos(pos[0], pos[1])
pos = [pos[0], pos[2]] if len(pos) > 2 else pos
color = elipse.pen().color()
self.scene.addEllipse(pos[0] - size // 2,
pos[1] - size // 2,
size,
size,
pen=QPen(QColor(color), 20),
brush=QBrush(color=QColor(color)))
# pixmap
self.persons[elipse].setPos(pos[0] - self.pixmapSize[0],
pos[1] - self.pixmapSize[1])
# change rotation value when provided
self.persons[elipse].setRotation(180)
def wheelEvent(self, event):
zoomInFactor = 1.15
zoomOutFactor = 1 / zoomInFactor
# Zoom
if event.delta() > 0:
zoomFactor = zoomInFactor
else:
zoomFactor = zoomOutFactor
self.graphicsView.scale(zoomFactor, zoomFactor)
def initializeWorld(self):
with open('autonomy.json', 'r') as f:
world = json.load(f)
#load dimensions
dim = world["dimensions"]
x_offset = -3200
y_offset = 1850
# load roundtables
# for k,v in world["roundTables"].items():
# print(v)
# box = self.scene.addEllipse(QRectF(-v[2]// 2, -v[3]// 2, v[2], v[3]), QPen(QColor("Khaki")), QBrush(QColor("Khaki")));
# box.setPos(v[4]+x_offset, v[5]+x_offset);
# self.boxes.append(box)
# load tables
for k, v in world["tables"].items():
box = self.scene.addRect(
QRectF(-v[2] // 2, -v[3] // 2, v[2], v[3]),
QPen(QColor("SandyBrown")), QBrush(QColor("SandyBrown")))
box.setPos(v[4] + x_offset, v[5] + y_offset)
box.setTransformOriginPoint(box.mapFromScene(QPointF(0, 0)))
box.setRotation(v[6])
self.boxes.append(box)
# load walls
for k, v in world['walls'].items():
box = self.scene.addRect(
QRectF(-v[2] // 2, -v[3] // 2, v[2], v[3]),
QPen(QColor("Brown")), QBrush(QColor("Brown")))
box.setPos(v[4] + x_offset, v[5] + y_offset)
box.setTransformOriginPoint(box.mapFromScene(QPointF(0, 0)))
box.setRotation(v[6])
self.boxes.append(box)
# }
# //load points
# QVariantMap points = mainMap[QString("points")].toMap();
# for (auto &t : points)
# {
# QVariantList object = t.toList();
# auto box = scene.addRect(QRectF(-object[2].toFloat() / 2, -object[3].toFloat() / 2, object[2].toFloat(), object[3].toFloat()), QPen(QColor("Brown")), QBrush(QColor("Brown")));
# box->setPos(object[4].toFloat()+x_offset, object[5].toFloat()+y_offset);
# boxes.push_back(box);
# }
# //load boxes
# QVariantMap cajas = mainMap[QString("boxes")].toMap();
# for (auto &t : cajas)
# {
# QVariantList object = t.toList();
# auto box = scene.addRect(QRectF(-object[2].toFloat() / 2, -object[3].toFloat() / 2, object[2].toFloat(), object[3].toFloat()), QPen(QColor("Brown")), QBrush(QColor("Orange")));
# box->setPos(object[4].toFloat()+x_offset, object[5].toFloat()+y_offset);
# //box->setPos(object[4].toFloat(), object[5].toFloat());
# //box->setRotation(object[6].toFloat()*180/M_PI2);
# box->setFlag(QGraphicsItem::ItemIsMovable);
# boxes.push_back(box);
# }
# QTransform t;
# //t.translate(3200, -1850);
# t.rotate(-90);
# //t.translate(-3200, 1850);
# for(auto &item : boxes)
# {
# item->setPos(t.map(item->pos()));
# item->setRotation(item->rotation() + 90);
# item->setPos(item->pos() + QPointF(1850,3200));
# }
# /////////////
# //AXIS
self.scene.addLine(0, 0, 400, 0, QPen(QBrush(QColor("red")), 20))
self.scene.addLine(0, 0, 0, 400, QPen(QBrush(QColor("blue")), 20))
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.particulas = Particulas()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.agregar_final_pushButton.clicked.connect(self.click_agregar)
self.ui.agregar_inicio_pushButton.clicked.connect(
self.click_agregar_inicio)
self.ui.mostrar_pushButton.clicked.connect(self.click_mostrar)
self.ui.actionAbrir.triggered.connect(self.click_abrir_archivo)
self.ui.actionGuardar.triggered.connect(self.click_guardar_archivo)
self.ui.mostrar_tabla_pushButton.clicked.connect(self.mostrar_tabla)
self.ui.buscar_pushButton.clicked.connect(self.buscar_id)
self.scene = QGraphicsScene()
self.ui.graphicsView.setScene(self.scene)
self.ui.dibujar_pushButton.clicked.connect(self.dibujar)
self.ui.limpiar_pushButton.clicked.connect(self.limpiar)
self.ui.ordenar_id_pushButton.clicked.connect(self.ordenar_id)
self.ui.ordenar_distancia_pushButton.clicked.connect(
self.ordenar_distancia)
self.ui.ordenar_velocidad_pushButton.clicked.connect(
self.ordenar_velocidad)
self.ui.actionGrafo.triggered.connect(self.mostrar_grafos)
self.ui.action_busqueda.triggered.connect(self.busqueda)
@Slot()
def busqueda(self):
self.particulas.peso()
self.ui.salida.clear()
origenes = (int(self.ui.origenx_lineEdit.text()),
int(self.ui.origeny_lineEdit.text()))
recorrido = self.particulas.recorrido_profundidad(origenes)
print("Profundidad")
self.ui.salida.insertPlainText("Profundidad" + '\n')
for i in recorrido:
self.ui.salida.insertPlainText(str(i) + '\n')
print(i)
recorrido_2 = self.particulas.recorrido_amplitud(origenes)
print("\nAmplitud")
self.ui.salida.insertPlainText('\n' "Amplitud" + '\n')
for i in recorrido_2:
self.ui.salida.insertPlainText(str(i) + '\n')
print(i)
def wheelEvent(self, event):
if event.delta() > 0:
self.ui.graphicsView.scale(1.2, 1.2)
else:
self.ui.graphicsView.scale(0.8, 0.8)
@Slot()
def mostrar_grafos(self):
self.ui.salida.clear()
self.ui.salida.insertPlainText(self.particulas.mostrar_diccionario())
@Slot()
def ordenar_id(self):
self.particulas.ordenarid()
@Slot()
def ordenar_distancia(self):
self.particulas.ordenardistancia()
@Slot()
def ordenar_velocidad(self):
self.particulas.ordenarvelocidad()
@Slot()
def dibujar(self):
for particula in self.particulas:
pen = QPen()
pen.setWidth(1)
c_red = particula.red
c_green = particula.green
c_blue = particula.blue
color = QColor(c_red, c_green, c_blue)
pen.setColor(color)
c_origenx = particula.origenx
c_origeny = particula.origeny
c_destinox = particula.destinox
c_destinoy = particula.destinoy
self.scene.addEllipse(c_origenx, c_origeny, .8, .8, pen)
self.scene.addEllipse(c_destinox, c_destinoy, .8, .8, pen)
self.scene.addLine(c_origenx, c_origeny, c_destinox, c_destinoy,
pen)
@Slot()
def limpiar(self):
self.scene.clear()
@Slot()
def buscar_id(self):
ident = self.ui.buscar_lineEdit.text()
encontrado = False
for particula in self.particulas:
if ident == str(particula.identificacion):
self.ui.tabla.clear()
self.ui.tabla.setRowCount(1)
identificacion_widget = QTableWidgetItem(
str(particula.identificacion))
origenx_widget = QTableWidgetItem(str(particula.origenx))
origeny_widget = QTableWidgetItem(str(particula.origeny))
destinox_widget = QTableWidgetItem(str(particula.destinox))
destinoy_widget = QTableWidgetItem(str(particula.destinoy))
velocidad_widget = QTableWidgetItem(str(particula.velocidad))
red_widget = QTableWidgetItem(str(particula.red))
blue_widget = QTableWidgetItem(str(particula.blue))
green_widget = QTableWidgetItem(str(particula.green))
d_widget = QTableWidgetItem(str(particula.d))
self.ui.tabla.setItem(0, 0, identificacion_widget)
self.ui.tabla.setItem(0, 1, origenx_widget)
self.ui.tabla.setItem(0, 2, origeny_widget)
self.ui.tabla.setItem(0, 3, destinox_widget)
self.ui.tabla.setItem(0, 4, destinoy_widget)
self.ui.tabla.setItem(0, 5, velocidad_widget)
self.ui.tabla.setItem(0, 6, red_widget)
self.ui.tabla.setItem(0, 7, blue_widget)
self.ui.tabla.setItem(0, 8, green_widget)
self.ui.tabla.setItem(0, 9, d_widget)
encontrado = True
return
if not encontrado:
QMessageBox.warning(
self, "Atención",
f'La particula con el id"{ident}"no fue encontrada')
@Slot()
def mostrar_tabla(self):
self.ui.tabla.setColumnCount(10)
headers = [
"ID", "Origen en x", "Origen en y", "Destino en x", "Destino en y",
"Velocidad", "Red", "Blue", "Green", "Distancia"
]
self.ui.tabla.setHorizontalHeaderLabels(headers)
self.ui.tabla.setRowCount(len(self.particulas))
row = 0
for particula in self.particulas:
identificacion_widget = QTableWidgetItem(
str(particula.identificacion))
origenx_widget = QTableWidgetItem(str(particula.origenx))
origeny_widget = QTableWidgetItem(str(particula.origeny))
destinox_widget = QTableWidgetItem(str(particula.destinox))
destinoy_widget = QTableWidgetItem(str(particula.destinoy))
velocidad_widget = QTableWidgetItem(str(particula.velocidad))
red_widget = QTableWidgetItem(str(particula.red))
blue_widget = QTableWidgetItem(str(particula.blue))
green_widget = QTableWidgetItem(str(particula.green))
d_widget = QTableWidgetItem(str(particula.d))
self.ui.tabla.setItem(row, 0, identificacion_widget)
self.ui.tabla.setItem(row, 1, origenx_widget)
self.ui.tabla.setItem(row, 2, origeny_widget)
self.ui.tabla.setItem(row, 3, destinox_widget)
self.ui.tabla.setItem(row, 4, destinoy_widget)
self.ui.tabla.setItem(row, 5, velocidad_widget)
self.ui.tabla.setItem(row, 6, red_widget)
self.ui.tabla.setItem(row, 7, blue_widget)
self.ui.tabla.setItem(row, 8, green_widget)
self.ui.tabla.setItem(row, 9, d_widget)
row += 1
@Slot()
def click_abrir_archivo(self):
ubicacion = QFileDialog.getOpenFileName(self, 'Abrir Archivo', '.',
'JSON (*.json)')[0]
if self.particulas.abrir(ubicacion):
QMessageBox.information(self, "Éxito",
"Se abrió el archivo" + ubicacion)
else:
QMessageBox.critical(self, "Error",
"Error al abrir el archivo" + ubicacion)
@Slot()
def click_guardar_archivo(self):
ubicacion = QFileDialog.getSaveFileName(self, 'Guadar Archivo', '.',
'JSON(*.json)')[0]
print(ubicacion)
if self.particulas.guardar(ubicacion):
QMessageBox.information(self, "Éxito",
"Se pudo crear el archivo" + ubicacion)
else:
QMessageBox.critical(self, "Error",
"No se pudo crear el archivo" + ubicacion)
@Slot()
def click_mostrar(self):
self.ui.salida.clear()
self.ui.salida.insertPlainText(str(self.particulas))
@Slot()
def click_agregar(self):
identificacion = int(self.ui.id_lineEdit.text())
origenx = int(self.ui.origenx_lineEdit.text())
origeny = int(self.ui.origeny_lineEdit.text())
destinox = int(self.ui.destinox_lineEdit.text())
destinoy = int(self.ui.destinoy_lineEdit.text())
velocidad = int(self.ui.velocidad_lineEdit.text())
red = int(self.ui.red_lineEdit.text())
green = int(self.ui.green_lineEdit.text())
blue = int(self.ui.blue_lineEdit.text())
particula = Particula(identificacion, origenx, origeny, destinox,
destinoy, velocidad, red, green, blue)
self.particulas.agregar_final(particula)
@Slot()
def click_agregar_inicio(self):
identificacion = int(self.ui.id_lineEdit.text())
origenx = int(self.ui.origenx_lineEdit.text())
origeny = int(self.ui.origeny_lineEdit.text())
destinox = int(self.ui.destinox_lineEdit.text())
destinoy = int(self.ui.destinoy_lineEdit.text())
velocidad = int(self.ui.velocidad_lineEdit.text())
red = int(self.ui.red_lineEdit.text())
green = int(self.ui.green_lineEdit.text())
blue = int(self.ui.blue_lineEdit.text())
particula = Particula(identificacion, origenx, origeny, destinox,
destinoy, velocidad, red, green, blue)
self.particulas.agregar_inicio(particula)
class AddItem(UsesQApplication):
'''Tests for QGraphicsScene.add*'''
qapplication = True
def setUp(self):
#Acquire resources
super(AddItem, self).setUp()
self.scene = QGraphicsScene()
# While the scene does not inherits from QWidget, requires
# an application to make the internals work.
def tearDown(self):
#Release resources
del self.scene
super(AddItem, self).tearDown()
def testEllipse(self):
#QGraphicsScene.addEllipse
item = self.scene.addEllipse(100, 100, 100, 100)
self.assertTrue(isinstance(item, QGraphicsEllipseItem))
def testLine(self):
#QGraphicsScene.addLine
item = self.scene.addLine(100, 100, 200, 200)
self.assertTrue(isinstance(item, QGraphicsLineItem))
def testPath(self):
#QGraphicsScene.addPath
item = self.scene.addPath(QPainterPath())
self.assertTrue(isinstance(item, QGraphicsPathItem))
def testPixmap(self):
#QGraphicsScene.addPixmap
item = self.scene.addPixmap(QPixmap())
self.assertTrue(isinstance(item, QGraphicsPixmapItem))
def testPolygon(self):
#QGraphicsScene.addPolygon
points = [QPointF(0, 0), QPointF(100, 100), QPointF(0, 100)]
item = self.scene.addPolygon(QPolygonF(points))
self.assertTrue(isinstance(item, QGraphicsPolygonItem))
def testRect(self):
#QGraphicsScene.addRect
item = self.scene.addRect(100, 100, 100, 100)
self.assertTrue(isinstance(item, QGraphicsRectItem))
def testSimpleText(self):
#QGraphicsScene.addSimpleText
item = self.scene.addSimpleText('Monty Python 42')
self.assertTrue(isinstance(item, QGraphicsSimpleTextItem))
def testText(self):
#QGraphicsScene.addText
item = self.scene.addText('Monty Python 42')
self.assertTrue(isinstance(item, QGraphicsTextItem))
def testWidget(self):
#QGraphicsScene.addWidget
# XXX: printing some X11 error when using under PyQt4
item = self.scene.addWidget(QPushButton())
self.assertTrue(isinstance(item, QGraphicsProxyWidget))
class MainWindow(QMainWindow):
def __init__(self):
super().__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.scene = QGraphicsScene()
#self.scene.setSceneRect(0,500)
self.ui.graphicsView.setScene(self.scene)
self.pen = QPen()
self.pen.setColor(QColor(0, 0, 0))
self.pen.setWidth(1)
self.lista = []
self.listaMenor = []
self.capturador = Capturador()
self.ui.pushButton.clicked.connect(self.click)
self.ui.pushButton_2.clicked.connect(self.mostrar)
self.ui.actionGuardar.triggered.connect(self.guardar)
self.ui.actionAbrir_2.triggered.connect(self.abrir)
self.ui.actionMostar.triggered.connect(self.mostarParticulasPuntos)
self.ui.actionPuntos_Cercanos.triggered.connect(self.puntos_cercanos)
self.ui.pushButton_3.clicked.connect(self.ordenar_velocidad)
self.ui.pushButton_4.clicked.connect(self.ordenar_distancia)
@Slot()
def puntos_cercanos(self):
for i in range(len(self.lista) - 1):
particulaMenor = self.lista[i + 1]
for j in range(len(self.lista) - 1):
particula2 = self.lista[j]
if (j == 0):
auxDistancia = math.sqrt(
pow((int(particula2['x']) -
int(particulaMenor['x'])), 2) +
pow((int(particula2['y']) -
int(particulaMenor['y'])), 2))
aux = {'origen': particulaMenor, 'destino': particula2}
if ((math.sqrt(
pow((int(particula2['x']) -
int(particulaMenor['x'])), 2) +
pow((int(particula2['y']) -
int(particulaMenor['y'])), 2)) < auxDistancia)
and (particulaMenor != particula2)):
auxDistancia = math.sqrt(
pow((int(particula2['x']) -
int(particulaMenor['x'])), 2) +
pow((int(particula2['y']) -
int(particulaMenor['y'])), 2))
aux = {'origen': particulaMenor, 'destino': particula2}
self.listaMenor.append(aux)
self.dibujar()
@Slot()
def mostarParticulasPuntos(self):
self.scene.clear()
self.scene = QGraphicsScene()
# self.scene.setSceneRect(0,500)
self.ui.graphicsView.setScene(self.scene)
self.pen = QPen()
self.pen.setColor(QColor(0, 0, 0))
self.pen.setWidth(1)
self.capturador.ordenar_velocidad()
for particula in self.capturador.lista:
self.lista.append({
'x': particula.origenX,
'y': particula.origenY,
'color': {
'red': particula.red,
'green': particula.green,
'blue': particula.blue
}
})
self.lista.append({
'x': particula.destinoX,
'y': particula.destinoY,
'color': {
'red': particula.red,
'green': particula.green,
'blue': particula.blue
}
})
self.ui.plainTextEdit.insertPlainText(str(particula))
self.pen.setColor(
QColor(particula.red, particula.green, particula.blue))
self.scene.addEllipse(
particula.origenX, particula.origenY, 5, 5, self.pen,
QBrush(
QColor(particula.red, 10, particula.green,
particula.blue)))
@Slot()
def ordenar_velocidad(self):
self.scene.clear()
self.scene = QGraphicsScene()
#self.scene.setSceneRect(0,500)
self.ui.graphicsView.setScene(self.scene)
self.pen = QPen()
self.pen.setColor(QColor(0, 0, 0))
self.pen.setWidth(1)
self.capturador.ordenar_velocidad()
y = 0
for particula in self.capturador.lista:
self.ui.plainTextEdit.insertPlainText(str(particula))
self.pen.setColor(
QColor(particula.red, particula.green, particula.blue))
self.scene.addLine(0, y, particula.distancia, y, self.pen)
y = y + 2
def dibujar(self):
self.scene.clear()
self.scene = QGraphicsScene()
# self.scene.setSceneRect(0,500)
self.ui.graphicsView.setScene(self.scene)
self.pen = QPen()
self.pen.setColor(QColor(0, 0, 0))
self.pen.setWidth(1)
self.capturador.ordenar_distancia()
for new in self.listaMenor:
self.scene.addEllipse(
new['origen']['x'], new['origen']['y'], 5, 5, self.pen,
QBrush(
QColor(new['origen']['color']['red'], 10,
new['origen']['color']['green'],
new['origen']['color']['blue'])))
self.pen.setColor(
QColor(new['origen']['color']['red'],
new['origen']['color']['green'],
new['origen']['color']['blue']))
self.scene.addLine(new['origen']['x'], new['origen']['y'],
new['destino']['x'], new['destino']['y'],
self.pen)
@Slot()
def ordenar_distancia(self):
self.scene.clear()
self.scene = QGraphicsScene()
#self.scene.setSceneRect(0,500)
self.ui.graphicsView.setScene(self.scene)
self.pen = QPen()
self.pen.setColor(QColor(0, 0, 0))
self.pen.setWidth(1)
self.capturador.ordenar_distancia()
y = 0
for particula in self.capturador.lista:
self.ui.plainTextEdit.insertPlainText(str(particula))
self.pen.setColor(
QColor(particula.red, particula.green, particula.blue))
self.scene.addLine(0, y, particula.distancia, y, self.pen)
y = y + 2
@Slot()
def guardar(self):
self.scene = QGraphicsScene()
#self.scene.setSceneRect(0,500)
self.ui.graphicsView.setScene(self.scene)
self.pen = QPen()
self.pen.setColor(QColor(0, 0, 0))
self.pen.setWidth(1)
file = QFileDialog.getSaveFileName(self, 'Guardar archivo...', '.',
'JSON (*.json)')
print(file)
self.capturador.guardar(file[0], self.pen, self.scene)
@Slot()
def abrir(self):
file = QFileDialog.getOpenFileName(self, 'Abrir archivo', '.',
'JSON (*.json)')
self.capturador.recuperar(file[0])
@Slot()
def mostrar(self):
self.scene.clear()
self.scene.addLine(0, 0, 499, 0, self.pen)
y = 0
for particula in self.capturador.lista:
self.ui.plainTextEdit.insertPlainText(str(particula))
self.pen.setColor(
QColor(particula.red, particula.green, particula.blue))
self.scene.addLine(0, y, particula.distancia, y, self.pen)
y = y + 2
#for particula in self.capturador.lista:
# self.ui.plainTextEdit.insertPlainText(str(particula))
# self.pen.setColor(QColor(particula.red, particula.green, particula.blue))
# self.scene.addEllipse(particula.origenX, particula.origenY, 5, 5, self.pen, QBrush(QColor(particula.red, 10,particula.green, particula.blue)))
#self.scene.addLine(particula.origenX, particula.origenY, particula.destinoX, particula.destinoY, self.pen)
#self.paqueteria.mostrar()
@Slot()
def click(self):
id = self.ui.lineEdit.text()
origenX = self.ui.lineEdit_2.text()
origenY = self.ui.lineEdit_6.text()
destinoX = self.ui.lineEdit_3.text()
destinoY = self.ui.lineEdit_7.text()
velocidad = self.ui.lineEdit_4.text()
red = self.ui.lineEdit_5.text()
green = self.ui.lineEdit_8.text()
blue = self.ui.lineEdit_9.text()
print(id, origenX, origenY, destinoX, destinoY, velocidad, red, green,
blue)
partiula = Particula()
partiula.id = id
partiula.origenX = int(origenX)
partiula.origenY = int(origenY)
partiula.destinoX = int(destinoX)
partiula.destinoY = int(destinoY)
partiula.distancia = math.sqrt(
pow((int(destinoX) - int(origenX)), 2) +
pow((int(destinoY) - int(origenY)), 2))
partiula.red = int(red)
partiula.green = int(green)
partiula.blue = int(blue)
partiula.velocidad = int(velocidad)
self.capturador.agregar(partiula)
msg = QMessageBox.information(
self, 'Exito', 'Se agrego paquete con exito'
) #Ventana de mensaje de la libreria QMessageBox
self.ui.lineEdit.clear() #Limpiar campos
self.ui.lineEdit_2.clear()
self.ui.lineEdit_3.clear()
self.ui.lineEdit_4.clear()
self.ui.lineEdit_5.clear()
self.ui.lineEdit_6.clear()
self.ui.lineEdit_7.clear()
self.ui.lineEdit_8.clear()
self.ui.lineEdit_9.clear()
class Test(QWidget):
def __init__(self):
# super() でスーパークラスのインスタンスメソッドを呼び出す
# super(MainWindow, self).__init__(parent)
super().__init__()
self.ui = Ui_Dialog()
#self.ui = MainWindow()
self.ui.setupUi(self)
self.view = self.ui.graphicsView
self.view.setAlignment(Qt.AlignTop | Qt.AlignLeft)
self.scene = QGraphicsScene()
# アイテムの名前設定
self.ui.comboBox.addItem("{}".format(comp_offset_x[0]))
self.ui.comboBox.addItem("{}".format(comp_offset_x[1]))
self.ui.comboBox.addItem("{}".format(comp_offset_x[2]))
self.ui.comboBox.addItem("{}".format(comp_offset_x[3]))
self.ui.comboBox.addItem("{}".format(comp_offset_x[4]))
self.ui.comboBox.addItem("{}".format(comp_offset_x[5]))
self.ui.comboBox.addItem("{}".format(comp_offset_x[6]))
self.ui.comboBox.addItem("{}".format(comp_offset_x[7]))
self.ui.comboBox.addItem("{}".format(comp_offset_x[8]))
self.ui.comboBox.addItem("{}".format(comp_offset_x[9]))
self.ui.comboBox.addItem("{}".format(comp_offset_x[10]))
self.ui.comboBox.setCurrentIndex(2)
self.ui.comboBox_2.addItem("{}".format(comp_offset_green[0]))
self.ui.comboBox_2.addItem("{}".format(comp_offset_green[1]))
self.ui.comboBox_2.addItem("{}".format(comp_offset_green[2]))
self.ui.comboBox_2.addItem("{}".format(comp_offset_green[3]))
self.ui.comboBox_2.addItem("{}".format(comp_offset_green[4]))
self.ui.comboBox_2.addItem("{}".format(comp_offset_green[5]))
self.ui.comboBox_2.addItem("{}".format(comp_offset_green[6]))
self.ui.comboBox_2.addItem("{}".format(comp_offset_green[7]))
self.ui.comboBox_2.addItem("{}".format(comp_offset_green[8]))
self.ui.comboBox_2.addItem("{}".format(comp_offset_green[9]))
self.ui.comboBox_2.addItem("{}".format(comp_offset_green[10]))
self.ui.comboBox_2.setCurrentIndex(6)
self.ui.lineEdit.setText('10.0')
self.ui.pushButton.clicked.connect(
lambda: self.buttonClicked("Hello world"))
def buttonClicked(self, str):
print("{} {} {}".format(str, self.ui.comboBox.currentIndex(),
self.ui.comboBox_2.currentIndex()))
offset_x = comp_offset_x[self.ui.comboBox.currentIndex()]
offset_green = comp_offset_green[self.ui.comboBox_2.currentIndex()]
gain = float(self.ui.lineEdit.text())
self.data = [
colorBarRGB(x * 0.001, offset_x, offset_green, gain)
for x in range(1000)
]
for i in range(1000):
# QPenの設定
pen = QPen(
QColor(self.data[i][0], self.data[i][1], self.data[i][2]), 1,
Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin)
self.scene.addLine(i, 0, i, 80, pen)
self.view.setScene(self.scene)
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
self.clickToColor(event)
def clickToColor(self, event):
self.px = event.pos().x()
self.py = event.pos().y()
#print('px:{px}, py:{py}'.format(px=self.px, py=self.py))
#print(type(self.px))
view_geo = self.view.geometry()
#print('view_geo{}'.format(view_geo))
self.cp_x = self.px - view_geo.left()
self.cp_y = self.py - view_geo.top()
print('cp_x:{cp_x}, cp_y:{cp_y}'.format(cp_x=self.cp_x,
cp_y=self.cp_y))
#print('data size:{}'.format(len(self.data)))
#view_margin = self.view.alignment()
#print('view_margin:{}'.format(view_margin))
selectLine = self.view.itemAt(self.cp_x, self.cp_y)
if not selectLine is None:
select_color = selectLine.pen().color()
r = select_color.red()
g = select_color.green()
b = select_color.blue()
input_value = self.cp_x / 1000
self.ui.label_R.setText(str(r))
self.ui.label_G.setText(str(g))
self.ui.label_B.setText(str(b))
self.ui.label_input.setText(str(input_value))
self.update()
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.particulas = Particulas()
self.grafo = Grafo()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.finalcap.clicked.connect(self.click_agregarfinal)
self.ui.Iniciocap.clicked.connect(self.click_agregarinicio)
self.ui.Mostrar.clicked.connect(self.click_mostrar)
self.ui.OrigenX.valueChanged.connect(self.setValue)
self.ui.OrigenY.valueChanged.connect(self.setValue)
self.ui.DestinoX.valueChanged.connect(self.setValue)
self.ui.DestinoY.valueChanged.connect(self.setValue)
self.ui.Verde.valueChanged.connect(self.setValue)
self.ui.Rojo.valueChanged.connect(self.setValue)
self.ui.Azul.valueChanged.connect(self.setValue)
self.ui.actionAbrir.triggered.connect(self.action_abrir_archivo)
self.ui.actionGuardar.triggered.connect(self.action_guardar_archivo)
self.ui.actionPor_ID.triggered.connect(self.action_ordenarid)
self.ui.actionVelocidad.triggered.connect(self.action_ordenarvelocidad)
self.ui.actionDistancia.triggered.connect(self.action_ordenardistancia)
self.ui.actionGrafo.triggered.connect(self.action_transformaragrafo)
self.ui.Mostrartabla_push.clicked.connect(self.Mostrar_tabla)
self.ui.Buscar_push.clicked.connect(self.buscar_id)
self.ui.Dibujarpush.clicked.connect(self.dibujar)
self.ui.Limpiarpush.clicked.connect(self.limpiar)
self.scene = QGraphicsScene()
self.ui.graphicsView.setScene(self.scene)
def wheelEvent(self, event):
if event.delta() > 0:
self.ui.graphicsView.scale(1.2, 1.2)
else:
self.ui.graphicsView.scale(0.8, 0.8)
@Slot()
def Mostrar_tabla(self):
self.ui.Tabla.setColumnCount(10)
headers = ["Id", "origen_x", "origen_y", "destino_x", "destino_y", "velocidad","rojo", "verde","azul", "distancia"]
self.ui.Tabla.setHorizontalHeaderLabels(headers)
self.ui.Tabla.setRowCount(len(self.particulas))
row = 0
for particula in self.particulas:
Id_widget = QTableWidgetItem(str(particula.Id))
origen_x_widget = QTableWidgetItem(str(particula.origen_x))
origen_y_widget = QTableWidgetItem(str(particula. origen_y))
destino_x_widget = QTableWidgetItem(str(particula.destino_x))
destino_y_widget = QTableWidgetItem(str(particula.destino_y))
velocidad_widget = QTableWidgetItem(str(particula.velocidad))
rojo_widget = QTableWidgetItem(str(particula.rojo))
verde_widget = QTableWidgetItem(str(particula.verde))
azul_widget = QTableWidgetItem(str(particula.azul))
distancia_widget = QTableWidgetItem(str(particula.distancia))
self.ui.Tabla.setItem(row, 0, Id_widget)
self.ui.Tabla.setItem(row, 1, origen_x_widget)
self.ui.Tabla.setItem(row, 2, origen_y_widget)
self.ui.Tabla.setItem(row, 3, destino_x_widget)
self.ui.Tabla.setItem(row, 4, destino_y_widget)
self.ui.Tabla.setItem(row, 5, velocidad_widget)
self.ui.Tabla.setItem(row, 6, rojo_widget)
self.ui.Tabla.setItem(row, 7, verde_widget)
self.ui.Tabla.setItem(row, 8, azul_widget)
self.ui.Tabla.setItem(row, 9, distancia_widget)
row += 1
@Slot()
def buscar_id(self):
headers = ["Id", "origen_x", "origen_y", "destino_x", "destino_y", "velocidad","rojo", "verde","azul", "distancia"]
Id = self.ui.LineadeBusqueda.text()
encontrado = False
for particula in self.particulas:
if Id == str(particula.Id):
self.ui.Tabla.clear()
self.ui.Tabla.setRowCount(1)
self.ui.Tabla.setColumnCount(10)
self.ui.Tabla.setHorizontalHeaderLabels(headers)
Id_widget = QTableWidgetItem(str(particula.Id))
origen_x_widget = QTableWidgetItem(str(particula.origen_x))
origen_y_widget = QTableWidgetItem(str(particula. origen_y))
destino_x_widget = QTableWidgetItem(str(particula.destino_x))
destino_y_widget = QTableWidgetItem(str(particula.destino_y))
velocidad_widget = QTableWidgetItem(str(particula.velocidad))
rojo_widget = QTableWidgetItem(str(particula.rojo))
verde_widget = QTableWidgetItem(str(particula.verde))
azul_widget = QTableWidgetItem(str(particula.azul))
distancia_widget = QTableWidgetItem(str(particula.distancia))
self.ui.Tabla.setItem(0, 0, Id_widget)
self.ui.Tabla.setItem(0, 1, origen_x_widget)
self.ui.Tabla.setItem(0, 2, origen_y_widget)
self.ui.Tabla.setItem(0, 3, destino_x_widget)
self.ui.Tabla.setItem(0, 4, destino_y_widget)
self.ui.Tabla.setItem(0, 5, velocidad_widget)
self.ui.Tabla.setItem(0, 6, rojo_widget)
self.ui.Tabla.setItem(0, 7, verde_widget)
self.ui.Tabla.setItem(0, 8, azul_widget)
self.ui.Tabla.setItem(0, 9, distancia_widget)
encontrado = True
return
if not encontrado:
QMessageBox.warning(
self,
"Atencion",
f'La particula con ID = "{Id}" no fue encontrado'
)
@Slot()
def action_abrir_archivo(self):
# print('Abrir Archivo')
ubicacion = QFileDialog.getOpenFileName(
self,
'Abrir Archivo',
'.',
'JSON (*.json)'
)[0]
if self.particulas.abrir(ubicacion):
QMessageBox.information(
self,
"Exito",
"Se abrió el archivo " + ubicacion
)
else:
QMessageBox.critical(
self,
"Error",
"Error al abrir el archivo " + ubicacion
)
@Slot()
def action_guardar_archivo(self):
#print('Guardar Archivo')
ubicacion = QFileDialog.getSaveFileName(
self,
'Guardar Archivo',
'.',
'JSON (*.json)'
)[0]
print(ubicacion)
if self.particulas.guardar(ubicacion):
QMessageBox.information(
self,
"Exito",
"Se pudo crear el archivo " + ubicacion
)
else:
QMessageBox.critical(
self,
"Error",
"No se pudo crear el archivo " + ubicacion
)
@Slot()
def click_agregarfinal(self):
Id = self.ui.ID.value()
Ox = self.ui.OrigenX.value()
Oy = self.ui.OrigenY.value()
Dx = self.ui.DestinoX.value()
Dy = self.ui.DestinoY.value()
Vel = self.ui.Velocidad.value()
Red = self.ui.Rojo.value()
Green = self.ui.Verde.value()
Blue = self.ui.Azul.value()
particula = Particula(Id,Ox,Oy,Dx,Dy,Vel,Red,Green,Blue)
self.particulas.agregar_final(particula)
#print(particula)
#self.ui.salida.insertPlainText(str(IDD)+str(Ox)+str(Oy)+str(Dx)+str(Dy)+str(Vel)+str(Red)+str(Blue)+str(Green))
@Slot()
def click_agregarinicio(self):
Id = self.ui.ID.value()
Ox = self.ui.OrigenX.value()
Oy = self.ui.OrigenY.value()
Dx = self.ui.DestinoX.value()
Dy = self.ui.DestinoY.value()
Vel = self.ui.Velocidad.value()
Red = self.ui.Rojo.value()
Green = self.ui.Verde.value()
Blue = self.ui.Azul.value()
particula = Particula(Id,Ox,Oy,Dx,Dy,Vel,Red,Blue,Green)
self.particulas.agregar_inicio(particula)
#print(IDD,Ox,Oy,Dx,Dy,Vel,Red,Blue,Green)
#self.ui.salida.insertPlainText(str(IDD)+str(Ox)+str(Oy)+str(Dx)+str(Dy)+str(Vel)+str(Red)+str(Blue)+str(Green))
@Slot()
def click_mostrar(self):
# self.particulas.mostrar()
self.ui.salida.clear()
self.ui.salida.insertPlainText(str(self.particulas))
@Slot()
def setValue(self,valor):
self.ui.NumAct.clear()
self.ui.NumAct.insertPlainText(str(valor))
@Slot()
def dibujar(self):
pen = QPen()
pen.setWidth(3)
for particula in self.particulas:
r= particula.rojo
g= particula.verde
b= particula.azul
color = QColor(r, g, b)
pen.setColor(color)
pox= particula.origen_x
poy= particula.origen_y
pdx= particula.destino_x
pdy= particula.destino_y
self.scene.addEllipse(pox, poy, 3, 3, pen)
self.scene.addEllipse(pdx, pdy, 3, 3, pen)
self.scene.addLine(pox+3, poy+1, pdx+2, pdy+1, pen)
@Slot()
def limpiar(self):
self.scene.clear()
@Slot()
def action_ordenarid(self):
self.particulas.__sortid__()
@Slot()
def action_ordenarvelocidad(self):
self.particulas.__sortvel__()
@Slot()
def action_ordenardistancia(self):
self.particulas.__sortdis__()
@Slot()
def action_transformaragrafo(self):
for particula in self.particulas:
self.grafo.__Add__(particula.origen_x,particula.origen_y,particula.destino_x,
particula.destino_y)
self.grafo.Mostrargrafo()
self.ui.salida.clear()
self.ui.salida.insertPlainText(str(pformat(self.grafo.Grafo, width=40, indent=1)))
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.particulas = Particula_libreria()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.agregar_inicio_pushButton.clicked.connect(
self.click_agregar_inicio)
self.ui.agregar_final_pushButton.clicked.connect(
self.click_agregar_final)
self.ui.mostrar_pushButton.clicked.connect(self.click_mostrar)
self.ui.actionAbrir.triggered.connect(self.action_abrir_archivo)
self.ui.actionGuardar.triggered.connect(self.action_guardar_archivo)
self.ui.mostar_tabla_pushButton_2.clicked.connect(self.mostrar_tabla)
self.ui.buscar_pushButton.clicked.connect(self.buscar_particula)
self.ui.dibujar.clicked.connect(self.dibujar)
self.ui.limpiar.clicked.connect(self.limpiar)
self.scene = QGraphicsScene()
self.ui.graphicsView.setScene(self.scene)
self.ui.actionPor_id.triggered.connect(self.ordenar_id)
self.ui.actionPor_distancia.triggered.connect(self.ordenar_distancia)
self.ui.actionPor_velocidad.triggered.connect(self.ordenar_velocidad)
self.ui.actionMostrar_diccionario.triggered.connect(
self.mostrar_diccionario)
self.ui.actionBusqueda_de_Profundidad.triggered.connect(self.recorrido)
def wheelEvent(self, event):
if event.delta() > 0:
self.ui.graphicsView.scale(1.2, 1.2)
else:
self.ui.graphicsView.scale(0.8, 0.8)
@Slot()
def recorrido(self):
self.particulas.bye_peso()
self.ui.salida.clear()
origenes = (self.ui.origen_x_spinBox.value(),
self.ui.origen_y_spinBox.value())
recorrido = self.particulas.mostrar_recorrido(origenes)
print("Profundidad")
self.ui.salida.insertPlainText("Profundidad" + '\n')
for i in recorrido:
self.ui.salida.insertPlainText(str(i) + '\n')
print(i)
recorrido_2 = self.particulas.mostrar_recorrido_2(origenes)
print("\nAmplitud")
self.ui.salida.insertPlainText('\n' "Amplitud" + '\n')
for i in recorrido_2:
self.ui.salida.insertPlainText(str(i) + '\n')
print(i)
@Slot()
def mostrar_diccionario(self):
self.ui.salida.clear()
self.ui.salida.insertPlainText(self.particulas.mostrar_diccionario())
QMessageBox.information(self, "Exito", "Se imprimio el diccionario ")
@Slot()
def ordenar_id(self):
self.ui.tabla.clear()
self.ui.tabla.clear()
headers = [
"Id", "Origen_x", "Origen_y", "Destino_x", "Destino_y",
"Velocidad", "Red", "Green", "Blue", "Distancia"
]
self.ui.tabla.setHorizontalHeaderLabels(headers)
self.ui.tabla.setRowCount(len(self.particulas))
particulas = []
for particula in self.particulas:
particulas.append(particula)
particulas.sort(key=lambda particula: particula.Id, reverse=False)
row = 0
for particula in particulas:
id_widget = QTableWidgetItem(str(particula.Id))
origen_x_widget = QTableWidgetItem(str(particula.origen_x))
origen_y_widget = QTableWidgetItem(str(particula.origen_y))
destino_x_widget = QTableWidgetItem(str(particula.destino_x))
destino_y_widget = QTableWidgetItem(str(particula.destino_y))
velocidad_widget = QTableWidgetItem(str(particula.velocidad))
rojo_widget = QTableWidgetItem(str(particula.rojo))
verde_widget = QTableWidgetItem(str(particula.verde))
azul_widget = QTableWidgetItem(str(particula.azul))
distancia_widget = QTableWidgetItem(str(particula.distancia))
self.ui.tabla.setItem(row, 0, id_widget)
self.ui.tabla.setItem(row, 1, origen_x_widget)
self.ui.tabla.setItem(row, 2, origen_y_widget)
self.ui.tabla.setItem(row, 3, destino_x_widget)
self.ui.tabla.setItem(row, 4, destino_y_widget)
self.ui.tabla.setItem(row, 5, velocidad_widget)
self.ui.tabla.setItem(row, 6, rojo_widget)
self.ui.tabla.setItem(row, 7, verde_widget)
self.ui.tabla.setItem(row, 8, azul_widget)
self.ui.tabla.setItem(row, 9, distancia_widget)
row += 1
for particula in particulas:
self.ui.salida.insertPlainText(str(particula))
@Slot()
def ordenar_distancia(self):
self.ui.tabla.clear()
self.ui.tabla.clear()
headers = [
"Id", "Origen_x", "Origen_y", "Destino_x", "Destino_y",
"Velocidad", "Red", "Green", "Blue", "Distancia"
]
self.ui.tabla.setHorizontalHeaderLabels(headers)
self.ui.tabla.setRowCount(len(self.particulas))
particulas = []
for particula in self.particulas:
particulas.append(particula)
particulas.sort(key=lambda particula: particula.distancia,
reverse=True)
row = 0
for particula in particulas:
id_widget = QTableWidgetItem(str(particula.Id))
origen_x_widget = QTableWidgetItem(str(particula.origen_x))
origen_y_widget = QTableWidgetItem(str(particula.origen_y))
destino_x_widget = QTableWidgetItem(str(particula.destino_x))
destino_y_widget = QTableWidgetItem(str(particula.destino_y))
velocidad_widget = QTableWidgetItem(str(particula.velocidad))
rojo_widget = QTableWidgetItem(str(particula.rojo))
verde_widget = QTableWidgetItem(str(particula.verde))
azul_widget = QTableWidgetItem(str(particula.azul))
distancia_widget = QTableWidgetItem(str(particula.distancia))
self.ui.tabla.setItem(row, 0, id_widget)
self.ui.tabla.setItem(row, 1, origen_x_widget)
self.ui.tabla.setItem(row, 2, origen_y_widget)
self.ui.tabla.setItem(row, 3, destino_x_widget)
self.ui.tabla.setItem(row, 4, destino_y_widget)
self.ui.tabla.setItem(row, 5, velocidad_widget)
self.ui.tabla.setItem(row, 6, rojo_widget)
self.ui.tabla.setItem(row, 7, verde_widget)
self.ui.tabla.setItem(row, 8, azul_widget)
self.ui.tabla.setItem(row, 9, distancia_widget)
row += 1
for particula in particulas:
self.ui.salida.insertPlainText(str(particula))
@Slot()
def ordenar_velocidad(self):
self.ui.tabla.clear()
self.ui.tabla.clear()
headers = [
"Id", "Origen_x", "Origen_y", "Destino_x", "Destino_y",
"Velocidad", "Red", "Green", "Blue", "Distancia"
]
self.ui.tabla.setHorizontalHeaderLabels(headers)
self.ui.tabla.setRowCount(len(self.particulas))
particulas = []
for particula in self.particulas:
particulas.append(particula)
particulas.sort(key=lambda particula: particula.velocidad,
reverse=False)
row = 0
for particula in particulas:
id_widget = QTableWidgetItem(str(particula.Id))
origen_x_widget = QTableWidgetItem(str(particula.origen_x))
origen_y_widget = QTableWidgetItem(str(particula.origen_y))
destino_x_widget = QTableWidgetItem(str(particula.destino_x))
destino_y_widget = QTableWidgetItem(str(particula.destino_y))
velocidad_widget = QTableWidgetItem(str(particula.velocidad))
rojo_widget = QTableWidgetItem(str(particula.rojo))
verde_widget = QTableWidgetItem(str(particula.verde))
azul_widget = QTableWidgetItem(str(particula.azul))
distancia_widget = QTableWidgetItem(str(particula.distancia))
self.ui.tabla.setItem(row, 0, id_widget)
self.ui.tabla.setItem(row, 1, origen_x_widget)
self.ui.tabla.setItem(row, 2, origen_y_widget)
self.ui.tabla.setItem(row, 3, destino_x_widget)
self.ui.tabla.setItem(row, 4, destino_y_widget)
self.ui.tabla.setItem(row, 5, velocidad_widget)
self.ui.tabla.setItem(row, 6, rojo_widget)
self.ui.tabla.setItem(row, 7, verde_widget)
self.ui.tabla.setItem(row, 8, azul_widget)
self.ui.tabla.setItem(row, 9, distancia_widget)
row += 1
for particula in particulas:
self.ui.salida.insertPlainText(str(particula))
@Slot()
def dibujar(self):
pen = QPen()
pen.setWidth(2)
for particula in self.particulas:
r = particula.rojo
g = particula.verde
b = particula.azul
color = QColor(r, g, b)
pen.setColor(color)
self.scene.addEllipse(particula.origen_x, particula.origen_y, 4, 4,
pen)
self.scene.addEllipse(particula.destino_x, particula.destino_y, 4,
4, pen)
self.scene.addLine(particula.origen_x, particula.origen_y,
particula.destino_x, particula.destino_y, pen)
@Slot()
def limpiar(self):
self.scene.clear()
@Slot()
def buscar_particula(self):
ID = self.ui.buscar_lineEdit.text()
encontrado = False
for particula in self.particulas:
if ID == particula.Id:
self.ui.tabla.clear()
self.ui.tabla.setRowCount(1)
id_widget = QTableWidgetItem(str(particula.Id))
origen_x_widget = QTableWidgetItem(str(particula.origen_x))
origen_y_widget = QTableWidgetItem(str(particula.origen_y))
destino_x_widget = QTableWidgetItem(str(particula.destino_x))
destino_y_widget = QTableWidgetItem(str(particula.destino_y))
velocidad_widget = QTableWidgetItem(str(particula.velocidad))
rojo_widget = QTableWidgetItem(str(particula.rojo))
verde_widget = QTableWidgetItem(str(particula.verde))
azul_widget = QTableWidgetItem(str(particula.azul))
distancia_widget = QTableWidgetItem(str(particula.distancia))
self.ui.tabla.setItem(0, 0, id_widget)
self.ui.tabla.setItem(0, 1, origen_x_widget)
self.ui.tabla.setItem(0, 2, origen_y_widget)
self.ui.tabla.setItem(0, 3, destino_x_widget)
self.ui.tabla.setItem(0, 4, destino_y_widget)
self.ui.tabla.setItem(0, 5, velocidad_widget)
self.ui.tabla.setItem(0, 6, rojo_widget)
self.ui.tabla.setItem(0, 7, verde_widget)
self.ui.tabla.setItem(0, 8, azul_widget)
self.ui.tabla.setItem(0, 9, distancia_widget)
encontrado = True
return
if not encontrado:
QMessageBox.warning(
self, "Atención",
f'La particula con Id "{ID}" no fue encontrada')
@Slot()
def mostrar_tabla(self):
self.ui.tabla.setColumnCount(10)
headers = [
"Id", "origen_x", "origen_y", "destino_x", "destino_y",
"velocidad", "rojo", "verde", "azul", "Distancia"
]
self.ui.tabla.setHorizontalHeaderLabels(headers)
self.ui.tabla.setRowCount(len(self.particulas))
row = 0
for particula in self.particulas:
id_widget = QTableWidgetItem(str(particula.Id))
origen_x_widget = QTableWidgetItem(str(particula.origen_x))
origen_y_widget = QTableWidgetItem(str(particula.origen_y))
destino_x_widget = QTableWidgetItem(str(particula.destino_x))
destino_y_widget = QTableWidgetItem(str(particula.destino_y))
velocidad_widget = QTableWidgetItem(str(particula.velocidad))
rojo_widget = QTableWidgetItem(str(particula.rojo))
verde_widget = QTableWidgetItem(str(particula.verde))
azul_widget = QTableWidgetItem(str(particula.azul))
distancia_widget = QTableWidgetItem(str(particula.distancia))
self.ui.tabla.setItem(row, 0, id_widget)
self.ui.tabla.setItem(row, 1, origen_x_widget)
self.ui.tabla.setItem(row, 2, origen_y_widget)
self.ui.tabla.setItem(row, 3, destino_x_widget)
self.ui.tabla.setItem(row, 4, destino_y_widget)
self.ui.tabla.setItem(row, 5, velocidad_widget)
self.ui.tabla.setItem(row, 6, rojo_widget)
self.ui.tabla.setItem(row, 7, verde_widget)
self.ui.tabla.setItem(row, 8, azul_widget)
self.ui.tabla.setItem(row, 9, distancia_widget)
row += 1
@Slot()
def action_abrir_archivo(self):
ubicacion = QFileDialog.getOpenFileName(self, 'Abrir achivo', '.',
'JSON (*.json)')[0]
if self.particulas.abrir(ubicacion):
QMessageBox.information(self, "Exito",
"Se abrió el archivo" + ubicacion)
else:
QMessageBox.critical(self, "Error",
"Error al abrir el archivo " + ubicacion)
@Slot()
def action_guardar_archivo(self):
ubicacion = QFileDialog.getSaveFileName(self, 'Guardar Archivo', '.',
'JSON (*.json)')[0]
print(ubicacion)
if self.particulas.guardar(ubicacion):
QMessageBox.information(self, "Éxito",
"Se pudo crear el archivo" + ubicacion)
else:
QMessageBox.critical(self, "Error",
"No se pudo crear el archivo" + ubicacion)
@Slot()
def click_mostrar(self):
self.ui.salida.clear()
self.ui.salida.insertPlainText(str(self.particulas))
@Slot()
def click_agregar_inicio(self):
id = self.ui.id_lineEdit.text()
origen_x = self.ui.origen_x_spinBox.value()
origen_y = self.ui.origen_y_spinBox.value()
destino_x = self.ui.destino_x_spinBox.value()
destino_y = self.ui.destino_y_spinBox.value()
velocidad = self.ui.velocidad_spinBox.value()
red = self.ui.red_spinBox.value()
green = self.ui.green_spinBox.value()
blue = self.ui.blue_spinBox.value()
particula = Particula(id, origen_x, origen_y, destino_x, destino_y,
velocidad, red, green, blue)
self.particulas.agregar_inicio(particula)
@Slot()
def click_agregar_final(self):
id = self.ui.id_lineEdit.text()
origen_x = self.ui.origen_x_spinBox.value()
origen_y = self.ui.origen_y_spinBox.value()
destino_x = self.ui.destino_x_spinBox.value()
destino_y = self.ui.destino_y_spinBox.value()
velocidad = self.ui.velocidad_spinBox.value()
red = self.ui.red_spinBox.value()
green = self.ui.green_spinBox.value()
blue = self.ui.blue_spinBox.value()
particula = Particula(id, origen_x, origen_y, destino_x, destino_y,
velocidad, red, green, blue)
self.particulas.agregar_final(particula)
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.organizador = Organizador()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.scene = QGraphicsScene()
self.ui.graficos.setScene(self.scene)
self.ui.agregar_inicio_button.clicked.connect(self.agregar_ini)
self.ui.agregar_final_button.clicked.connect(self.agregar_fin)
self.ui.mostrar_button.clicked.connect(self.mostrar)
self.ui.buscar_button.clicked.connect(self.buscar)
self.ui.mostrar_tabla_button.clicked.connect(self.mostrar_tabla)
self.ui.dibujar_button.clicked.connect(self.dibujar)
self.ui.limpiar_button.clicked.connect(self.limpiar)
self.ui.generar_button.clicked.connect(self.generar)
self.ui.actionAbrir.triggered.connect(self.abrir_archivo)
self.ui.actionGuardar.triggered.connect(self.guardar_archivo)
self.ui.actionGrafo.triggered.connect(self.generar_grafo)
self.ui.actionRecorrido.triggered.connect(self.recorrido)
self.ui.id_checkbox.stateChanged.connect(self.ordenar_id)
self.ui.velocidad_checkbox.stateChanged.connect(self.ordenar_vel)
self.ui.distancia_checkbox.stateChanged.connect(self.ordenar_dis)
def recorrido(self):
self.ui.plainTextEdit.clear()
self.ui.plainTextEdit.insertPlainText("Recorrido en Profundidad: \n")
self.ui.plainTextEdit.insertPlainText(
self.organizador.profundidad(self.ui.origen_X.value(),
self.ui.origen_y.value()))
self.ui.plainTextEdit.insertPlainText("\n\nRecorrido en Amplitud: \n")
self.ui.plainTextEdit.insertPlainText(
self.organizador.amplitud(self.ui.origen_X.value(),
self.ui.origen_y.value()))
def generar_grafo(self):
self.ui.plainTextEdit.clear()
self.ui.plainTextEdit.insertPlainText(
"Grafo (Lista de Adyacencia): \n")
self.ui.plainTextEdit.insertPlainText(self.organizador.grafo())
def wheelEvent(self, event):
if event.delta() > 0:
self.ui.graficos.scale(1.1, 1.1)
else:
self.ui.graficos.scale(0.9, 0.9)
@Slot()
def ordenar_id(self):
if self.ui.id_checkbox.isChecked():
self.ui.velocidad_checkbox.setChecked(False)
self.ui.distancia_checkbox.setChecked(False)
self.organizador.orden(False, "id")
@Slot()
def ordenar_dis(self):
if self.ui.distancia_checkbox.isChecked():
self.ui.velocidad_checkbox.setChecked(False)
self.ui.id_checkbox.setChecked(False)
self.organizador.orden(True, "dis")
@Slot()
def ordenar_vel(self):
if self.ui.velocidad_checkbox.isChecked():
self.ui.distancia_checkbox.setChecked(False)
self.ui.id_checkbox.setChecked(False)
self.organizador.orden(False, "vel")
@Slot()
def dibujar(self):
pen = QPen()
brush = QBrush()
pen.setWidth(3)
for i in self.organizador:
color = QColor(i.red, i.green, i.blue)
brush.setStyle(Qt.SolidPattern)
brush.setColor(color)
pen.setColor(color)
self.scene.addEllipse(i.or_x, i.or_y, 7, 7, pen, brush)
self.scene.addEllipse(i.de_x, i.de_y, 7, 7, pen, brush)
self.scene.addLine((i.or_x) + 3.5, (i.or_y) + 3.5, (i.de_x) + 3.5,
(i.de_y) + 3.5, pen)
for keys in self.organizador.grafo_dic:
text = QGraphicsTextItem(str(keys))
text.setFlag(QGraphicsItem.ItemIsMovable)
text.setFont(QFont("TimesNewRoman", 12, QFont.ExtraBold))
self.scene.addItem(text)
text.setPos(keys[0], keys[1])
@Slot()
def limpiar(self):
self.scene.clear()
@Slot()
def generar(self):
self.ui.id.setValue((randint(0, 9) * 10000) + (randint(0, 9) * 1000) +
(randint(0, 9) * 100) + (randint(0, 9) * 10) +
randint(0, 9))
self.ui.origen_X.setValue(randint(0, 500))
self.ui.origen_y.setValue(randint(0, 500))
self.ui.destino_x.setValue(randint(0, 500))
self.ui.destino_y.setValue(randint(0, 500))
self.ui.vel.setValue(randint(0, 200))
self.ui.red.setValue(randint(0, 255))
self.ui.green.setValue(randint(0, 255))
self.ui.blue.setValue(randint(0, 225))
@Slot()
def buscar(self):
key = int(self.ui.buscar_line_edit.text())
find = False
for particula in self.organizador:
if key == particula.id:
self.ui.tabla.setColumnCount(10)
labels = [
'ID', 'Origen en X', 'Origen en Y', 'Destino en X',
'Destino en Y', 'Velocidad', 'Distancia', 'Red', 'Green',
'Blue'
]
self.ui.tabla.setHorizontalHeaderLabels(labels)
self.ui.tabla.setRowCount(1)
self.ui.tabla.setItem(0, 0,
QTableWidgetItem(str(particula.id)))
self.ui.tabla.setItem(0, 1,
QTableWidgetItem(str(particula.or_x)))
self.ui.tabla.setItem(0, 2,
QTableWidgetItem(str(particula.or_y)))
self.ui.tabla.setItem(0, 3,
QTableWidgetItem(str(particula.de_x)))
self.ui.tabla.setItem(0, 4,
QTableWidgetItem(str(particula.de_y)))
self.ui.tabla.setItem(0, 5,
QTableWidgetItem(str(particula.vel)))
self.ui.tabla.setItem(0, 6,
QTableWidgetItem(str(particula.dis)))
self.ui.tabla.setItem(0, 7,
QTableWidgetItem(str(particula.red)))
self.ui.tabla.setItem(0, 8,
QTableWidgetItem(str(particula.green)))
self.ui.tabla.setItem(0, 9,
QTableWidgetItem(str(particula.blue)))
find = True
return
if find == False:
QMessageBox.warning(self, "Atención",
f"La partícula '{key}' no fue encontrada")
@Slot()
def mostrar_tabla(self):
self.ui.tabla.setColumnCount(10)
labels = [
'ID', 'Origen en X', 'Origen en Y', 'Destino en X', 'Destino en Y',
'Velocidad', 'Distancia', 'Red', 'Green', 'Blue'
]
self.ui.tabla.setHorizontalHeaderLabels(labels)
self.ui.tabla.setRowCount(len(self.organizador))
fila = 0
for particula in self.organizador:
self.ui.tabla.setItem(fila, 0, QTableWidgetItem(str(particula.id)))
self.ui.tabla.setItem(fila, 1,
QTableWidgetItem(str(particula.or_x)))
self.ui.tabla.setItem(fila, 2,
QTableWidgetItem(str(particula.or_y)))
self.ui.tabla.setItem(fila, 3,
QTableWidgetItem(str(particula.de_x)))
self.ui.tabla.setItem(fila, 4,
QTableWidgetItem(str(particula.de_y)))
self.ui.tabla.setItem(fila, 5,
QTableWidgetItem(str(particula.vel)))
self.ui.tabla.setItem(fila, 6,
QTableWidgetItem(str(particula.dis)))
self.ui.tabla.setItem(fila, 7,
QTableWidgetItem(str(particula.red)))
self.ui.tabla.setItem(fila, 8,
QTableWidgetItem(str(particula.green)))
self.ui.tabla.setItem(fila, 9,
QTableWidgetItem(str(particula.blue)))
fila += 1
@Slot()
def abrir_archivo(self):
ubicacion = QFileDialog.getOpenFileName(
self,
"Abrir",
".",
"JSON (*.json)",
)[0]
if self.organizador.abrir(ubicacion):
QMessageBox.information(
self, "Operación Exitosa",
"El archivo se abrió con éxito desde la direccion: \n" +
ubicacion)
self.organizador.borrar_grafo()
else:
QMessageBox.critical(self, "Error!",
"El archivo no se logró abrir")
@Slot()
def guardar_archivo(self):
ubicacion = QFileDialog.getSaveFileName(self, 'Guadar', '.',
'JSON (*.json)')[0]
if self.organizador.guardar(ubicacion):
QMessageBox.information(
self, "Operación Exitosa",
"El archivo se guardó con éxito en la direccion: \n" +
ubicacion)
else:
QMessageBox.critical(self, "Error!",
"El archivo no se logró guardar")
@Slot()
def agregar_ini(self):
Id = self.ui.id.value()
or_x = self.ui.origen_X.value()
or_y = self.ui.origen_y.value()
ds_x = self.ui.destino_x.value()
ds_y = self.ui.destino_y.value()
vel = self.ui.vel.value()
red = self.ui.red.value()
grn = self.ui.green.value()
blu = self.ui.blue.value()
part = Particula(Id, or_x, or_y, ds_x, ds_y, vel, red, grn, blu)
self.organizador.agregar_inicio(part)
@Slot()
def agregar_fin(self):
Id = self.ui.id.value()
or_x = self.ui.origen_X.value()
or_y = self.ui.origen_y.value()
ds_x = self.ui.destino_x.value()
ds_y = self.ui.destino_y.value()
vel = self.ui.vel.value()
red = self.ui.red.value()
grn = self.ui.green.value()
blu = self.ui.blue.value()
part = Particula(Id, or_x, or_y, ds_x, ds_y, vel, red, grn, blu)
self.organizador.agregar_final(part)
def mostrar(self):
self.ui.plainTextEdit.clear()
self.ui.plainTextEdit.insertPlainText(str(self.organizador))
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__() #Se llama a la ventana
self.administrador = Administrador()
self.grafo = dict()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
#Conexión del Slot
self.ui.agregarFinal_pushButton.clicked.connect(self.click_agregar)
self.ui.agregarInicio_pushButton.clicked.connect(self.click_agregarInicio)
self.ui.mostrar_pushButton.clicked.connect(self.click_mostrar)
self.ui.actionAbrir.triggered.connect(self.action_abrir_archivo)
self.ui.actionGuardar.triggered.connect(self.action_guardar_archivo)
self.ui.actionGrafo.triggered.connect(self.to_graph)
self.ui.actionRecorrido.triggered.connect(self.action_recorrido)
self.ui.mostrar_tabla_pushButton.clicked.connect(self.mostrar_tabla)
self.ui.buscar_pushButton.clicked.connect(self.buscar_id)
self.ui.dibujar.clicked.connect(self.dibujar)
self.ui.limpiar.clicked.connect(self.limpiar)
self.scene = QGraphicsScene()
self.ui.graphicsView.setScene(self.scene)
self.ui.ordenar_id_pushButton.clicked.connect(self.order_id)
self.ui.ordenar_distancia_pushButton.clicked.connect(self.order_distancia)
self.ui.ordenar_velocidad_pushButton.clicked.connect(self.order_velocidad)
def order_id(self):
self.administrador.order_by_id()
def order_distancia(self):
self.administrador.order_by_distancia()
def order_velocidad(self):
self.administrador.order_by_velocidad()
def wheelEvent(self, event):
print(event.delta())
if event.delta() > 0:
self.ui.graphicsView.scale(1.2, 1.2)
else:
self.ui.graphicsView.scale(0.8, 0.8)
@Slot()
def action_recorrido(self):
#Amplitud
cola = []
visitados = []
recorrido = []
self.to_graph()
x = self.ui.origenX_spinBox.value()
y = self.ui.origenY_spinBox.value()
cola.append((x,y))
visitados.append((x,y))
while cola:
padre = cola[-1] #En esta parte, se saca el tope de la lista
recorrido.append(padre)
del cola[-1]
adyacentes = self.grafo[padre] #Aquí se sacan los adyacentes
for a in adyacentes:
if a[0] not in visitados:
visitados.append(a[0])
cola.append(a[0])
else:
break
print(visitados)
self.ui.salida.insertPlainText("\nAmplitud\n")
self.ui.salida.insertPlainText(str(recorrido))
#Profundidad
pila = []
visitados = []
recorrido = []
x = self.ui.origenX_spinBox.value()
y = self.ui.origenY_spinBox.value()
pila.append((x,y))
visitados.append((x,y))
while pila:
padre = pila[0] #Sacamos el tope de la lista
recorrido.append(padre)
del pila[0]
adyacentes = self.grafo[padre] #Sacamos los adyacentes
for a in adyacentes:
if a[0] not in visitados:
visitados.append(a[0])
pila.append(a[0])
else:
break
print(visitados)
self.ui.salida.insertPlainText("\n\nProfundidad\n")
self.ui.salida.insertPlainText(str(visitados))
@Slot()
def to_graph(self):
self.ui.salida.clear()
for particula in self.administrador:
origen = (particula.origen_x, particula.origen_y)
destino = (particula.destino_x, particula.destino_y)
distancia = (particula.distancia)
arista_origen = (origen, distancia)
arista_destino = (destino, distancia)
if origen in self.grafo:
self.grafo[origen].append(arista_destino)
else:
self.grafo[origen] = [arista_destino]
if destino in self.grafo:
self.grafo[destino].append(arista_origen)
else:
self.grafo[destino] = [arista_origen]
impresion = pformat(self.grafo, width=40)
impresion+='\n'
self.ui.salida.insertPlainText(impresion)
@Slot()
def dibujar(self):
#print('dibujar')
pen = QPen()
pen.setWidth(2)
for particula in self.administrador:
r = particula.red
g = particula.green
b = particula.blue
color = QColor(r, g, b)
pen.setColor(color)
x_origen = particula.origen_x
y_origen = particula.origen_y
x_destino = particula.destino_x
y_destino = particula.destino_y
self.scene.addEllipse(x_origen, y_origen, 6, 6, pen)
self.scene.addEllipse(x_destino, y_destino, 6, 6, pen)
self.scene.addLine(x_origen+3, y_origen+3, x_destino+3, y_destino+3, pen)
@Slot()
def limpiar(self):
#print('limpiar')
self.scene.clear()
self.ui.graphicsView.setTransform(QTransform())
@Slot()
def buscar_id(self):
id = self.ui.buscar_lineEdit.text()
encontrado = False
for particula in self.administrador:
if id == particula.id:
self.ui.tabla.clear()
self.ui.tabla.setRowCount(1)
#Construir widgets
id_widget = QTableWidgetItem(particula.id)
origen_x_widget = QTableWidgetItem(str(particula.origen_x))
origen_y_widget = QTableWidgetItem(str(particula.origen_x))
destino_x_widget = QTableWidgetItem(str(particula.destino_x))
destino_y_widget = QTableWidgetItem(str(particula.destino_x))
velocidad_widget = QTableWidgetItem(str(particula.velocidad))
red_widget = QTableWidgetItem(str(particula.red))
green_widget = QTableWidgetItem(str(particula.green))
blue_widget = QTableWidgetItem(str(particula.blue))
distancia_widget = QTableWidgetItem(str(particula.distancia))
#Agregar widgets a cada columna
self.ui.tabla.setItem(0, 0, id_widget)
self.ui.tabla.setItem(0, 1, origen_x_widget)
self.ui.tabla.setItem(0, 2, origen_y_widget)
self.ui.tabla.setItem(0, 3, destino_x_widget)
self.ui.tabla.setItem(0, 4, destino_y_widget)
self.ui.tabla.setItem(0, 5, velocidad_widget)
self.ui.tabla.setItem(0, 6, red_widget)
self.ui.tabla.setItem(0, 7, green_widget)
self.ui.tabla.setItem(0, 8, blue_widget)
self.ui.tabla.setItem(0, 9, distancia_widget)
encontrado = True
return
if not encontrado:
QMessageBox.warning(
self,
"Atención",
f'La particula con el id "{id}" no fue encontrada'
)
@Slot()
def mostrar_tabla(self):
self.ui.tabla.setColumnCount(10) #Genera 10 columnas
headers = ["ID", "Origen x", "Origen y", "Destino x", "Destino y", "Velocidad", "Red", "Green", "Blue", "Distancia"]
self.ui.tabla.setHorizontalHeaderLabels(headers)
self.ui.tabla.setRowCount(len(self.administrador))
row = 0
for particula in self.administrador:
#Construir widgets
id_widget = QTableWidgetItem(particula.id)
origen_x_widget = QTableWidgetItem(str(particula.origen_x))
origen_y_widget = QTableWidgetItem(str(particula.origen_x))
destino_x_widget = QTableWidgetItem(str(particula.destino_x))
destino_y_widget = QTableWidgetItem(str(particula.destino_x))
velocidad_widget = QTableWidgetItem(str(particula.velocidad))
red_widget = QTableWidgetItem(str(particula.red))
green_widget = QTableWidgetItem(str(particula.green))
blue_widget = QTableWidgetItem(str(particula.blue))
distancia_widget = QTableWidgetItem(str(particula.distancia))
#Agregar widgets a cada columna
self.ui.tabla.setItem(row, 0, id_widget)
self.ui.tabla.setItem(row, 1, origen_x_widget)
self.ui.tabla.setItem(row, 2, origen_y_widget)
self.ui.tabla.setItem(row, 3, destino_x_widget)
self.ui.tabla.setItem(row, 4, destino_y_widget)
self.ui.tabla.setItem(row, 5, velocidad_widget)
self.ui.tabla.setItem(row, 6, red_widget)
self.ui.tabla.setItem(row, 7, green_widget)
self.ui.tabla.setItem(row, 8, blue_widget)
self.ui.tabla.setItem(row, 9, distancia_widget)
row += 1
@Slot()
def action_abrir_archivo(self):
ubicacion = QFileDialog.getOpenFileName(
self,
'Abrir archivo',
'.',
'JSON (*.json)'
)[0]
if self.administrador.abrir(ubicacion):
QMessageBox.information(
self,
"Éxito",
"Se abrió el archivo " + ubicacion
)
else:
QMessageBox.critical(
self,
"Error",
"Error al abrir el archivo " + ubicacion
)
@Slot()
def action_guardar_archivo(self):
ubicacion = QFileDialog.getSaveFileName(
self,
'Guardar Archivo',
#Lo abrirá desde donde se corre
'.',
#Extensión del archivo
'JSON (*.json)'
)[0]
print(ubicacion)
if self.administrador.guardar(ubicacion):
QMessageBox.information(
self,
"Éxito",
"Se pudo crear el archivo " + ubicacion
)
else:
QMessageBox.critical(
self,
"Error",
"No se pudo crear el archivo " + ubicacion
)
@Slot()
def click_mostrar(self):
#self.administrador.mostrar()
self.ui.salida.clear()
self.ui.salida.insertPlainText(str(self.administrador))
@Slot() #Definición de Slot
def click_agregar(self):
ID = self.ui.ID_lineEdit.text()
origenX = self.ui.origenX_spinBox.value()
origenY = self.ui.origenY_spinBox.value()
destinoX = self.ui.destinoX_spinBox.value()
destinoY = self.ui.destinoY_spinBox.value()
velocidad = self.ui.velocidad_spinBox.value()
red = self.ui.red_spinBox.value()
green = self.ui.green_spinBox.value()
blue = self.ui.blue_spinBox.value()
particula = Particula(ID, origenX, origenY, destinoX, destinoY, velocidad, red, green, blue)
self.administrador.agregar_final(particula)
@Slot() #Definición de Slot
def click_agregarInicio(self):
ID = self.ui.ID_lineEdit.text()
origenX = self.ui.origenX_spinBox.value()
origenY = self.ui.origenY_spinBox.value()
destinoX = self.ui.destinoX_spinBox.value()
destinoY = self.ui.destinoY_spinBox.value()
velocidad = self.ui.velocidad_spinBox.value()
red = self.ui.red_spinBox.value()
green = self.ui.green_spinBox.value()
blue = self.ui.blue_spinBox.value()
particula = Particula(ID, origenX, origenY, destinoX, destinoY, velocidad, red, green, blue)
self.administrador.agregar_inicio(particula)
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.particula = Particula()
self.organizador = Organizador()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.abInicio.clicked.connect(self.click_agregar_inicio)
self.ui.abFinal.clicked.connect(self.click_agregar_final)
self.ui.abMostrar.clicked.connect(self.click_mostrar)
self.ui.actionGuardar_.triggered.connect(self.guardar)
self.ui.actionAbrir_.triggered.connect(self.abrir)
self.ui.abMostrarParticulas.clicked.connect(
self.mostrarParticulasTodas)
self.ui.abBuscar.clicked.connect(self.buscarParticulaId)
self.ui.abLimpiar.clicked.connect(self.limpiar)
self.scene = QGraphicsScene()
self.ui.graphicsView.setScene(self.scene)
def wheelEvent(self, event):
if event.delta() > 0:
self.ui.graphicsView.scale(1.2, 1.2)
else:
self.ui.graphicsView.scale(0.8, 0.8)
@Slot()
def click_mostrar(self):
pen = QPen()
pen.setWidth(2)
for item in self.organizador.organizador:
pen.setColor(item.color())
origen_x = item.Xi()
origen_y = item.Yi()
destino_x = item.Xf()
destino_y = item.Yf()
self.scene.addEllipse(origen_x, origen_y, 3, 3, pen)
self.scene.addEllipse(destino_x, destino_y, 3, 3, pen)
self.scene.addLine(origen_x + 3, origen_y + 3, destino_x,
destino_y, pen)
@Slot()
def click_agregar_inicio(self):
id = self.ui.id.value()
origen_x = self.ui.origenX.value()
origen_y = self.ui.origenY.value()
destino_x = self.ui.destinoX.value()
destino_y = self.ui.destinoY.value()
velocidad = self.ui.velocidad.value()
rojo = self.ui.rojo.value()
verde = self.ui.verde.value()
azul = self.ui.azul.value()
particula = Particula(id, origen_x, origen_y, destino_x, destino_y,
velocidad, rojo, verde, azul)
self.organizador.agregar_inicio(particula)
@Slot()
def click_agregar_final(self):
id = self.ui.id.value()
origen_x = self.ui.origenX.value()
origen_y = self.ui.origenY.value()
destino_x = self.ui.destinoX.value()
destino_y = self.ui.destinoY.value()
velocidad = self.ui.velocidad.value()
rojo = self.ui.rojo.value()
verde = self.ui.verde.value()
azul = self.ui.azul.value()
particula = Particula(id, origen_x, origen_y, destino_x, destino_y,
velocidad, rojo, verde, azul)
self.organizador.agregar_final(particula)
@Slot()
def guardar(self):
ubicacion = QFileDialog.getSaveFileName(self, 'Guardar', '.',
'JSON (*.json)')
with open(ubicacion[0], 'w') as archivo:
json.dump(self.organizador.guardar(), archivo, indent=4)
@Slot()
def abrir(self):
ubicacion = QFileDialog.getOpenFileName(self, 'Abrir', '.',
'JSON (*.json)')
with open(ubicacion[0], 'r') as archivo:
self.organizador.get(json.load(archivo))
@Slot()
def buscarParticulaId(self):
id = self.ui.lineaBuscar.text()
encontrado = False
for item in self.organizador.organizador:
if id == item.getId():
self.ui.tableWidget.clear()
self.ui.tableWidget.setRowCount(1)
headers = [
"Id", "Origen", "Destino", "Velocidad", "Color",
"Distancia"
]
self.ui.tableWidget.setHorizontalHeaderLabels(headers)
id = QTableWidgetItem(item.getId())
origen = QTableWidgetItem(item.getOrigen())
destino = QTableWidgetItem(item.getDestino())
velocidad = QTableWidgetItem(item.getVelocidad())
color = QTableWidgetItem(item.getColor())
distancia = QTableWidgetItem(item.getDistancia())
self.ui.tableWidget.setItem(0, 0, id)
self.ui.tableWidget.setItem(0, 1, origen)
self.ui.tableWidget.setItem(0, 2, destino)
self.ui.tableWidget.setItem(0, 3, velocidad)
self.ui.tableWidget.setItem(0, 4, color)
self.ui.tableWidget.setItem(0, 5, distancia)
encontrado = True
return
if not encontrado:
QMessageBox.warning(
self, "Atención",
f'La partícula con identificador "{id}" no fue encontrada')
@Slot()
def mostrarParticulasTodas(self):
row = 0
self.ui.tableWidget.clear()
self.ui.tableWidget.setRowCount(len(self.organizador.organizador))
headers = [
"Id", "Origen", "Destino", "Velocidad", "Color", "Distancia"
]
self.ui.tableWidget.setHorizontalHeaderLabels(headers)
for item in self.organizador.organizador:
id = QTableWidgetItem(item.getId())
origen = QTableWidgetItem(item.getOrigen())
destino = QTableWidgetItem(item.getDestino())
velocidad = QTableWidgetItem(item.getVelocidad())
color = QTableWidgetItem(item.getColor())
distancia = QTableWidgetItem(item.getDistancia())
self.ui.tableWidget.setItem(row, 0, id)
self.ui.tableWidget.setItem(row, 1, origen)
self.ui.tableWidget.setItem(row, 2, destino)
self.ui.tableWidget.setItem(row, 3, velocidad)
self.ui.tableWidget.setItem(row, 4, color)
self.ui.tableWidget.setItem(row, 5, distancia)
row += 1
@Slot()
def limpiar(self):
self.scene.clear()
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.particulas = Particulas()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.agregar_final_pushButton.clicked.connect(
self.click_agregar_final)
self.ui.agregar_inicio_pushButton.clicked.connect(
self.click_agregar_inicio)
self.ui.mostrar_pushButton.clicked.connect(self.click_mostrar)
self.ui.actionAbrir.triggered.connect(self.action_abrir_archivo)
self.ui.actionGuardar.triggered.connect(self.action_guardar_archivo)
self.ui.mostrar_tabla_pushButton.clicked.connect(self.mostrar_tabla)
self.ui.buscar_pushButton.clicked.connect(self.buscar_id)
self.ui.dibujar_pushbutton.clicked.connect(self.dibujar)
self.ui.limpiar_pushbutton.clicked.connect(self.limpiar)
self.scene = QGraphicsScene()
self.ui.graphicsView.setScene(self.scene)
self.ui.ordenID_pushButton.clicked.connect(self.orden_ID)
self.ui.orden_distancia_pushButton.clicked.connect(
self.orden_Distancia)
self.ui.orden_velocidad_pushButton.clicked.connect(
self.orden_Velocidad)
self.ui.mostrar_grafo_pushbutton.clicked.connect(self.mostrar_Grafo)
self.grafo = QGraphicsScene()
self.ui.grafica_grafo.setScene(self.grafo)
self.ui.busqueda_ap_pushButton.clicked.connect(self.busquedas)
def wheelEvent(self, event):
if event.delta() > 0:
self.ui.graphicsView.scale(1.2, 1.2)
else:
self.ui.graphicsView.scale(0.8, 0.8)
@Slot()
def busquedas(self):
grafo = dict()
for particula in self.particulas:
or_x = str(particula.origenx).upper()
or_y = str(particula.origeny).upper()
de_x = str(particula.destinox).upper()
de_y = str(particula.destinoy).upper()
peso = int(particula.distancia)
origen = or_x, or_y
destino = de_x, de_y
arista_o_d = (de_x, de_y, peso)
arista_d_o = (or_x, or_y, peso)
if origen in grafo:
grafo[origen].append(arista_o_d)
else:
grafo[origen] = [arista_o_d]
if destino in grafo:
grafo[destino].append(arista_d_o)
else:
grafo[destino] = [arista_d_o]
origenx = self.ui.Origenx_busqueda_lineEdit.text()
origeny = self.ui.Origeny_busqueda_lineEdit.text()
origen = origenx, origeny
if self.ui.Origenx_busqueda_lineEdit.text(
) == "" or self.ui.Origeny_busqueda_lineEdit.text() == "":
QMessageBox.warning(self, "Atencion",
"Alguno de los campos esta vacio.")
else:
print("Profundidad: ")
print(busquedaProfundidad(grafo, origen))
print("Amplitud: ")
print(busquedaAmplitud(grafo, origen))
@Slot()
def mostrar_Grafo(self):
grafo = dict()
for particula in self.particulas:
or_x = str(particula.origenx).upper()
or_y = str(particula.origeny).upper()
de_x = str(particula.destinox).upper()
de_y = str(particula.destinoy).upper()
peso = int(particula.distancia)
origen = or_x, or_y
destino = de_x, de_y
arista_o_d = (de_x, de_y, peso)
arista_d_o = (or_x, or_y, peso)
if origen in grafo:
grafo[origen].append(arista_o_d)
else:
grafo[origen] = [arista_o_d]
if destino in grafo:
grafo[destino].append(arista_d_o)
else:
grafo[destino] = [arista_d_o]
strn = pformat(grafo, width=40, indent=1)
for particula in self.particulas:
pen = QPen()
pen.setWidth(2)
color = QColor(particula.red, particula.green, particula.blue)
pen.setColor(color)
self.grafo.addEllipse(particula.origenx, particula.origeny, 3, 3,
pen)
self.grafo.addEllipse(particula.destinox, particula.destinoy, 3, 3,
pen)
self.grafo.addLine(particula.origenx + 3, particula.origeny + 3,
particula.destinox, particula.destinoy, pen)
self.ui.text_edit_grafo.clear()
self.ui.text_edit_grafo.insertPlainText(strn)
@Slot()
def orden_ID(self):
self.particulas.orden_id()
@Slot()
def orden_Distancia(self):
self.particulas.orden_distancia()
@Slot()
def orden_Velocidad(self):
self.particulas.orden_velocidad()
@Slot()
def dibujar(self):
pen = QPen()
pen.setWidth(2)
for particula in self.particulas:
color = QColor(particula.red, particula.green, particula.blue)
pen.setColor(color)
self.scene.addEllipse(particula.origenx, particula.origeny, 3, 3,
pen)
self.scene.addEllipse(particula.destinox, particula.destinoy, 3, 3,
pen)
self.scene.addLine(particula.origenx, particula.origeny,
particula.destinox, particula.destinoy, pen)
@Slot()
def limpiar(self):
self.scene.clear()
@Slot()
def buscar_id(self):
id_buscado = self.ui.busca_lineEdit.text()
encontrado = False
for particula in self.particulas:
if id_buscado == particula.id:
self.ui.tableWidget.clear()
self.ui.tableWidget.setRowCount(1)
self.ui.tableWidget.setColumnCount(10)
headers = [
"Id", "Origen x", "Origen y", "Destino x", "Destino y",
"Velocidad", "Red", "Green", "Blue", "Distancia"
]
self.ui.tableWidget.setHorizontalHeaderLabels(headers)
id_widget = QTableWidgetItem(particula.id)
origenx_widget = QTableWidgetItem(str(particula.origenx))
origeny_widget = QTableWidgetItem(str(particula.origeny))
destinox_widget = QTableWidgetItem(str(particula.destinox))
destinoy_widget = QTableWidgetItem(str(particula.destinoy))
velocidad_widget = QTableWidgetItem(str(particula.velocidad))
red_widget = QTableWidgetItem(str(particula.red))
green_widget = QTableWidgetItem(str(particula.green))
blue_widget = QTableWidgetItem(str(particula.blue))
distancia_widget = QTableWidgetItem(str(particula.distancia))
self.ui.tableWidget.setItem(0, 0, id_widget)
self.ui.tableWidget.setItem(0, 1, origenx_widget)
self.ui.tableWidget.setItem(0, 2, origeny_widget)
self.ui.tableWidget.setItem(0, 3, destinox_widget)
self.ui.tableWidget.setItem(0, 4, destinoy_widget)
self.ui.tableWidget.setItem(0, 5, velocidad_widget)
self.ui.tableWidget.setItem(0, 6, red_widget)
self.ui.tableWidget.setItem(0, 7, green_widget)
self.ui.tableWidget.setItem(0, 8, blue_widget)
self.ui.tableWidget.setItem(0, 9, distancia_widget)
encontrado = True
return
if not encontrado:
self.ui.tableWidget.clear()
QMessageBox.warning(
self, "Atencion",
f'La particula con el id "{id_buscado}" no fue encontrado')
@Slot()
def mostrar_tabla(self):
self.ui.tableWidget.setColumnCount(10)
headers = [
"Id", "Origen x", "Origen y", "Destino x", "Destino y",
"Velocidad", "Red", "Green", "Blue", "Distancia"
]
self.ui.tableWidget.setHorizontalHeaderLabels(headers)
self.ui.tableWidget.setRowCount(len(self.particulas))
row = 0
for particula in self.particulas:
id_widget = QTableWidgetItem(particula.id)
origenx_widget = QTableWidgetItem(str(particula.origenx))
origeny_widget = QTableWidgetItem(str(particula.origeny))
destinox_widget = QTableWidgetItem(str(particula.destinox))
destinoy_widget = QTableWidgetItem(str(particula.destinoy))
velocidad_widget = QTableWidgetItem(str(particula.velocidad))
red_widget = QTableWidgetItem(str(particula.red))
green_widget = QTableWidgetItem(str(particula.green))
blue_widget = QTableWidgetItem(str(particula.blue))
distancia_widget = QTableWidgetItem(str(particula.distancia))
self.ui.tableWidget.setItem(row, 0, id_widget)
self.ui.tableWidget.setItem(row, 1, origenx_widget)
self.ui.tableWidget.setItem(row, 2, origeny_widget)
self.ui.tableWidget.setItem(row, 3, destinox_widget)
self.ui.tableWidget.setItem(row, 4, destinoy_widget)
self.ui.tableWidget.setItem(row, 5, velocidad_widget)
self.ui.tableWidget.setItem(row, 6, red_widget)
self.ui.tableWidget.setItem(row, 7, green_widget)
self.ui.tableWidget.setItem(row, 8, blue_widget)
self.ui.tableWidget.setItem(row, 9, distancia_widget)
row += 1
@Slot()
def action_abrir_archivo(self):
# print('abrir_archivo')
ubicacion = QFileDialog.getOpenFileName(self, 'Abrir Archivo', '.',
'JSON (*.json)')[0]
if self.particulas.abrir(ubicacion):
QMessageBox.information(self, "Exito",
"Se abrio el archivo " + ubicacion)
else:
QMessageBox.critical(self, "Error",
"Error al abrir el archivo" + ubicacion)
@Slot()
def action_guardar_archivo(self):
# print('guardar archivo')
ubicacion = QFileDialog.getSaveFileName(self, 'Guardar Archivo', '.',
'JSON (*.json)')[0]
print(ubicacion)
if self.particulas.guardar(ubicacion):
QMessageBox.information(self, "Exito",
"Se creo el archivo " + ubicacion)
else:
QMessageBox.critical(self, "Error",
"No se pudo crear el archivo" + ubicacion)
@Slot()
def click_agregar_final(self):
id = self.ui.id_lineEdit.text()
origen_x = self.ui.origen_x_spinBox.value()
origen_y = self.ui.origen_y_spinBox.value()
destino_x = self.ui.destino_x_spinBox.value()
destino_y = self.ui.destino_y_spinBox.value()
velocidad = self.ui.velocidad_lineEdit.text()
red = self.ui.red_spinBox.value()
green = self.ui.green_spinBox.value()
blue = self.ui.blue_spinBox.value()
particula = Particula(id, origen_x, origen_y, destino_x, destino_y,
velocidad, red, green, blue)
self.particulas.agregar_final(particula)
@Slot()
def click_agregar_inicio(self):
id = self.ui.id_lineEdit.text()
origen_x = self.ui.origen_x_spinBox.value()
origen_y = self.ui.origen_y_spinBox.value()
destino_x = self.ui.destino_x_spinBox.value()
destino_y = self.ui.destino_y_spinBox.value()
velocidad = self.ui.velocidad_lineEdit.text()
red = self.ui.red_spinBox.value()
green = self.ui.green_spinBox.value()
blue = self.ui.blue_spinBox.value()
particula = Particula(id, origen_x, origen_y, destino_x, destino_y,
velocidad, red, green, blue)
self.particulas.agregar_inicio(particula)
@Slot()
def click_mostrar(self):
self.ui.salida.clear()
self.ui.salida.insertPlainText(str(self.particulas))
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.AlmacenP = AlmacenDeParticulas()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.AgregarFinal.clicked.connect(self.click_agregar)
self.ui.AgregarInicio.clicked.connect(self.click_agregarInicio)
self.ui.Mostrar.clicked.connect(self.click_mostrar)
self.ui.actionAbrir.triggered.connect(self.action_abrir_archivo)
self.ui.actionGuardar.triggered.connect(self.action_guardar_archivo)
self.ui.Mostrar_Tabla_Boton.clicked.connect(self.mostrar_tabla)
self.ui.Buscar_Boton.clicked.connect(self.buscar_id)
self.ui.Dibujar.clicked.connect(self.dibujar)
self.ui.Limpiar.clicked.connect(self.limpiar)
self.scene = QGraphicsScene()
self.ui.graphicsView.setScene(self.scene)
self.ui.OrdId.clicked.connect(self.ordId)
self.ui.OrdDistancia.clicked.connect(self.ordDistancia)
self.ui.OrdVelocidad.clicked.connect(self.ordVelocidad)
self.scene = QGraphicsScene()
self.ui.graphicsView.setScene(self.scene)
self.Scene = QGraphicsScene()
self.ui.GrafoF_graphicsView.setScene(self.Scene)
self.ui.Mostrar_pushButton.clicked.connect(self.MostrarGrafo)
self.ui.Limpiar_pushButton.clicked.connect(self.limpiarGrafo)
self.ui.Recorrer.clicked.connect(self.Profundidad_Amplitud)
@Slot()
def Profundidad_Amplitud(self):
self.ui.Recorrido_plainTextEdit.clear()
grafo = dict()
for Particulas in self.AlmacenP:
OX = str(Particulas.OrigenX).upper()
OY = str(Particulas.OrigenY).upper()
DX = str(Particulas.DestinoX).upper()
DY = str(Particulas.DestinoY).upper()
Origen = OX, OY
Destino = DX, DY
if Origen in grafo:
grafo[Origen].append(Destino)
else:
grafo[Origen] = [Destino]
if Destino in grafo:
grafo[Destino].append(Origen)
else:
grafo[Destino] = [Origen]
UbicX = self.ui.BusquedaX_spinBox.value()
UbicY = self.ui.BusquedaY_spinBox.value()
UbicacionX = str(UbicX).upper()
UbicacionY = str(UbicY).upper()
Ubicacion = UbicacionX, UbicacionY
if Ubicacion in grafo:
adyacencia = Ubicacion
visitados = []
pila = deque()
recorrido = []
visitados.append(adyacencia)
pila.append(adyacencia)
while len(pila) != 0:
vertice = pila[-1]
recorrido.append(vertice)
pila.pop()
for ady in grafo[vertice]:
if ady not in visitados:
visitados.append(ady)
pila.append(ady)
self.ui.Recorrido_plainTextEdit.insertPlainText('Profundidad\n')
for parte in recorrido:
self.ui.Recorrido_plainTextEdit.insertPlainText(str(parte))
self.ui.Recorrido_plainTextEdit.insertPlainText('\n')
self.ui.Recorrido_plainTextEdit.insertPlainText('\n\n')
adyacencia2 = Ubicacion
visitados2 = []
cola = deque()
recorrido2 = []
visitados2.append(adyacencia2)
cola.append(adyacencia2)
while len(cola) != 0:
vertice2 = cola[0]
recorrido2.append(vertice2)
cola.popleft()
for ady2 in grafo[vertice2]:
if ady2 not in visitados2:
visitados2.append(ady2)
cola.append(ady2)
self.ui.Recorrido_plainTextEdit.insertPlainText('Amplitud\n')
for parte in recorrido2:
self.ui.Recorrido_plainTextEdit.insertPlainText(str(parte))
self.ui.Recorrido_plainTextEdit.insertPlainText('\n')
else:
QMessageBox.critical(self, "Error",
"Esta ubicacion no se encuentra en el grafo")
@Slot()
def MostrarGrafo(self):
grafo = dict()
for Particulas in self.AlmacenP:
OX = str(Particulas.OrigenX).upper()
OY = str(Particulas.OrigenY).upper()
DX = str(Particulas.DestinoX).upper()
DY = str(Particulas.DestinoY).upper()
DI = int(Particulas.Distancia)
Origen = OX, OY
Destino = DX, DY
AristaOD = (DX, DY, DI)
AristaDO = (OX, OY, DI)
if Origen in grafo:
grafo[Origen].append(AristaOD)
else:
grafo[Origen] = [AristaOD]
if Destino in grafo:
grafo[Destino].append(AristaDO)
else:
grafo[Destino] = [AristaDO]
strn = pformat(grafo, width=40, indent=1)
pprint(grafo, width=40)
for Particulas in self.AlmacenP:
pen = QPen()
pen.setWidth(2)
color = QColor(Particulas.Red, Particulas.Green, Particulas.Blue)
pen.setColor(color)
self.Scene.addEllipse(Particulas.OrigenX, Particulas.OrigenY, 3, 3,
pen)
self.Scene.addEllipse(Particulas.DestinoX, Particulas.DestinoY, 3,
3, pen)
self.Scene.addLine(Particulas.OrigenX + 3, Particulas.OrigenY + 3,
Particulas.DestinoX, Particulas.DestinoY, pen)
self.ui.Grafo_plainTextEdit.clear()
self.ui.Grafo_plainTextEdit.insertPlainText(strn)
@Slot()
def limpiarGrafo(self):
self.Scene.clear()
self.ui.Grafo_plainTextEdit.clear()
# def sort_by_Distancia(self.__lista):
# return self.__particulas.Distancia
@Slot()
def ordId(self):
self.AlmacenP.ordenar()
@Slot()
def ordDistancia(self):
self.AlmacenP.ordenarD()
@Slot()
def ordVelocidad(self):
self.AlmacenP.ordenarV()
@Slot()
def dibujar(self):
pen = QPen()
pen.setWidth(3)
for Particulas in self.AlmacenP:
r = float(Particulas.Red)
g = float(Particulas.Green)
b = float(Particulas.Blue)
# origen_x = randint(0, 500)
# origen_y = randint(0, 500)
# destino_x = randint(0, 500)
# destino_y = randint(0, 500)
color = QColor(r, g, b)
pen.setColor(color)
self.scene.addEllipse(float(Particulas.OrigenX),
float(Particulas.OrigenY), 3, 3, pen)
self.scene.addEllipse(float(Particulas.DestinoX),
float(Particulas.DestinoY), 3, 3, pen)
self.scene.addLine(
float(Particulas.OrigenX) + 3,
float(Particulas.OrigenY) + 3, float(Particulas.DestinoX),
float(Particulas.DestinoY), pen)
def wheelEvent(self, event):
if event.delta() > 0:
self.ui.graphicsView.scale(1.2, 1.2)
else:
self.ui.graphicsView.scale(0.8, 0.8)
if event.delta() > 0:
self.ui.GrafoF_graphicsView.scale(1.2, 1.2)
else:
self.ui.GrafoF_graphicsView.scale(0.8, 0.8)
@Slot()
def limpiar(self):
self.scene.clear()
@Slot()
def buscar_id(self):
Id = self.ui.Buscar.text()
encontrado = False
for Particulas in self.AlmacenP:
if Id == str(Particulas.Id):
self.ui.tableWidget.clear()
self.ui.tableWidget.setRowCount(1)
Id_widget = QTableWidgetItem(str(Particulas.Id))
OrigenX_widget = QTableWidgetItem(str(Particulas.OrigenX))
OrigenY_widget = QTableWidgetItem(str(Particulas.OrigenY))
DestinoX_widget = QTableWidgetItem(str(Particulas.DestinoX))
DestinoY_widget = QTableWidgetItem(str(Particulas.DestinoY))
Velocidad_widget = QTableWidgetItem(str(Particulas.Velocidad))
Red_widget = QTableWidgetItem(str(Particulas.Red))
Green_widget = QTableWidgetItem(str(Particulas.Green))
Blue_widget = QTableWidgetItem(str(Particulas.Blue))
Distancia_widget = QTableWidgetItem(str(Particulas.Distancia))
self.ui.tableWidget.setItem(0, 0, Id_widget)
self.ui.tableWidget.setItem(0, 1, OrigenX_widget)
self.ui.tableWidget.setItem(0, 2, OrigenY_widget)
self.ui.tableWidget.setItem(0, 3, DestinoX_widget)
self.ui.tableWidget.setItem(0, 4, DestinoY_widget)
self.ui.tableWidget.setItem(0, 5, Velocidad_widget)
self.ui.tableWidget.setItem(0, 6, Red_widget)
self.ui.tableWidget.setItem(0, 7, Green_widget)
self.ui.tableWidget.setItem(0, 8, Blue_widget)
self.ui.tableWidget.setItem(0, 9, Distancia_widget)
encontrado = True
return
if not encontrado:
QMessageBox.warning(
self, 'Atencion',
f'La particula con el Id "{Id}" no fue encontrado')
@Slot()
def mostrar_tabla(self):
#print('mostrar_tabla')
self.ui.tableWidget.setColumnCount(10)
headers = [
"Id", "OrigenX", "OrigenY", "DestinoX", "DestinoY", "Velocidad",
"Red", "Green", "Blue", "Distancia"
]
self.ui.tableWidget.setHorizontalHeaderLabels(headers)
self.ui.tableWidget.setRowCount(len(self.AlmacenP))
row = 0
for Particulas in self.AlmacenP:
Id_widget = QTableWidgetItem(str(Particulas.Id))
OrigenX_widget = QTableWidgetItem(str(Particulas.OrigenX))
OrigenY_widget = QTableWidgetItem(str(Particulas.OrigenY))
DestinoX_widget = QTableWidgetItem(str(Particulas.DestinoX))
DestinoY_widget = QTableWidgetItem(str(Particulas.DestinoY))
Velocidad_widget = QTableWidgetItem(str(Particulas.Velocidad))
Red_widget = QTableWidgetItem(str(Particulas.Red))
Green_widget = QTableWidgetItem(str(Particulas.Green))
Blue_widget = QTableWidgetItem(str(Particulas.Blue))
Distancia_widget = QTableWidgetItem(str(Particulas.Distancia))
self.ui.tableWidget.setItem(row, 0, Id_widget)
self.ui.tableWidget.setItem(row, 1, OrigenX_widget)
self.ui.tableWidget.setItem(row, 2, OrigenY_widget)
self.ui.tableWidget.setItem(row, 3, DestinoX_widget)
self.ui.tableWidget.setItem(row, 4, DestinoY_widget)
self.ui.tableWidget.setItem(row, 5, Velocidad_widget)
self.ui.tableWidget.setItem(row, 6, Red_widget)
self.ui.tableWidget.setItem(row, 7, Green_widget)
self.ui.tableWidget.setItem(row, 8, Blue_widget)
self.ui.tableWidget.setItem(row, 9, Distancia_widget)
row += 1
@Slot()
def action_abrir_archivo(self):
#print('abrir_archivo')
ubication = QFileDialog.getOpenFileName(self, 'Abrir Archivo', '.',
'JSON (*.json)')[0]
if self.AlmacenP.abrir(ubication):
QMessageBox.information(self, "Exito",
"Se abrio el archivo " + ubication)
else:
QMessageBox.critical(self, "Error",
"Eror al abrir el archivo" + ubication)
@Slot()
def action_guardar_archivo(self):
#print('Guardar_archivo')
ubication = QFileDialog.getSaveFileName(self, 'Guardar Archivo', '.',
'JSON (*.json)')[0]
print(ubication)
if self.AlmacenP.guardar(ubication):
QMessageBox.information(self, "Exito",
"Se pudo crear el archivo" + ubication)
else:
QMessageBox.critical(self, "Error",
"No se pudo crear el archivo" + ubication)
@Slot()
def click_mostrar(self):
#self.AlmacenP.mostrar()
self.ui.plainTextEdit.clear()
self.ui.plainTextEdit.insertPlainText(str(self.AlmacenP))
@Slot()
def click_agregar(self):
Id = self.ui.Id_spinBox.value()
OrigenX = self.ui.OrigenX_spinBox.value()
OrigenY = self.ui.OrigenY_spinBox.value()
DestinoX = self.ui.DestinoX_spinBox.value()
DestinoY = self.ui.DestinoY_spinBox.value()
Velocidad = self.ui.Velocidad_spinBox.value()
Red = self.ui.Red_spinBox.value()
Green = self.ui.Green_spinBox.value()
Blue = self.ui.Blue_spinBox.value()
Distancia = self.ui.Distancia_spinBox.value()
Particulas = Particula(Id, OrigenX, OrigenY, DestinoX, DestinoY,
Velocidad, Red, Green, Blue)
self.AlmacenP.agregar_final(Particulas)
# print(Id, OrigenX, OrigenY, DestinoX, DestinoY, Velocidad, Red, Green, Blue)
# self.ui.plainTextEdit.insertPlainText(str(Id) + str(OrigenX) + str(OrigenY) + str(DestinoX) + str(DestinoY) + str(Velocidad) + str(Red) + str(Green) + str(Blue))
@Slot()
def click_agregarInicio(self):
Id = self.ui.Id_spinBox.value()
OrigenX = self.ui.OrigenX_spinBox.value()
OrigenY = self.ui.OrigenY_spinBox.value()
DestinoX = self.ui.DestinoX_spinBox.value()
DestinoY = self.ui.DestinoY_spinBox.value()
Velocidad = self.ui.Velocidad_spinBox.value()
Red = self.ui.Red_spinBox.value()
Green = self.ui.Green_spinBox.value()
Blue = self.ui.Blue_spinBox.value()
Distancia = self.ui.Distancia_spinBox.value()
Particulas = Particula(Id, OrigenX, OrigenY, DestinoX, DestinoY,
Velocidad, Red, Green, Blue)
self.AlmacenP.agregar_inicio(Particulas)
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow,self).__init__()
self.cern = CERN()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.agregar_inicio_button.clicked.connect(self.agregar_inicio)
self.ui.agregar_final_button.clicked.connect(self.agregar_fin)
self.ui.mostrar_button.clicked.connect(self.mostrar_plano)
self.ui.grafo_button.clicked.connect(self.mostrar_grafo)
self.ui.salida.setReadOnly(True)
self.grafo = False
self.ui.actionAbrir.triggered.connect(self.abrir_archivo)
self.ui.actionGuardar.triggered.connect(self.guardar_archivo)
self.ui.action_grafo.triggered.connect(self.mostrar_grafo)
self.ui.action_lista.triggered.connect(self.mostrar_plano)
self.ui.action_recorridos.triggered.connect(self.mostrar_recorridos)
self.ui.action_prim.triggered.connect(self.dibujar_prim)
self.ui.action_kruskal.triggered.connect(self.dibujar_kruskal)
self.ui.action_dijkstra.triggered.connect(self.dibujar_dijkstra)
self.ui.mostrar_tabla_pushButton.clicked.connect(self.mostrar_tabla)
self.ui.buscar_pushButton.clicked.connect(self.buscar_id)
self.ui.dibujar.clicked.connect(self.dibujar)
self.ui.borrar.clicked.connect(self.limpiar)
self.scene = QGraphicsScene()
self.ui.graphicsView.setScene(self.scene)
self.ui.plainTextSort.currentIndexChanged.connect(self.sort_plain)
self.ui.tableSort.currentIndexChanged.connect(self.sort_plain)
@Slot()
def dibujar_dijkstra(self):
self.mostrar()
if not self.grafo or len(self.cern) == 0:
QMessageBox.critical(
self,
"No se pudo leer",
"Convierta a grafo no vacío antes"
)
else:
origen_x = int(self.ui.origin_x.text())
origen_y = int(self.ui.origin_y.text())
origen = (origen_x, origen_y)
destino_x = int(self.ui.destination_x.text())
destino_y = int(self.ui.destination_y.text())
destino = (destino_x, destino_y)
grafo = self.cern.to_dict()
if origen not in grafo or destino not in grafo:
QMessageBox.information(
self,
"Origen o destino inválidos",
"Escriba un origen y destino válidos en los campos"
)
return
distancias, camino = self.cern.dijkstra(origen)
print('')
formated = pformat(distancias, width=40, indent=1)
print(formated)
print('')
formated = pformat(camino, width=40, indent=1)
print(formated)
if camino[origen] not in grafo or camino[destino] not in grafo:
QMessageBox.critical(
self,
"Sin camino",
"No se encontró el camino"
)
return
self.ui.tabWidget.setCurrentIndex(2)
self.scene.clear()
pen = QPen()
pen.setColor(QColor(105, 207, 193))
dimension = 5
pen.setWidth(dimension)
siguiente = destino
while siguiente != origen:
actual = camino[siguiente]
self.scene.addLine(actual[0]+3, actual[1]+3, siguiente[0], siguiente[1], pen)
self.scene.addEllipse(actual[0], actual[1], dimension, dimension, pen)
self.scene.addEllipse(siguiente[0], siguiente[1], dimension, dimension, pen)
siguiente = camino[siguiente]
@Slot()
def dibujar_kruskal(self):
self.mostrar()
if not self.grafo or len(self.cern) == 0:
QMessageBox.critical(
self,
"No se pudo leer",
"Convierta a grafo no vacío antes"
)
else:
arbol = self.cern.kruskal()
print("Arbol de expansion minima: ")
print(arbol)
self.ui.tabWidget.setCurrentIndex(2)
pen = QPen()
pen.setDashPattern([1,3])
color = QColor(255,255,255)
pen.setColor(color)
pen.setWidth(4)
for arista in arbol:
origen = arista[1]
destino = arista[2]
self.scene.addLine(origen[0]+3, origen[1]+3, destino[0], destino[1], pen)
@Slot()
def dibujar_prim(self):
self.mostrar()
if not self.grafo or len(self.cern) == 0:
QMessageBox.critical(
self,
"No se pudo leer",
"Convierta a grafo no vacío antes"
)
else:
origen_x = int(self.ui.origin_x.text())
origen_y = int(self.ui.origin_y.text())
origen = (origen_x, origen_y)
if origen not in self.cern.to_dict():
QMessageBox.information(
self,
"Sin origen válido",
"Se usará el primer elemento en el grafo como origen"
)
origen = next(iter(self.cern.to_dict()))
arbol = self.cern.prim(origen)
print(arbol)
self.ui.tabWidget.setCurrentIndex(2)
pen = QPen()
pen.setDashPattern([1,3])
color = QColor(255,255,255)
pen.setColor(color)
pen.setWidth(4)
for arista in arbol:
origen = arista[1]
destino = arista[2]
self.scene.addLine(origen[0]+3, origen[1]+3, destino[0], destino[1], pen)
@Slot()
def mostrar_recorridos(self):
self.mostrar()
if not self.grafo or len(self.cern) == 0:
QMessageBox.critical(
self,
"No se pudo leer",
"Convierta a grafo no vacío antes"
)
else:
origen_x = int(self.ui.origin_x.text())
origen_y = int(self.ui.origin_y.text())
origen = (origen_x, origen_y)
if origen not in self.cern.to_dict():
QMessageBox.information(
self,
"Sin origen válido",
"Se usará el primer elemento en el grafo como origen"
)
origen = next(iter(self.cern.to_dict()))
anchura = self.cern.recorrido_anchura(origen)
profundidad = self.cern.recorrido_profundidad(origen)
print(f"Origen = {str(origen)}")
print("Recorrido en anchura:")
print(anchura)
self.ui.salida.insertPlainText('\n\nRecorrido en anchura:\n')
self.ui.salida.insertPlainText(anchura)
print("Recorrido en profundidad:")
print(profundidad)
self.ui.salida.insertPlainText('\nRecorrido en profundidad:\n')
self.ui.salida.insertPlainText(profundidad)
self.ui.salida.ensureCursorVisible()
@Slot()
def sort_plain(self,index):
self.ui.plainTextSort.setCurrentIndex(index)
self.ui.tableSort.setCurrentIndex(index)
self.mostrar()
def wheelEvent(self, event):
if event.delta() > 0:
self.ui.graphicsView.scale(1.2, 1.2)
else:
self.ui.graphicsView.scale(0.8, 0.8)
@Slot()
def dibujar(self):
self.scene.clear()
if len(self.cern) > 0:
pen = QPen()
# maxValue = max( [p.velocidad for p in self.cern] )
for particula in self.cern:
color = QColor(int(particula.red), int(particula.green), int(particula.blue))
pen.setColor(color)
# dimension = round(6 - 3 * particula.velocidad / (maxValue+0.1))
dimension = 5
pen.setWidth(dimension)
self.scene.addLine(particula.origen_x+3, particula.origen_y+3, particula.destino_x, particula.destino_y, pen)
self.scene.addEllipse(particula.origen_x, particula.origen_y, dimension, dimension, pen)
self.scene.addEllipse(particula.destino_x, particula.destino_y, dimension, dimension, pen)
@Slot()
def limpiar(self):
self.scene.clear()
@Slot()
def mostrar_tabla(self):
headers = ['Id','Origen','Destino','Velocidad','Color','Distancia']
self.ui.tabla.setColumnCount(len(headers))
self.ui.tabla.setHorizontalHeaderLabels(headers)
self.ui.tabla.setRowCount(len(self.cern))
for index, part in enumerate(self.cern):
id_widget = QTableWidgetItem(str(part.id))
origen_widget = QTableWidgetItem(f"({part.origen_x},{part.origen_y})")
destino_widget = QTableWidgetItem(f"({part.destino_x},{part.destino_y})")
velocidad_widget = QTableWidgetItem(str(part.velocidad))
color_widget = QTableWidgetItem(f"rgb({part.red},{part.green},{part.blue})")
distancia_widget = QTableWidgetItem(f"{part.distancia:.4f}")
self.ui.tabla.setItem(index,0,id_widget)
self.ui.tabla.setItem(index,1,origen_widget)
self.ui.tabla.setItem(index,2,destino_widget)
self.ui.tabla.setItem(index,3,velocidad_widget)
self.ui.tabla.setItem(index,4,color_widget)
self.ui.tabla.setItem(index,5,distancia_widget)
@Slot()
def buscar_id(self):
id = self.ui.buscar_lineEdit.text().strip()
for part in self.cern:
current_id = str(part.id)
if current_id == id:
self.ui.tabla.clearContents()
self.ui.tabla.setRowCount(1)
id_widget = QTableWidgetItem(str(part.id))
origen_widget = QTableWidgetItem(f"({part.origen_x},{part.origen_y})")
destino_widget = QTableWidgetItem(f"({part.destino_x},{part.destino_y})")
velocidad_widget = QTableWidgetItem(str(part.velocidad))
color_widget = QTableWidgetItem(f"rgb({part.red},{part.green},{part.blue})")
distancia_widget = QTableWidgetItem(f"{part.distancia:.4f}")
self.ui.tabla.setItem(0, 0, id_widget)
self.ui.tabla.setItem(0, 1, origen_widget)
self.ui.tabla.setItem(0, 2, destino_widget)
self.ui.tabla.setItem(0, 3, velocidad_widget)
self.ui.tabla.setItem(0, 4, color_widget)
self.ui.tabla.setItem(0, 5, distancia_widget)
return
QMessageBox.warning(
self,
'Atención',
f"La particula con id {id} no pudo ser encontrada"
)
self.ui.buscar_lineEdit.clear()
@Slot()
def abrir_archivo(self):
ubicacion = QFileDialog.getOpenFileName(
self,
'Abrir archivo',
'./examples',
'JSON (*.json)'
)[0]
if self.cern.abrir(ubicacion):
QMessageBox.information(
self,
"Éxito",
"Se abrió el archivo " + ubicacion
)
self.mostrar()
else:
QMessageBox.critical(
self,
"Error",
"Error al abrir el archivo " + ubicacion
)
@Slot()
def guardar_archivo(self):
ubicacion = QFileDialog.getSaveFileName(
self,
'Abrir archivo',
'./examples',
'JSON (*.json)'
)[0]
print("Archivo: " + ubicacion)
if self.cern.guardar(ubicacion):
QMessageBox.information(
self,
"Éxito",
"Se guardó en el archivo " + ubicacion
)
else:
QMessageBox.critical(
self,
"Error",
"Error al guardar el archivo " + ubicacion
)
@Slot()
def agregar_inicio(self):
self.cern.agregar_inicio(self.get_particula())
self.mostrar()
@Slot()
def agregar_fin(self):
self.cern.agregar_final(self.get_particula())
self.mostrar()
@Slot()
def mostrar_grafo(self):
self.grafo = True
self.mostrar()
@Slot()
def mostrar_plano(self):
self.grafo = False
self.mostrar()
@Slot()
def mostrar(self):
self.ui.salida.clear()
index = self.ui.tableSort.currentIndex()
if index == 0:
self.cern.sort_by_id()
elif index == 1:
self.cern.sort_by_distancia()
elif index == 2:
self.cern.sort_by_velocidad()
if self.grafo:
grafo = self.cern.to_dict()
formated = pformat(grafo, width=40, indent=1)
print(formated)
self.ui.salida.insertPlainText(formated)
else:
self.ui.salida.insertPlainText(str(self.cern))
self.mostrar_tabla()
self.dibujar()
def get_particula(self):
id = int(self.ui.id.text())
orig_x = int(self.ui.origin_x.text())
orig_y = int(self.ui.origin_y.text())
dest_x = int(self.ui.destination_x.text())
dest_y = int(self.ui.destination_y.text())
velocidad = int(self.ui.velocity.text())
color_r = int(self.ui.color_r.text())
color_g = int(self.ui.color_g.text())
color_b = int(self.ui.color_b.text())
return Particula(id,orig_x,orig_y,dest_x,dest_y,velocidad,color_r,color_g,color_b)
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.administra = Administrador()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.AgFinal_pushButton.clicked.connect(self.click_capturar)
self.ui.AgInicio_pushButton.clicked.connect(self.click_capturar_Inicio)
self.ui.Mostrar_pushButton.clicked.connect(self.click_mostrar)
self.ui.actionAbrir.triggered.connect(self.actio_abrir_archivo)
self.ui.actionGuardar.triggered.connect(self.actio_guardar_archivo)
self.ui.actionPor_ID.triggered.connect(self.Ordenar_ID)
self.ui.actionPor_Distancia.triggered.connect(self.Ordenar_Distancia)
self.ui.actionPor_Velocidad.triggered.connect(self.Ordenar_Velocida)
self.ui.Mostrar_Tabla_PushButton.clicked.connect(self.mostrar_tabla)
self.ui.Buscar_Tabla_PushButton.clicked.connect(self.buscar_id)
self.ui.Dibujar_dibujo_pushButton.clicked.connect(self.Dibujar_part)
self.ui.Limpiar_dibujo_pushButton.clicked.connect(self.Limpiar_part)
self.scene = QGraphicsScene()
self.ui.graphicsView.setScene(self.scene)
self.sceneG = QGraphicsScene()
self.ui.Grafo_graphicsView.setScene(self.sceneG)
self.ui.Grafo_L_pushButton.clicked.connect(self.Limpiar_Grafo)
self.ui.Grafo_M_pushButton.clicked.connect(self.Mostrar_Grafo)
self.ui.Busqueda_pushButton.clicked.connect(self.Buscar_Grafo)
@Slot()
def Buscar_Grafo(self):
self.ui.Busquedas_plainTextEdit.clear()
grafo = dict()
for particula in self.administra:
o_x = str(particula.origen_x).upper()
o_y = str(particula.origen_y).upper()
d_x = str(particula.destino_x).upper()
d_y = str(particula.destino_y).upper()
origen = o_x, o_y
destino = d_x, d_y
if origen in grafo:
grafo[origen].append(destino)
else:
grafo[origen] = [destino]
if destino in grafo:
grafo[destino].append(origen)
else:
grafo[destino] = [origen]
UbicX = self.ui.Busqueda_x_spinBox.value()
UbicY = self.ui.Busqued_y_spinBox.value()
Ubicacion_X = str(UbicX).upper()
Ubicacion_Y = str(UbicY).upper()
Ubicacion = Ubicacion_X, Ubicacion_Y
if Ubicacion in grafo:
adyacencia = Ubicacion
visitados = []
pila = deque()
recorrido = []
visitados.append(adyacencia)
pila.append(adyacencia)
while len(pila) != 0:
vertice = pila[-1]
recorrido.append(vertice)
pila.pop()
for ady in grafo[vertice]:
if ady not in visitados:
visitados.append(ady)
pila.append(ady)
self.ui.Busquedas_plainTextEdit.insertPlainText('Profundidad\n')
for parte in recorrido:
self.ui.Busquedas_plainTextEdit.insertPlainText(str(parte))
self.ui.Busquedas_plainTextEdit.insertPlainText('\n')
self.ui.Busquedas_plainTextEdit.insertPlainText('\n\n')
adyacencia2 = Ubicacion
visitados2 = []
cola = deque()
recorrido2 = []
visitados2.append(adyacencia2)
cola.append(adyacencia2)
while len(cola) != 0:
vertice2 = cola[0]
recorrido2.append(vertice2)
cola.popleft()
for ady2 in grafo[vertice2]:
if ady2 not in visitados2:
visitados2.append(ady2)
cola.append(ady2)
self.ui.Busquedas_plainTextEdit.insertPlainText('Amplitud\n')
for parte in recorrido2:
self.ui.Busquedas_plainTextEdit.insertPlainText(str(parte))
self.ui.Busquedas_plainTextEdit.insertPlainText('\n')
else:
QMessageBox.critical(self, "Error",
"Esta ubicacion no se encuentra en el grafo")
@Slot()
def Mostrar_Grafo(self):
grafo = dict()
for particula in self.administra:
o_x = str(particula.origen_x).upper()
o_y = str(particula.origen_y).upper()
d_x = str(particula.destino_x).upper()
d_y = str(particula.destino_y).upper()
peso = int(particula.distancia)
origen = o_x, o_y
destino = d_x, d_y
arista_o_d = (destino, peso)
arista_d_o = (origen, peso)
if origen in grafo:
grafo[origen].append(arista_o_d)
else:
grafo[origen] = [arista_o_d]
if destino in grafo:
grafo[destino].append(arista_d_o)
else:
grafo[destino] = [arista_d_o]
strn = pformat(grafo, width=40, indent=1)
for particula in self.administra:
pen = QPen()
pen.setWidth(2)
color = QColor(particula.red, particula.green, particula.blue)
pen.setColor(color)
self.sceneG.addEllipse(particula.origen_x, particula.origen_y, 3,
3, pen)
self.sceneG.addEllipse(particula.destino_x, particula.destino_y, 3,
3, pen)
self.sceneG.addLine(particula.origen_x + 3, particula.origen_y + 3,
particula.destino_x, particula.destino_y, pen)
self.ui.Grafo_plainTextEdit.clear()
self.ui.Grafo_plainTextEdit.insertPlainText(strn)
@Slot()
def Limpiar_Grafo(self):
self.sceneG.clear()
self.ui.Grafo_plainTextEdit.clear()
@Slot()
def Dibujar_part(self):
for particula in self.administra:
pen = QPen()
pen.setWidth(2)
color = QColor(particula.red, particula.green, particula.blue)
pen.setColor(color)
self.scene.addEllipse(particula.origen_x, particula.origen_y, 3, 3,
pen)
self.scene.addEllipse(particula.destino_x, particula.destino_y, 3,
3, pen)
self.scene.addLine(particula.origen_x + 3, particula.origen_y + 3,
particula.destino_x, particula.destino_y, pen)
def wheelEvent(self, event):
if event.delta() > 0:
self.ui.graphicsView.scale(1.2, 1.2)
else:
self.ui.graphicsView.scale(0.8, 0.8)
if event.delta() > 0:
self.ui.Grafo_graphicsView.scale(1.2, 1.2)
else:
self.ui.Grafo_graphicsView.scale(0.8, 0.8)
@Slot()
def Limpiar_part(self):
self.scene.clear()
@Slot()
def buscar_id(self):
identificador = self.ui.Buscar_Tabla_lineEdit.text()
Encontrado = False
for particula in self.administra:
if identificador == str(particula.ide):
self.ui.Tabla.clear()
self.ui.Tabla.setRowCount(1)
ide_widget = QTableWidgetItem(str(particula.ide))
origen_x_widget = QTableWidgetItem(str(particula.origen_x))
origen_y_widget = QTableWidgetItem(str(particula.origen_y))
destino_x_widget = QTableWidgetItem(str(particula.destino_x))
destino_y_widget = QTableWidgetItem(str(particula.destino_y))
velocidad_widget = QTableWidgetItem(str(particula.velocidad))
distancia_widget = QTableWidgetItem(str(particula.distancia))
red_widget = QTableWidgetItem(str(particula.red))
green_widget = QTableWidgetItem(str(particula.green))
blue_widget = QTableWidgetItem(str(particula.blue))
self.ui.Tabla.setItem(0, 0, ide_widget)
self.ui.Tabla.setItem(0, 1, origen_x_widget)
self.ui.Tabla.setItem(0, 2, origen_y_widget)
self.ui.Tabla.setItem(0, 3, destino_x_widget)
self.ui.Tabla.setItem(0, 4, destino_y_widget)
self.ui.Tabla.setItem(0, 5, velocidad_widget)
self.ui.Tabla.setItem(0, 6, distancia_widget)
self.ui.Tabla.setItem(0, 7, red_widget)
self.ui.Tabla.setItem(0, 8, green_widget)
self.ui.Tabla.setItem(0, 9, blue_widget)
Encontrado = True
return
if not Encontrado:
QMessageBox.warning(
self, "Atencion", "La particula con identificador " +
identificador + " no fue encontrada")
@Slot()
def mostrar_tabla(self):
self.ui.Tabla.setColumnCount(10)
headers = [
"ID", "Origen_X", "Origen_Y", "Destino_X", "Destino_Y",
"Velocidad", "Distancia", "Red", "Green", "Blue"
]
self.ui.Tabla.setHorizontalHeaderLabels(headers)
self.ui.Tabla.setRowCount(len(self.administra))
row = 0
for particula in self.administra:
ide_widget = QTableWidgetItem(str(particula.ide))
origen_x_widget = QTableWidgetItem(str(particula.origen_x))
origen_y_widget = QTableWidgetItem(str(particula.origen_y))
destino_x_widget = QTableWidgetItem(str(particula.destino_x))
destino_y_widget = QTableWidgetItem(str(particula.destino_y))
velocidad_widget = QTableWidgetItem(str(particula.velocidad))
distancia_widget = QTableWidgetItem(str(particula.distancia))
red_widget = QTableWidgetItem(str(particula.red))
green_widget = QTableWidgetItem(str(particula.green))
blue_widget = QTableWidgetItem(str(particula.blue))
self.ui.Tabla.setItem(row, 0, ide_widget)
self.ui.Tabla.setItem(row, 1, origen_x_widget)
self.ui.Tabla.setItem(row, 2, origen_y_widget)
self.ui.Tabla.setItem(row, 3, destino_x_widget)
self.ui.Tabla.setItem(row, 4, destino_y_widget)
self.ui.Tabla.setItem(row, 5, velocidad_widget)
self.ui.Tabla.setItem(row, 6, distancia_widget)
self.ui.Tabla.setItem(row, 7, red_widget)
self.ui.Tabla.setItem(row, 8, green_widget)
self.ui.Tabla.setItem(row, 9, blue_widget)
row += 1
@Slot()
def actio_abrir_archivo(self):
ubicacion = QFileDialog.getOpenFileName(self, 'Abrir Archivo', '.',
'JSON (*.json)')[0]
if self.administra.abrir(ubicacion):
QMessageBox.information(self, "Exito",
"Se abrio el archivo " + ubicacion)
else:
QMessageBox.critical(self, "Error",
"Error al abrir el archivo " + ubicacion)
@Slot()
def actio_guardar_archivo(self):
ubicacion = QFileDialog.getSaveFileName(self, 'Guardar Archivo', '.',
'JSON (*.json)')[0]
print(ubicacion)
if self.administra.guardar(ubicacion):
QMessageBox.information(self, "Exito",
"Se pudo crear el archivo " + ubicacion)
else:
QMessageBox.critical(self, "Error",
"No se pud crear el archivo " + ubicacion)
@Slot()
def Ordenar_ID(self):
self.administra.ordenar()
@Slot()
def Ordenar_Distancia(self):
self.administra.ordenar_distancia()
@Slot()
def Ordenar_Velocida(self):
self.administra.ordenar_velocidad()
@Slot()
def click_mostrar(self):
self.ui.plainTextEdit.clear()
self.ui.plainTextEdit.insertPlainText(str(self.administra))
@Slot()
def click_capturar(self):
Ide = self.ui.ID_spinBox.value()
OrigenX = self.ui.OrigenX_spinBox.value()
OrigenY = self.ui.OrigenY_spinBox.value()
DestinoX = self.ui.DestinoX_spinBox.value()
DestinoY = self.ui.DestinoY_spinBox.value()
Velocidad = self.ui.Velocidad_spinBox.value()
Red = self.ui.ColorRed_spinBox.value()
Green = self.ui.ColorGreen_spinBox.value()
Blue = self.ui.ColorBlue_spinBox.value()
particula = Particula(Ide, OrigenX, OrigenY, DestinoX, DestinoY,
Velocidad, Red, Green, Blue)
self.administra.agregar_final(particula)
@Slot()
def click_capturar_Inicio(self):
Ide = self.ui.ID_spinBox.value()
OrigenX = self.ui.OrigenX_spinBox.value()
OrigenY = self.ui.OrigenY_spinBox.value()
DestinoX = self.ui.DestinoX_spinBox.value()
DestinoY = self.ui.DestinoY_spinBox.value()
Velocidad = self.ui.Velocidad_spinBox.value()
Red = self.ui.ColorRed_spinBox.value()
Green = self.ui.ColorGreen_spinBox.value()
Blue = self.ui.ColorBlue_spinBox.value()
particula = Particula(Ide, OrigenX, OrigenY, DestinoX, DestinoY,
Velocidad, Red, Green, Blue)
self.administra.agregar_inicio(particula)
class MainWindow(QMainWindow):
def __init__(self):
super().__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.scene = QGraphicsScene()
#self.scene.setSceneRect(0,500)
self.ui.graphicsView.setScene(self.scene)
self.pen = QPen()
self.pen.setColor(QColor(0, 0, 0))
self.pen.setWidth(1)
self.capturador = Capturador()
self.ui.pushButton.clicked.connect(self.click)
self.ui.pushButton_2.clicked.connect(self.mostrar)
self.ui.actionGuardar.triggered.connect(self.guardar)
self.ui.actionAbrir_2.triggered.connect(self.abrir)
self.ui.pushButton_3.clicked.connect(self.ordenar_velocidad)
self.ui.pushButton_4.clicked.connect(self.ordenar_distancia)
@Slot()
def ordenar_velocidad(self):
self.scene.clear()
self.scene = QGraphicsScene()
#self.scene.setSceneRect(0,500)
self.ui.graphicsView.setScene(self.scene)
self.pen = QPen()
self.pen.setColor(QColor(0, 0, 0))
self.pen.setWidth(1)
self.capturador.ordenar_velocidad()
y = 0
for particula in self.capturador.lista:
self.ui.plainTextEdit.insertPlainText(str(particula))
self.pen.setColor(
QColor(particula.red, particula.green, particula.blue))
self.scene.addLine(0, y, particula.distancia, y, self.pen)
y = y + 2
@Slot()
def ordenar_distancia(self):
self.scene.clear()
self.scene = QGraphicsScene()
#self.scene.setSceneRect(0,500)
self.ui.graphicsView.setScene(self.scene)
self.pen = QPen()
self.pen.setColor(QColor(0, 0, 0))
self.pen.setWidth(1)
self.capturador.ordenar_distancia()
y = 0
for particula in self.capturador.lista:
self.ui.plainTextEdit.insertPlainText(str(particula))
self.pen.setColor(
QColor(particula.red, particula.green, particula.blue))
self.scene.addLine(0, y, particula.distancia, y, self.pen)
y = y + 2
@Slot()
def guardar(self):
self.scene = QGraphicsScene()
#self.scene.setSceneRect(0,500)
self.ui.graphicsView.setScene(self.scene)
self.pen = QPen()
self.pen.setColor(QColor(0, 0, 0))
self.pen.setWidth(1)
file = QFileDialog.getSaveFileName(self, 'Guardar archivo...', '.',
'JSON (*.json)')
print(file)
self.capturador.guardar(file[0], self.pen, self.scene)
@Slot()
def abrir(self):
file = QFileDialog.getOpenFileName(self, 'Abrir archivo', '.',
'JSON (*.json)')
self.capturador.recuperar(file[0])
@Slot()
def mostrar(self):
self.scene.clear()
self.scene.addLine(0, 0, 499, 0, self.pen)
y = 0
for particula in self.capturador.lista:
self.ui.plainTextEdit.insertPlainText(str(particula))
self.pen.setColor(
QColor(particula.red, particula.green, particula.blue))
self.scene.addLine(0, y, particula.distancia, y, self.pen)
y = y + 2
#for particula in self.capturador.lista:
# self.ui.plainTextEdit.insertPlainText(str(particula))
# self.pen.setColor(QColor(particula.red, particula.green, particula.blue))
# self.scene.addEllipse(particula.origenX, particula.origenY, 5, 5, self.pen, QBrush(QColor(particula.red, 10,particula.green, particula.blue)))
#self.scene.addLine(particula.origenX, particula.origenY, particula.destinoX, particula.destinoY, self.pen)
#self.paqueteria.mostrar()
@Slot()
def click(self):
id = self.ui.lineEdit.text()
origenX = self.ui.lineEdit_2.text()
origenY = self.ui.lineEdit_6.text()
destinoX = self.ui.lineEdit_3.text()
destinoY = self.ui.lineEdit_7.text()
velocidad = self.ui.lineEdit_4.text()
red = self.ui.lineEdit_5.text()
green = self.ui.lineEdit_8.text()
blue = self.ui.lineEdit_9.text()
print(id, origenX, origenY, destinoX, destinoY, velocidad, red, green,
blue)
partiula = Particula()
partiula.id = id
partiula.origenX = int(origenX)
partiula.origenY = int(origenY)
partiula.destinoX = int(destinoX)
partiula.destinoY = int(destinoY)
partiula.distancia = math.sqrt(
pow((int(destinoX) - int(origenX)), 2) +
pow((int(destinoY) - int(origenY)), 2))
partiula.red = int(red)
partiula.green = int(green)
partiula.blue = int(blue)
partiula.velocidad = int(velocidad)
self.capturador.agregar(partiula)
msg = QMessageBox.information(
self, 'Exito', 'Se agrego paquete con exito'
) #Ventana de mensaje de la libreria QMessageBox
self.ui.lineEdit.clear() #Limpiar campos
self.ui.lineEdit_2.clear()
self.ui.lineEdit_3.clear()
self.ui.lineEdit_4.clear()
self.ui.lineEdit_5.clear()
self.ui.lineEdit_6.clear()
self.ui.lineEdit_7.clear()
self.ui.lineEdit_8.clear()
self.ui.lineEdit_9.clear()
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.adm_part = Adm_part()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.agregar_final_pushButton.clicked.connect(self.click_agregar)
self.ui.agregar_inicio_pushButton.clicked.connect(
self.click_agregar_inicio)
self.ui.mostrar_pushButton.clicked.connect(self.click_mostrar)
self.ui.actionAbrir.triggered.connect(self.action_abrir_archivo)
self.ui.actionGuardar.triggered.connect(self.action_guardar_archivo)
self.ui.mostrar_tabla_pushButton.clicked.connect(self.mostrar_tabla)
self.ui.buscar_pushButton.clicked.connect(self.buscar_id)
self.ui.dibujar.clicked.connect(self.dibujar)
self.ui.limpiar.clicked.connect(self.limpiar)
self.scene = QGraphicsScene()
self.ui.graphicsView.setScene(self.scene)
def wheelEvent(self, event):
if event.delta() > 0:
self.ui.graphicsView.scale(1.2, 1.2)
else:
self.ui.graphicsView.scale(0.8, 0.8)
@Slot()
def dibujar(self):
pen = QPen()
pen.setWidth(2)
for particula in self.adm_part:
r = int(particula.rojo)
g = int(particula.verde)
b = int(particula.azul)
color = QColor(r, g, b)
pen.setColor(color)
origen_x = int(particula.origen_x)
origen_y = int(particula.origen_y)
destino_x = int(particula.destino_x)
destino_y = int(particula.destino_y)
self.scene.addEllipse(origen_x, origen_y, 3, 3, pen)
self.scene.addEllipse(destino_x, destino_y, 3, 3, pen)
self.scene.addLine(origen_x + 3, origen_y + 3, destino_x,
destino_y, pen)
@Slot()
def limpiar(self):
self.scene.clear()
@Slot()
def buscar_id(self):
id = self.ui.buscar_spinBox.value()
encontrado = False
for particula in self.adm_part:
if id == particula.id:
self.ui.tabla.clear()
self.ui.tabla.setRowCount(1)
id_widget = QTableWidgetItem(str(particula.id))
origen_x_widget = QTableWidgetItem(str(particula.origen_x))
origen_y_widget = QTableWidgetItem(str(particula.origen_y))
destino_x_widget = QTableWidgetItem(str(particula.destino_x))
destino_y_widget = QTableWidgetItem(str(particula.destino_y))
velocidad_widget = QTableWidgetItem(str(particula.velocidad))
rojo_widget = QTableWidgetItem(str(particula.rojo))
verde_widget = QTableWidgetItem(str(particula.verde))
azul_widget = QTableWidgetItem(str(particula.azul))
distancia_widget = QTableWidgetItem(str(particula.distancia))
self.ui.tabla.setItem(0, 0, id_widget)
self.ui.tabla.setItem(0, 1, origen_x_widget)
self.ui.tabla.setItem(0, 2, origen_y_widget)
self.ui.tabla.setItem(0, 3, destino_x_widget)
self.ui.tabla.setItem(0, 4, destino_y_widget)
self.ui.tabla.setItem(0, 5, velocidad_widget)
self.ui.tabla.setItem(0, 6, rojo_widget)
self.ui.tabla.setItem(0, 7, verde_widget)
self.ui.tabla.setItem(0, 8, azul_widget)
self.ui.tabla.setItem(0, 9, distancia_widget)
encontrado = True
return
if not encontrado:
QMessageBox.warning(
self, "Atención",
f'La particula con el ID "{id}" no fue encontrada')
@Slot()
def mostrar_tabla(self):
self.ui.tabla.setColumnCount(10)
headers = [
"ID", "Origen en x", "Origen en y", "Destino en x", "Destino en y",
"Velocidad", "Rojo", "Verde", "Azul", "Distancia"
]
self.ui.tabla.setHorizontalHeaderLabels(headers)
self.ui.tabla.setRowCount(len(self.adm_part))
row = 0
for particula in self.adm_part:
id_widget = QTableWidgetItem(str(particula.id))
origen_x_widget = QTableWidgetItem(str(particula.origen_x))
origen_y_widget = QTableWidgetItem(str(particula.origen_y))
destino_x_widget = QTableWidgetItem(str(particula.destino_x))
destino_y_widget = QTableWidgetItem(str(particula.destino_y))
velocidad_widget = QTableWidgetItem(str(particula.velocidad))
rojo_widget = QTableWidgetItem(str(particula.rojo))
verde_widget = QTableWidgetItem(str(particula.verde))
azul_widget = QTableWidgetItem(str(particula.azul))
distancia_widget = QTableWidgetItem(str(particula.distancia))
self.ui.tabla.setItem(row, 0, id_widget)
self.ui.tabla.setItem(row, 1, origen_x_widget)
self.ui.tabla.setItem(row, 2, origen_y_widget)
self.ui.tabla.setItem(row, 3, destino_x_widget)
self.ui.tabla.setItem(row, 4, destino_y_widget)
self.ui.tabla.setItem(row, 5, velocidad_widget)
self.ui.tabla.setItem(row, 6, rojo_widget)
self.ui.tabla.setItem(row, 7, verde_widget)
self.ui.tabla.setItem(row, 8, azul_widget)
self.ui.tabla.setItem(row, 9, distancia_widget)
row += 1
@Slot()
def action_abrir_archivo(self):
#print('abrir_archivo')
ubicacion = QFileDialog.getOpenFileName(self, 'Abrir archivo', '.',
'JSON(*.json)')[0]
if self.adm_part.abrir(ubicacion):
QMessageBox.information(self, "Exito",
"Se abrió el archivo " + ubicacion)
else:
QMessageBox.critical(self, "Error",
"No se pudo abrir el archivo " + ubicacion)
@Slot()
def action_guardar_archivo(self):
#print('guardar_archivo')
ubicacion = QFileDialog.getSaveFileName(self, 'Guardar Archivo', '.',
'JSON (*.json)')[0]
print(ubicacion)
if self.adm_part.guardar(ubicacion):
QMessageBox.information(self, "Exito",
"Se pudo crear el archivo " + ubicacion)
else:
QMessageBox.critical(self, "Error",
"No se pudo crear el archivo " + ubicacion)
@Slot()
def click_mostrar(self):
#self.adm_part.mostrar()
self.ui.plainTextEdit.clear()
self.ui.plainTextEdit.insertPlainText(str(self.adm_part))
@Slot()
def click_agregar(self):
id = self.ui.id_spinBox.value()
origen_x = self.ui.origen_x_spinBox.value()
origen_y = self.ui.origen_y_spinBox.value()
destino_x = self.ui.destino_x_spinBox.value()
destino_y = self.ui.destino_y_spinBox.value()
velocidad = self.ui.velocidad_spinBox.value()
rojo = self.ui.rojo_spinBox.value()
azul = self.ui.azul_spinBox.value()
verde = self.ui.verde_spinBox.value()
particula = Particula(id, origen_x, origen_y, destino_x, destino_y,
velocidad, rojo, verde, azul)
self.adm_part.agregar_final(particula)
#print(id,origen_x,origen_y,destino_x,destino_y,rojo,azul,verde)
#self.ui.plainTextEdit.insertPlainText(id + origen_x + origen_y +
#destino_x + destino_y + rojo + azul + verde)
@Slot()
def click_agregar_inicio(self):
id = self.ui.id_spinBox.value()
origen_x = self.ui.origen_x_spinBox.value()
origen_y = self.ui.origen_y_spinBox.value()
destino_x = self.ui.destino_x_spinBox.value()
destino_y = self.ui.destino_y_spinBox.value()
velocidad = self.ui.velocidad_spinBox.value()
rojo = self.ui.rojo_spinBox.value()
azul = self.ui.azul_spinBox.value()
verde = self.ui.verde_spinBox.value()
particula = Particula(id, origen_x, origen_y, destino_x, destino_y,
velocidad, rojo, verde, azul)
self.adm_part.agregar_inicio(particula)
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.particula = Particula()
self.particulas = Particulas()
#al declarar el objeto de manera globar ya podemos crear particulas
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.Inicio_pushButton.clicked.connect(self.agregar_Particula_Inicio)
self.ui.Final_pushButton.clicked.connect(self.agregar_Particula_Final)
self.ui.pushButton_2.clicked.connect(self.mostrar_Particula)
self.ui.actionAbrir.triggered.connect(self.action_abrir_archivo)
self.ui.actionGuardar.triggered.connect(self.action_guardar_archivo)
self.ui.mostrar_tabla_pushButton.clicked.connect(self.mostrar_tabla)
self.ui.buscar_pushButton.clicked.connect(self.buscar_titulo)
self.ui.dibujar.clicked.connect(self.dibujar)
self.ui.limpiar.clicked.connect(self.limpiar)
self.scene = QGraphicsScene()
self.ui.graphicsView.setScene(self.scene)
def wheelEvent(self, event):
if event.delta() > 0:
self.ui.graphicsView.scale(1.2, 1.2)
else:
self.ui.graphicsView.scale(0.8, 0.8)
@Slot()
def dibujar(self):
pen = QPen()
pen.setWidth(2)
for particula in self.particulas:
R = particula.colorR
G = particula.colorG
B = particula.colorB
color = QColor (R,G,B)
pen.setColor(color)
self.scene.addEllipse(particula.origenX, particula.origenY,3,3,pen)
self.scene.addEllipse(particula.destinoX, particula.destinoY,3,3,pen)
self.scene.addLine(particula.origenX+3, particula.origenY+3, particula.destinoX, particula.destinoY, pen)
print(color)
@Slot()
def limpiar(self):
self.scene.clear()
@Slot()
def buscar_titulo(self):
id = self.ui.buscar_lineEdit.text()
encontrado = False
for particula in self.particulas:
if id == particula.id:
self.ui.tabla.clear() #vacia la filas para poner el libro
self.ui.tabla.setRowCount(1) #nada mas tendra una fila
id_widget = QTableWidgetItem(particula.id)
origenX_widget = QTableWidgetItem(str(particula.origenX))
origenY_widget = QTableWidgetItem(str(particula.origenY))
destinoX_widget = QTableWidgetItem(str(particula.destinoX))
destinoY_widget = QTableWidgetItem(str(particula.destinoY))
velocidad_widget = QTableWidgetItem(str(particula.velocidad))
colorR_widget = QTableWidgetItem(str(particula.colorR))
colorG_widget = QTableWidgetItem(str(particula.colorG))
colorB_widget = QTableWidgetItem(str(particula.colorB))
distancia_widget = QTableWidgetItem(str(particula.distancia))
self.ui.tabla.setItem(0, 0,id_widget)
self.ui.tabla.setItem(0, 1,origenX_widget)
self.ui.tabla.setItem(0, 2,origenY_widget)
self.ui.tabla.setItem(0, 3,destinoX_widget)
self.ui.tabla.setItem(0, 4,destinoY_widget)
self.ui.tabla.setItem(0, 5,velocidad_widget)
self.ui.tabla.setItem(0, 6,colorR_widget)
self.ui.tabla.setItem(0, 7,colorG_widget)
self.ui.tabla.setItem(0, 8,colorB_widget)
self.ui.tabla.setItem(0, 9,distancia_widget)
encontrado = True
return
if not encontrado:
QMessageBox.warning(
self,
"Atencion",
f'ERROR -> La Particula con el ID: "{id}" no se encontro'
)
@Slot()
def mostrar_tabla(self):
self.ui.tabla.setColumnCount(10)
headers = ["ID","Origen X","Origen Y","Destino X", "Destino Y","Velocidad","Color R","Color G","Color B","Distancia"]
self.ui.tabla.setHorizontalHeaderLabels(headers) # en la cabecera imprime los nombres
self.ui.tabla.setRowCount(len(self.particulas)) # crea la cantidad de lineas dependiendo de las particulas que hemmos insertado
row = 0
for particula in self.particulas:
id_widget = QTableWidgetItem(particula.id)
origenX_widget = QTableWidgetItem(str(particula.origenX))
origenY_widget = QTableWidgetItem(str(particula.origenY))
destinoX_widget = QTableWidgetItem(str(particula.destinoX))
destinoY_widget = QTableWidgetItem(str(particula.destinoY))
velocidad_widget = QTableWidgetItem(str(particula.velocidad))
colorR_widget = QTableWidgetItem(str(particula.colorR))
colorG_widget = QTableWidgetItem(str(particula.colorG))
colorB_widget = QTableWidgetItem(str(particula.colorB))
distancia_widget = QTableWidgetItem(str(particula.distancia))
self.ui.tabla.setItem(row, 0,id_widget)
self.ui.tabla.setItem(row, 1,origenX_widget)
self.ui.tabla.setItem(row, 2,origenY_widget)
self.ui.tabla.setItem(row, 3,destinoX_widget)
self.ui.tabla.setItem(row, 4,destinoY_widget)
self.ui.tabla.setItem(row, 5,velocidad_widget)
self.ui.tabla.setItem(row, 6,colorR_widget)
self.ui.tabla.setItem(row, 7,colorG_widget)
self.ui.tabla.setItem(row, 8,colorB_widget)
self.ui.tabla.setItem(row, 9,distancia_widget)
row += 1 # incrementamos el contador de fila para que no se escriban encima
@Slot()
def action_abrir_archivo(self):
#print('Abrir_archivo')
ubicacion = QFileDialog.getOpenFileName(
self,
'Abrir Archivo', #el nombre del archivo
'.', #donde lo va a guardar, en este caso en la carpeta del proyecto
'JSON (*.json)' #Tipo de formato
)[0]
if self.particulas.abrir(ubicacion):
QMessageBox.information(
self,
"Éxito",
"Se abrió el archivo " + ubicacion
)
else:
QMessageBox.information(
self,
"Error",
"Error al abrir el archivo " + ubicacion
)
@Slot()
def action_guardar_archivo(self):
#print('Guardar_archivo')
ubicacion = QFileDialog.getSaveFileName(
self,
'Guardar Archivo', #el nombre del archivo
'.', #donde lo va a guardar, en este caso en la carpeta del proyecto
'JSON (*.json)' #Tipo de formato
)[0]
print(ubicacion)
if self.particulas.guardar(ubicacion):
QMessageBox.information(
self, #desde donde se manda
"Éxito", #nombre de la ventana
"Se pudo crear el archivo " + ubicacion #mensaje
)
else:
QMessageBox.critical(
self,
"Error",
"No se pudo crear el archivo " + ubicacion
)
@Slot()
def agregar_Particula_Inicio(self):
id = self.ui.ID_lineEdit.text()
origenX = self.ui.origenX_spinBox.value()
origenY = self.ui.origenY_spinBox.value()
destinoX = self.ui.destinoX_spinBox.value()
destinoY = self.ui.destinoY_spinBox.value()
velocidad = self.ui.velocidad_spinBox.value()
colorR = self.ui.R_spinBox.value()
colorG = self.ui.G_spinBox.value()
colorB = self.ui.B_spinBox.value()
particula = Particula(id, origenX, origenY, destinoX, destinoY, velocidad, colorR, colorG, colorB)
self.particulas.agregar_inicio(particula)
@Slot()
def agregar_Particula_Final(self):
id = self.ui.ID_lineEdit.text()
origenX = self.ui.origenX_spinBox.value()
origenY = self.ui.origenY_spinBox.value()
destinoX = self.ui.destinoX_spinBox.value()
destinoY = self.ui.destinoY_spinBox.value()
velocidad = self.ui.velocidad_spinBox.value()
colorR = self.ui.R_spinBox.value()
colorG = self.ui.G_spinBox.value()
colorB = self.ui.B_spinBox.value()
particula = Particula(id, origenX, origenY, destinoX, destinoY, velocidad, colorR, colorG, colorB)
self.particulas.agregar_final(particula)
@Slot()
def mostrar_Particula(self):
#self.particulas.mostrar()
self.ui.salida.clear(
)
self.ui.salida.insertPlainText(str(self.particulas))
class MainWindow(QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.libreria = Libreria()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.agregar_pushButton.clicked.connect(
self.click_agregar) #agregado
self.ui.mostrar_pushButton.clicked.connect(self.mostrar) #agregado
self.ui.ordenar_velocidad_pushButton.clicked.connect(
self.ordenar_velocidad)
self.ui.ordenar_distancia_pushButton.clicked.connect(
self.ordenar_distancia)
self.ui.actionguardar.triggered.connect(self.action_guardar) #agregado
self.ui.actionabrir.triggered.connect(self.action_abrir) #agregado
self.ui.actiongrafo.triggered.connect(self.mostrar_diccionario)
self.ui.actionRecorrido_en_Profundidad_Amplitud.triggered.connect(
self.recorrido_p_a)
self.grafo = {}
self.scene = QGraphicsScene()
self.ui.graphicsView.setScene(self.scene)
def wheelEvent(self, event):
if event.delta() > 0:
self.ui.graphicsView.scale(1.2, 1.2)
else:
self.ui.graphicsView.scale(0.8, 0.8)
@Slot()
def recorrido_p_a(self):
origen_x = self.ui.origen_x_spinBox.value() #toma de valores
origen_y = self.ui.origen_y_spinBox.value()
if not self.libreria.metodo_p(
self.grafo, origen_x,
origen_y): #acceder a metodos y cargar parametros
QMessageBox.warning(self, 'Aviso',
'No es posible leer los valores')
else:
profundidad = self.libreria.metodo_p(self.grafo, origen_x,
origen_y)
print('Profundidad: \n')
self.ui.salida.clear()
self.ui.salida.insertPlainText('Profundidad: ' + '\n')
for i in profundidad:
self.ui.salida.insertPlainText(str(i) + '\n')
print(i)
amplitud = self.libreria.metodo_a(self.grafo, origen_x, origen_y)
print('Amplitud: \n')
self.ui.salida.insertPlainText('Amplitud:' + '\n')
for i in amplitud:
self.ui.salida.insertPlainText(str(i) + '\n')
print(i)
@Slot()
def mostrar_diccionario(self):
self.ui.salida.clear()
self.grafo.clear()
grafo = self.libreria.mostrar_diccionario(self.grafo)
self.ui.salida.insertPlainText(grafo)
QMessageBox.information(self, 'Exito', "Se imprimio el diccionario ")
@Slot()
def click_agregar(self):
id = self.ui.id_spinBox.value()
origen_x = self.ui.origen_x_spinBox.value()
origen_y = self.ui.origen_y_spinBox.value()
destino_x = self.ui.destino_x_spinBox.value()
destino_y = self.ui.destino_y_spinBox.value()
velocidad = self.ui.velocidad_spinBox.value()
red = self.ui.red_spinBox.value()
green = self.ui.green_spinBox.value()
blue = self.ui.blue_spinBox.value()
particula = Particula(id, origen_x, origen_y, destino_x, destino_y,
velocidad, red, green, blue)
self.libreria.agregar(particula)
@Slot()
def mostrar(self):
self.ui.salida.clear()
self.libreria.mostrar()
self.ui.salida.insertPlainText(str(self.libreria))
self.ui.tabla.setColumnCount(10)
headers = [
'ID', 'origen x', 'origen y', 'destino x', 'destino y',
'velocidad', 'red', 'green', 'blue', 'distancia'
]
self.ui.tabla.setHorizontalHeaderLabels(headers)
self.ui.tabla.setRowCount(len(self.libreria))
row = 0
for particula in self.libreria:
id_widget = QTableWidgetItem(str(particula.id))
origen_x_widget = QTableWidgetItem(str(particula.origen_x))
origen_y_widget = QTableWidgetItem(str(particula.origen_y))
destino_x_widget = QTableWidgetItem(str(particula.destino_x))
destino_y_widget = QTableWidgetItem(str(particula.destino_y))
velocidad_widget = QTableWidgetItem(str(particula.velocidad))
red_widget = QTableWidgetItem(str(particula.red))
green_widget = QTableWidgetItem(str(particula.green))
blue_widget = QTableWidgetItem(str(particula.blue))
distancia_widget = QTableWidgetItem(str(particula.distancia))
self.ui.tabla.setItem(row, 0, id_widget)
self.ui.tabla.setItem(row, 1, origen_x_widget)
self.ui.tabla.setItem(row, 2, origen_y_widget)
self.ui.tabla.setItem(row, 3, destino_x_widget)
self.ui.tabla.setItem(row, 4, destino_y_widget)
self.ui.tabla.setItem(row, 5, velocidad_widget)
self.ui.tabla.setItem(row, 6, red_widget)
self.ui.tabla.setItem(row, 7, green_widget)
self.ui.tabla.setItem(row, 8, blue_widget)
self.ui.tabla.setItem(row, 9, distancia_widget)
row += 1
pen = QPen()
pen.setWidth(2)
for particula in self.libreria: #'MainWindow' object has no attribute 'particulas'
r = particula.red
g = particula.green
b = particula.blue
color = QColor(r, g, b)
pen.setColor(color)
self.scene.addEllipse(particula.origen_x, particula.origen_y, 4, 4,
pen)
self.scene.addEllipse(particula.destino_x, particula.destino_y, 4,
4, pen)
self.scene.addLine(particula.origen_x, particula.origen_y,
particula.destino_x, particula.destino_y, pen)
@Slot()
def ordenar_velocidad(self): #ascendente
self.ui.tabla.clear()
self.ui.salida.clear()
headers = [
'ID', 'origen x', 'origen y', 'destino x', 'destino y',
'velocidad', 'red', 'green', 'blue', 'distancia'
]
self.ui.tabla.setHorizontalHeaderLabels(headers)
self.ui.tabla.setRowCount(len(self.libreria))
particulas = []
for particula in self.libreria:
particulas.append(particula)
particulas.sort(key=lambda particula: particula.velocidad,
reverse=False)
row = 0
for particula in particulas:
id_widget = QTableWidgetItem(str(particula.id))
origen_x_widget = QTableWidgetItem(str(particula.origen_x))
origen_y_widget = QTableWidgetItem(str(particula.origen_y))
destino_x_widget = QTableWidgetItem(str(particula.destino_x))
destino_y_widget = QTableWidgetItem(str(particula.destino_y))
velocidad_widget = QTableWidgetItem(str(particula.velocidad))
red_widget = QTableWidgetItem(str(particula.red))
green_widget = QTableWidgetItem(str(particula.green))
blue_widget = QTableWidgetItem(str(particula.blue))
distancia_widget = QTableWidgetItem(str(particula.distancia))
self.ui.tabla.setItem(row, 0, id_widget)
self.ui.tabla.setItem(row, 1, origen_x_widget)
self.ui.tabla.setItem(row, 2, origen_y_widget)
self.ui.tabla.setItem(row, 3, destino_x_widget)
self.ui.tabla.setItem(row, 4, destino_y_widget)
self.ui.tabla.setItem(row, 5, velocidad_widget)
self.ui.tabla.setItem(row, 6, red_widget)
self.ui.tabla.setItem(row, 7, green_widget)
self.ui.tabla.setItem(row, 8, blue_widget)
self.ui.tabla.setItem(row, 9, distancia_widget)
row += 1
for particula in particulas:
self.ui.salida.insertPlainText(str(particula) + '\n')
@Slot()
def ordenar_distancia(self): #descendente
self.ui.tabla.clear()
self.ui.salida.clear()
headers = [
'ID', 'origen x', 'origen y', 'destino x', 'destino y',
'velocidad', 'red', 'green', 'blue', 'distancia'
]
self.ui.tabla.setHorizontalHeaderLabels(headers)
self.ui.tabla.setRowCount(len(self.libreria))
particulas = []
for particula in self.libreria:
particulas.append(particula)
particulas.sort(key=lambda particula: particula.distancia,
reverse=True)
row = 0
for particula in particulas:
id_widget = QTableWidgetItem(str(particula.id))
origen_x_widget = QTableWidgetItem(str(particula.origen_x))
origen_y_widget = QTableWidgetItem(str(particula.origen_y))
destino_x_widget = QTableWidgetItem(str(particula.destino_x))
destino_y_widget = QTableWidgetItem(str(particula.destino_y))
velocidad_widget = QTableWidgetItem(str(particula.velocidad))
red_widget = QTableWidgetItem(str(particula.red))
green_widget = QTableWidgetItem(str(particula.green))
blue_widget = QTableWidgetItem(str(particula.blue))
distancia_widget = QTableWidgetItem(str(particula.distancia))
self.ui.tabla.setItem(row, 0, id_widget)
self.ui.tabla.setItem(row, 1, origen_x_widget)
self.ui.tabla.setItem(row, 2, origen_y_widget)
self.ui.tabla.setItem(row, 3, destino_x_widget)
self.ui.tabla.setItem(row, 4, destino_y_widget)
self.ui.tabla.setItem(row, 5, velocidad_widget)
self.ui.tabla.setItem(row, 6, red_widget)
self.ui.tabla.setItem(row, 7, green_widget)
self.ui.tabla.setItem(row, 8, blue_widget)
self.ui.tabla.setItem(row, 9, distancia_widget)
row += 1
for particula in particulas:
self.ui.salida.insertPlainText(str(particula) + '\n')
@Slot()
def action_abrir(self):
ubicacion = QFileDialog.getOpenFileName(self, 'Abrir Archivo', '.',
'JSON (*.json)')[0]
if self.libreria.abrir(ubicacion):
QMessageBox.information(self, 'Éxito',
'Se abrio el archivo ' + ubicacion)
else:
QMessageBox.critical(self, 'Error',
'Error al abrir el archivo ' + ubicacion)
@Slot() #Hacer uso de la biblioteca json
def action_guardar(self):
ubicacion = QFileDialog.getSaveFileName(self, 'Guardar como', '.',
'JSON (*.json)')[0]
print(ubicacion)
if self.libreria.guardar(ubicacion):
QMessageBox.information(self, 'Éxito',
'Se pudo crear el archivo ' + ubicacion)
else:
QMessageBox.critical(self, 'Error',
'No se pudo crear el archivo ' + ubicacion)
class AddItem(UsesQApplication):
'''Tests for QGraphicsScene.add*'''
qapplication = True
def setUp(self):
#Acquire resources
super(AddItem, self).setUp()
self.scene = QGraphicsScene()
# While the scene does not inherits from QWidget, requires
# an application to make the internals work.
def tearDown(self):
#Release resources
del self.scene
super(AddItem, self).tearDown()
def testEllipse(self):
#QGraphicsScene.addEllipse
item = self.scene.addEllipse(100, 100, 100, 100)
self.assertTrue(isinstance(item, QGraphicsEllipseItem))
def testLine(self):
#QGraphicsScene.addLine
item = self.scene.addLine(100, 100, 200, 200)
self.assertTrue(isinstance(item, QGraphicsLineItem))
def testPath(self):
#QGraphicsScene.addPath
item = self.scene.addPath(QPainterPath())
self.assertTrue(isinstance(item, QGraphicsPathItem))
def testPixmap(self):
#QGraphicsScene.addPixmap
item = self.scene.addPixmap(QPixmap())
self.assertTrue(isinstance(item, QGraphicsPixmapItem))
def testPolygon(self):
#QGraphicsScene.addPolygon
points = [QPointF(0, 0), QPointF(100, 100), QPointF(0, 100)]
item = self.scene.addPolygon(QPolygonF(points))
self.assertTrue(isinstance(item, QGraphicsPolygonItem))
def testRect(self):
#QGraphicsScene.addRect
item = self.scene.addRect(100, 100, 100, 100)
self.assertTrue(isinstance(item, QGraphicsRectItem))
def testSimpleText(self):
#QGraphicsScene.addSimpleText
item = self.scene.addSimpleText('Monty Python 42')
self.assertTrue(isinstance(item, QGraphicsSimpleTextItem))
def testText(self):
#QGraphicsScene.addText
item = self.scene.addText('Monty Python 42')
self.assertTrue(isinstance(item, QGraphicsTextItem))
def testWidget(self):
#QGraphicsScene.addWidget
# XXX: printing some X11 error when using under PyQt4
item = self.scene.addWidget(QPushButton())
self.assertTrue(isinstance(item, QGraphicsProxyWidget))
