def display_culling(self, scene: QGraphicsScene) -> None:
"""Draws the culling distance rings on the map"""
culling_points = self.game_model.game.get_culling_points()
culling_zones = self.game_model.game.get_culling_zones()
culling_distance = self.game_model.game.settings.perf_culling_distance
for point in culling_points:
culling_distance_point = Point(point.x + 2500, point.y + 2500)
distance_point = self._transform_point(culling_distance_point)
transformed = self._transform_point(point)
radius = distance_point[0] - transformed[0]
scene.addEllipse(
transformed[0] - radius,
transformed[1] - radius,
2 * radius,
2 * radius,
CONST.COLORS["transparent"],
CONST.COLORS["light_green_transparent"],
)
for zone in culling_zones:
culling_distance_zone = Point(
zone.x + culling_distance * 1000, zone.y + culling_distance * 1000
)
distance_zone = self._transform_point(culling_distance_zone)
transformed = self._transform_point(zone)
radius = distance_zone[0] - transformed[0]
scene.addEllipse(
transformed[0] - radius,
transformed[1] - radius,
2 * radius,
2 * radius,
CONST.COLORS["transparent"],
CONST.COLORS["light_green_transparent"],
)
def draw_threat_range(self, scene: QGraphicsScene, group: Group,
ground_object: TheaterGroundObject,
cp: ControlPoint) -> None:
go_pos = self._transform_point(ground_object.position)
detection_range = ground_object.detection_range(group)
threat_range = ground_object.threat_range(group)
if threat_range:
threat_pos = self._transform_point(
ground_object.position +
Point(threat_range.meters, threat_range.meters))
threat_radius = Point(*go_pos).distance_to_point(
Point(*threat_pos))
# Add threat range circle
scene.addEllipse(go_pos[0] - threat_radius / 2 + 7,
go_pos[1] - threat_radius / 2 + 6, threat_radius,
threat_radius, self.threat_pen(cp.captured))
if detection_range and DisplayOptions.detection_range:
# Add detection range circle
detection_pos = self._transform_point(
ground_object.position +
Point(detection_range.meters, detection_range.meters))
detection_radius = Point(*go_pos).distance_to_point(
Point(*detection_pos))
scene.addEllipse(go_pos[0] - detection_radius / 2 + 7,
go_pos[1] - detection_radius / 2 + 6,
detection_radius, detection_radius,
self.detection_pen(cp.captured))
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 create_ui(self):
button = QPushButton("Rotate - ", self)
button.setGeometry(200, 450, 100, 50)
button.clicked.connect(self.rotateMinus)
button2 = QPushButton("Rotate + ", self)
button2.setGeometry(320, 450, 100, 50)
button2.clicked.connect(self.rotatePlus)
scene = QGraphicsScene(self)
greenBrush = QBrush(Qt.green)
blueBrush = QBrush(Qt.blue)
blackPen = QPen(Qt.black)
blackPen.setWidth(5)
ellipse = scene.addEllipse(10, 10, 200, 200, blackPen, greenBrush)
rect = scene.addRect(-100, -100, 200, 200, blackPen, blueBrush)
scene.addText("antoine-libert.com", QFont("Sanserif", 15))
ellipse.setFlag(QGraphicsItem.ItemIsMovable)
rect.setFlag(QGraphicsItem.ItemIsMovable)
self.view = QGraphicsView(scene, self)
self.view.setGeometry(0, 0, 640, 440)
def draw_waypoint(self, scene: QGraphicsScene, position: Tuple[int, int],
player: bool, selected: bool) -> None:
waypoint_pen = self.waypoint_pen(player, selected)
waypoint_brush = self.waypoint_brush(player, selected)
self.flight_path_items.append(
scene.addEllipse(position[0], position[1], self.WAYPOINT_SIZE,
self.WAYPOINT_SIZE, waypoint_pen, waypoint_brush))
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 create_ui(self):
scene = QGraphicsScene(self)
greenBrush = QBrush(Qt.red)
blueBrush = QBrush(Qt.blue)
blackPen = QPen(Qt.black)
blackPen.setWidth(1)
ellipse = scene.addEllipse(0, 0, 20, 20, blackPen, greenBrush)
ellipse2 = scene.addEllipse(-30, -30, 20, 20, blackPen, blueBrush)
ellipse.setFlag(QGraphicsItem.ItemIsMovable)
ellipse2.setFlag(QGraphicsItem.ItemIsMovable)
self.view = QGraphicsView(scene, self)
self.view.setGeometry(0, 0, 640, 440)
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()
def waferPainter(self):
blackPen = QPen(Qt.black)
blackPen.setWidth(1)
blueBrush = QBrush(Qt.blue)
scene = QGraphicsScene()
chipNumX = 100
chipNumY = 100
canvasWidth = self.ui.mapView.width()
canvasHeight = self.ui.mapView.height()
chipWidthX = (canvasWidth - 5) / chipNumX
chipHeightY = (canvasHeight - 5) / chipNumY
waferEllipse = QGraphicsEllipseItem()
scene.addEllipse(0, 0, canvasWidth - 5, canvasHeight - 5, blackPen)
for numx in range(0, chipNumX):
for numy in range(0, chipNumY):
scene.addRect(numx * chipWidthX, numy * chipHeightY, chipWidthX, chipHeightY, blackPen, blueBrush)
# --》隐藏graphicsView的滚动条
self.ui.mapView.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.ui.mapView.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.ui.mapView.setScene(scene)
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 __init__(self):
super(Window, self).__init__()
self.setWindowTitle("Pyside2 Simple Application")
self.setGeometry(300, 300, 300, 300)
scene = QGraphicsScene(self)
greenBrush = QBrush(Qt.green)
blueBrush = QBrush(Qt.blue)
blackPen = QPen(Qt.black)
blackPen.setWidth(5)
ellipse = scene.addEllipse(10, 10, 200, 200, blackPen, greenBrush)
rect = scene.addRect(-100, -100, 200, 200, blackPen, blueBrush)
ellipse.setFlag(QGraphicsItem.ItemIsMovable)
rect.setFlag(QGraphicsItem.ItemIsMovable)
self.view = QGraphicsView(scene, self)
self.setCentralWidget(self.view)
self.view.rotate(30)
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.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 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(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.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(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.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.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 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.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.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))
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().__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 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__()
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.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 TestGUI(QMainWindow):
def __init__(self):
self.app = QApplication(sys.argv)
ui_file = QFile("testgui.ui")
ui_file.open(QFile.ReadOnly)
loader = QUiLoader()
self.window = loader.load(ui_file)
ui_file.close()
self.scene_gt = QGraphicsScene()
self.scene_gt.setSceneRect(-2000, -3000, 4000, 6000)
self.view_gt = QGraphicsView(self.scene_gt, self.window.scene_gt)
self.view_gt.scale(-0.1, 0.1)
self.view_gt.resize(self.window.scene_gt.geometry().width(),
self.window.scene_gt.geometry().height())
self.personPos_gt = self.scene_gt.addEllipse(
QRectF(-200, -200, 400, 400), QPen(QColor("LightGreen")),
QBrush(QColor("LightGreen")))
self.personPos_gt.setFlag(QGraphicsItem.ItemIsMovable)
self.personPos_gt.setPos(0, 0)
self.personAng_gt = self.scene_gt.addRect(QRectF(-10, 0, 20, 300),
QPen(QColor("Green")),
QBrush(QColor("Green")))
self.personAng_gt.setFlag(QGraphicsItem.ItemIsMovable)
self.personAng_gt.setPos(0, 0)
self.scene_cc = QGraphicsScene()
self.scene_cc.setSceneRect(-2000, -3000, 4000, 6000)
self.view_cc = QGraphicsView(self.scene_cc, self.window.scene_cc)
self.view_cc.scale(-0.1, 0.1)
self.view_cc.resize(self.window.scene_cc.geometry().width(),
self.window.scene_cc.geometry().height())
self.personPos_cc = self.scene_cc.addEllipse(
QRectF(-200, -200, 400, 400), QPen(QColor("Red")),
QBrush(QColor("Red")))
self.personPos_cc.setFlag(QGraphicsItem.ItemIsMovable)
self.personPos_cc.setPos(0, 0)
self.personAng_cc = self.scene_cc.addRect(QRectF(-10, 0, 20, 300),
QPen(QColor("Black")),
QBrush(QColor("Black")))
self.personAng_cc.setFlag(QGraphicsItem.ItemIsMovable)
self.personAng_cc.setPos(0, 0)
self.scene_nn = QGraphicsScene()
self.scene_nn.setSceneRect(-2000, -3000, 4000, 6000)
self.view_nn = QGraphicsView(self.scene_nn, self.window.scene_nn)
self.view_nn.scale(-0.1, 0.1)
self.view_nn.resize(self.window.scene_nn.geometry().width(),
self.window.scene_nn.geometry().height())
self.personPos_nn = self.scene_nn.addEllipse(
QRectF(-200, -200, 400, 400), QPen(QColor("LightBlue")),
QBrush(QColor("LightBlue")))
self.personPos_nn.setFlag(QGraphicsItem.ItemIsMovable)
self.personPos_nn.setPos(0, 0)
self.personAng_nn = self.scene_nn.addRect(QRectF(-10, 0, 20, 300),
QPen(QColor("Blue")),
QBrush(QColor("Blue")))
self.personAng_nn.setFlag(QGraphicsItem.ItemIsMovable)
self.personAng_nn.setPos(0, 0)
self.loadData(sys.argv[1])
self.window.instantScrollBar.valueChanged.connect(self.changeInstant)
self.it = 0
self.timer = QTimer()
self.timer.timeout.connect(self.compute)
self.timer.start(150)
self.window.show()
r = self.app.exec_()
sys.exit(r)
def loadData(self, filename):
test_dataset = graph_generator.CalibrationDataset(filename, 'run', '1')
with open(sys.argv[1], 'r') as f:
raw = f.read()
raw = list(raw)
raws = ''.join(raw)
data = json.loads(raws)['data_set']
model = trackerapi.TrackerAPI('.', test_dataset)
self.x_gt = []
self.x_cc = []
self.x_nn = []
self.z_gt = []
self.z_cc = []
self.z_nn = []
self.a_gt = []
self.a_cc = []
self.a_nn = []
try:
with open('kk', 'rb') as f:
results = pickle.load(f)
except:
results = [x for x in model.predict()]
with open('kk', 'wb') as f:
pickle.dump(results, f, pickle.HIGHEST_PROTOCOL)
eX_cc = []
eZ_cc = []
eA_cc = []
eX_nn = []
eZ_nn = []
eA_nn = []
self.trajectory = []
s = 0
ang_prev = 0
for i in range(int(len(results))):
n_joints = 0
for cam in range(len(data[i]['superbody'])):
n_joints += len(data[i]['superbody'][cam]['joints'])
if n_joints < 3:
continue
s += 1
if s < 2 or s % 1 != 0:
continue
self.x_gt.append(data[i]['superbody'][0]['ground_truth'][0])
self.z_gt.append(data[i]['superbody'][0]['ground_truth'][2])
self.a_gt.append(data[i]['superbody'][0]['ground_truth'][3] *
180. / math.pi)
self.trajectory.append(QPointF(self.x_gt[-1], self.z_gt[-1]))
x_cc = 0
z_cc = 0
ncams = 0
for cam in range(0, len(data[i]['superbody'])):
x_cc += data[i]['superbody'][cam]['world'][0]
z_cc += data[i]['superbody'][cam]['world'][2]
ncams += 1
self.x_cc.append(x_cc / ncams)
self.z_cc.append(z_cc / ncams)
s_cc = 0
c_cc = 0
ncams = 0
for cam in range(0, len(data[i]['superbody'])):
joints = data[i]['superbody'][cam]["joints"]
if ("right_shoulder" in joints and "left_shoulder"
in joints) or ("right_hip" in joints
and "left_hip" in joints):
s_cc = math.sin(data[i]['superbody'][cam]['world'][3])
c_cc = math.cos(data[i]['superbody'][cam]['world'][3])
ncams += 1
if ncams > 0:
a_cc = math.atan2(s_cc / ncams, c_cc / ncams)
ang_prev = a_cc
else:
a_cc = ang_prev
self.a_cc.append(a_cc * 180. / math.pi)
self.x_nn.append(results[i][0] * 4000)
self.z_nn.append(results[i][2] * 4000)
self.a_nn.append(
math.atan2(results[i][3] / 0.7, results[i][4] / 0.7) * 180. /
math.pi)
eX_cc.append(abs(self.x_gt[-1] - self.x_cc[-1]))
eZ_cc.append(abs(self.z_gt[-1] - self.z_cc[-1]))
eAng = 180 - abs(abs(self.a_gt[-1] - self.a_cc[-1]) - 180)
if eAng < 0:
eAng = 360 + eAng
eA_cc.append(eAng)
eX_nn.append(abs(self.x_gt[-1] - self.x_nn[-1].item()))
eZ_nn.append(abs(self.z_gt[-1] - self.z_nn[-1].item()))
eAng = 180 - abs(abs(self.a_gt[-1] - self.a_nn[-1]) - 180)
if eAng < 0:
eAng = 360 + eAng
eA_nn.append(eAng)
array_err_z = np.array(eZ_nn)
print("len array error", len(array_err_z))
# self.window.eX_cc.display(np.array(eX_cc).mean())
# self.window.eZ_cc.display(np.array(eZ_cc).mean())
# self.window.eA_cc.display(np.array(eA_cc).mean())
# self.window.eX_nn.display(np.array(eX_nn).mean())
# self.window.eZ_nn.display(np.array(eZ_nn).mean())
# self.window.eA_nn.display(np.array(eA_nn).mean())
self.scene_gt.addPolygon(self.trajectory, QPen(QColor("Black")))
self.scene_cc.addPolygon(self.trajectory, QPen(QColor("Black")))
self.scene_nn.addPolygon(self.trajectory, QPen(QColor("Black")))
self.window.instantScrollBar.setMaximum(len(self.a_gt) - 1)
def compute(self):
if self.window.playButton.isChecked():
if self.it >= len(self.x_gt):
self.it = 0
self.movePerson()
self.it += 1
self.window.instantScrollBar.setValue(self.it)
def changeInstant(self, instant):
self.it = instant
self.movePerson()
def movePerson(self):
self.personPos_gt.setPos(self.x_gt[self.it], self.z_gt[self.it])
self.personAng_gt.setPos(self.x_gt[self.it], self.z_gt[self.it])
self.personAng_gt.setRotation(self.a_gt[self.it])
self.personPos_cc.setPos(self.x_cc[self.it], self.z_cc[self.it])
self.personAng_cc.setPos(self.x_cc[self.it], self.z_cc[self.it])
self.personAng_cc.setRotation(self.a_cc[self.it])
self.personPos_nn.setPos(self.x_nn[self.it], self.z_nn[self.it])
self.personAng_nn.setPos(self.x_nn[self.it], self.z_nn[self.it])
self.personAng_nn.setRotation(self.a_nn[self.it])
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())
