2D y 3D más una descripción

app.py

@@ -6,302 +6,33 @@ import plotly.graph_objects as go
 import pandas as pd
 
 # Se debe tener instalado plotly, streamlit y matplotlib
-
-
-# Función para generar una población inicial aleatoria
-def generar_poblacion(num_individuos, num_ciudades):
-    poblacion = []
-    for _ in range(num_individuos):
-        individuo = list(range(num_ciudades))
-        random.shuffle(individuo)
-        poblacion.append(individuo)
-    return poblacion
-
-
-# Función para evaluar la aptitud de un individuo (distancia total del recorrido)
-def calcular_aptitud(individuo, distancias):
-    distancia_total = 0
-    for i in range(len(individuo) - 1):
-        ciudad_actual = individuo[i]
-        siguiente_ciudad = individuo[i + 1]
-        distancia_total += distancias[ciudad_actual][siguiente_ciudad]
-    distancia_total += distancias[individuo[-1]][individuo[0]]
-    return distancia_total
-
-
-# Función para seleccionar individuos para la reproducción (torneo binario)
-def seleccion_torneo(poblacion, distancias):
-    seleccionados = []
-    for _ in range(len(poblacion)):
-        torneo = random.sample(poblacion, 2)
-        aptitud_torneo = [
-            calcular_aptitud(individuo, distancias) for individuo in torneo
-        ]
-        seleccionado = torneo[aptitud_torneo.index(min(aptitud_torneo))]
-        seleccionados.append(seleccionado)
-    return seleccionados
-
-
-# Función para realizar el cruce de dos padres para producir un hijo
-def cruzar(padre1, padre2):
-    punto_cruce = random.randint(0, len(padre1) - 1)
-    hijo = padre1[:punto_cruce] + [
-        gen for gen in padre2 if gen not in padre1[:punto_cruce]
-    ]
-    return hijo
-
-
-# Función para aplicar mutaciones en la población
-def mutar(individuo, probabilidad_mutacion):
-    if random.random() < probabilidad_mutacion:
-        indices = random.sample(range(len(individuo)), 2)
-        individuo[indices[0]], individuo[indices[1]] = (
-            individuo[indices[1]],
-            individuo[indices[0]],
-        )
-    return individuo
-
-
-# Función para generar distancias aleatorias entre ciudades y sus coordenadas tridimensionales
-def generar_distancias(num_ciudades):
-    distancias = [[0] * num_ciudades for _ in range(num_ciudades)]
-    coordenadas = [
-        (random.uniform(0, 100), random.uniform(0, 100), random.uniform(0, 100))
-        for _ in range(num_ciudades)
-    ]
-
-    for i in range(num_ciudades):
-        for j in range(i + 1, num_ciudades):
-            distancias[i][j] = distancias[j][i] = (
-                sum((x - y) ** 2 for x, y in zip(coordenadas[i], coordenadas[j])) ** 0.5
-            )
-
-    return distancias, coordenadas
-
-
-def visualizar_camino(camino, coordenadas, mejor_distancia):
-    fig = go.Figure()
-
-    # Añadir el camino como un trazado 3D interactivo
-    x = [coordenadas[i][0] for i in camino]
-    y = [coordenadas[i][1] for i in camino]
-    z = [coordenadas[i][2] for i in camino]
-
-    fig.add_trace(go.Scatter3d(x=x, y=y, z=z, mode="lines+markers", name="Camino"))
-
-    # Añadir el punto de inicio
-    fig.add_trace(
-        go.Scatter3d(
-            x=[x[0]],
-            y=[y[0]],
-            z=[z[0]],
-            mode="markers",
-            marker=dict(color="green", size=10),
-            name="Inicio",
-        )
-    )
-
-    # Añadir el punto de fin
-    fig.add_trace(
-        go.Scatter3d(
-            x=[x[-1]],
-            y=[y[-1]],
-            z=[z[-1]],
-            mode="markers",
-            marker=dict(color="red", size=10),
-            name="Fin",
-        )
-    )
-
-    # Configuraciones adicionales
-    fig.update_layout(
-        scene=dict(aspectmode="cube"),
-        title=f"Mejor Camino Encontrado\nDistancia: {mejor_distancia:.2f}",
-    )
-
-    # Mostrar el gráfico interactivo en Streamlit
-    st.plotly_chart(fig)
-
-
-def visualizar_camino_streamlit(camino, coordenadas, mejor_distancia):
-    fig_camino = go.Figure()
-
-    # Añadir el camino como un trazado 3D interactivo
-    x = [coordenadas[i][0] for i in camino]
-    y = [coordenadas[i][1] for i in camino]
-    z = [coordenadas[i][2] for i in camino]
-
-    # Añadir el camino como un trazado 3D interactivo con identificadores
-    fig_camino.add_trace(
-        go.Scatter3d(
-            x=x, y=y, z=z, mode="lines+markers", marker=dict(size=5), name="Camino"
-        )
-    )
-
-    # Añadir los puntos de inicio y fin con etiquetas
-    fig_camino.add_trace(
-        go.Scatter3d(
-            x=[x[0]],
-            y=[y[0]],
-            z=[z[0]],
-            mode="markers+text",
-            marker=dict(color="green", size=10),
-            name="Inicio",
-            text=[str(camino[0])],
-            textposition="top center",
-        )
-    )
-
-    fig_camino.add_trace(
-        go.Scatter3d(
-            x=[x[-1]],
-            y=[y[-1]],
-            z=[z[-1]],
-            mode="markers+text",
-            marker=dict(color="red", size=10),
-            name="Fin",
-            text=[str(camino[-1])],
-            textposition="top center",
-        )
-    )
-
-    # Añadir etiquetas a los puntos intermedios
-    for i, (xi, yi, zi) in enumerate(zip(x[1:-1], y[1:-1], z[1:-1])):
-        fig_camino.add_trace(
-            go.Scatter3d(
-                x=[xi],
-                y=[yi],
-                z=[zi],
-                mode="markers+text",
-                marker=dict(size=5),
-                text=[str(camino[i + 1])],
-                textposition="top center",
-            )
-        )
-
-    # Configuraciones adicionales
-    fig_camino.update_layout(
-        scene=dict(aspectmode="cube"),
-        title=f"Mejor Camino Encontrado\nDistancia: {mejor_distancia:.2f}",
-    )
-
-    # Mostrar el gráfico interactivo en Streamlit
-    st.plotly_chart(fig_camino)
-
-
-def algoritmo_genetico(
-    num_generaciones, num_ciudades, num_individuos, probabilidad_mutacion, distancias
-):
-    poblacion = generar_poblacion(num_individuos, num_ciudades)
-    mejor_solucion_historial = []
-    mejor_distancia_historial = []
-    for generacion in range(num_generaciones):
-        poblacion = sorted(poblacion, key=lambda x: calcular_aptitud(x, distancias))
-        mejor_individuo = poblacion[0]
-        mejor_distancia = calcular_aptitud(mejor_individuo, distancias)
-        mejor_solucion_historial.append(mejor_individuo)
-        mejor_distancia_historial.append(mejor_distancia)
-        seleccionados = seleccion_torneo(poblacion, distancias)
-        nueva_poblacion = []
-        for i in range(0, len(seleccionados), 2):
-            padre1, padre2 = seleccionados[i], seleccionados[i + 1]
-            hijo1 = cruzar(padre1, padre2)
-            hijo2 = cruzar(padre2, padre1)
-            hijo1 = mutar(hijo1, probabilidad_mutacion)
-            hijo2 = mutar(hijo2, probabilidad_mutacion)
-            nueva_poblacion.extend([hijo1, hijo2])
-        poblacion = nueva_poblacion
-    mejor_solucion = poblacion[0]
-    mejor_distancia = calcular_aptitud(mejor_solucion, distancias)
-    # Visualizar el proceso del algoritmo
-    visualizar_proceso_streamlit(
-        mejor_distancia_historial, mejor_solucion, coordenadas, mejor_distancia
-    )
-    # Visualizar el mejor camino encontrado
-    visualizar_camino_streamlit(mejor_solucion, coordenadas, mejor_distancia)
-
-    return mejor_solucion, mejor_distancia
-
-
-def visualizar_proceso_streamlit(
-    mejor_distancia_historial, mejor_solucion, coordenadas, mejor_distancia
-):
-    generaciones = list(range(len(mejor_distancia_historial)))
-
-    # Crear gráfico interactivo de evolución de la distancia
-    fig_distancia = go.Figure()
-    fig_distancia.add_trace(
-        go.Scatter(x=generaciones, y=mejor_distancia_historial, mode="lines+markers")
-    )
-    fig_distancia.update_layout(
-        title="Evolución de la Distancia en Cada Generación",
-        xaxis_title="Generación",
-        yaxis_title="Distancia",
-    )
-    st.plotly_chart(fig_distancia)
-
-
-if __name__ == "__main__":
-    st.title("Algoritmo Genético para el Problema del Viajante")
-    st.sidebar.header("Configuración")
-    manual_input = st.sidebar.checkbox("Ingresar datos manualmente")
-    # Ingresar datos manualmente o generarlos aleatoriamente (por defecto), además de generar las distancias
-    if manual_input:
-        st.sidebar.subheader("Ingresar coordenadas manualmente:")
-        num_ciudades = st.sidebar.number_input(
-            "Número de Ciudades", min_value=5, max_value=100, value=10, step=5
-        )
-
-        coordenadas = []
-        for i in range(num_ciudades):
-            st.sidebar.subheader(f"Coordenadas Ciudad {i + 1}")
-            x = st.sidebar.number_input(
-                f"X Ciudad {i + 1}:", value=0.0, key=f"x_{i}", step=1.0
-            )
-            y = st.sidebar.number_input(
-                f"Y Ciudad {i + 1}:", value=0.0, key=f"y_{i}", step=1.0
-            )
-            z = st.sidebar.number_input(
-                f"Z Ciudad {i + 1}:", value=0.0, key=f"z_{i}", step=1.0
-            )
-            coordenadas.append((x, y, z))
-
-        data = pd.DataFrame(coordenadas, columns=["X", "Y", "Z"])
-        distancias, _ = generar_distancias(num_ciudades)
-    else:
-        num_ciudades = st.sidebar.number_input(
-            "Número de Ciudades", min_value=5, max_value=100, value=10, step=5
-        )
-
-        distancias, coordenadas = generar_distancias(num_ciudades)
-        data = pd.DataFrame(coordenadas, columns=["X", "Y", "Z"])
-
-    # Mostrar datos en la interfaz
-    st.write(
-        "Puntos en el espacio tridimensional (X, Y, Z), donde cada punto es una ciudad"
-    )
-    st.dataframe(data=data, use_container_width=True)
-
-    # Configuraciones adicionales
-    num_generaciones = st.sidebar.slider(
-        "Número de Generaciones", min_value=10, max_value=100, value=50
-    )
-    num_individuos = st.sidebar.slider(
-        "Tamaño de la Población ($par$)", min_value=10, max_value=100, value=50, step=2
-    )
-    probabilidad_mutacion = st.sidebar.slider(
-        "Probabilidad de Mutación", min_value=0.01, max_value=0.5, value=0.1
-    )
-
-    # Ejecutar el algoritmo genético
-    mejor_solucion, mejor_distancia = algoritmo_genetico(
-        num_generaciones,
-        num_ciudades,
-        num_individuos,
-        probabilidad_mutacion,
-        distancias,
-    )
-
-    # Mostrar resultados
-    st.success(f"Mejor solución encontrada: {mejor_solucion}")
-    st.success(f"Mejor distancia encontrada: {mejor_distancia:.2f}")
+# configurar con wide mode
+st.set_page_config(layout="wide", page_title="AG for TSP", page_icon="🧬")
+
+st.sidebar.title("Algoritmo Genético para el Problema del Viajante")
+st.sidebar.write("Integrantes: ")
+st.sidebar.write("🦁 Edson Emanuel Alvarado Prieto ")
+st.sidebar.write("🐺 Jairo Daniel Mendoza Torres ")
+st.write(
+    """
+## **Descripción:**
+Este fascinante código despliega un Algoritmo Genético (AG) diseñado para abordar el intrigante Problema del Viajante, también conocido como el Problema del Viajante de Comercio (TSP en inglés), llevando la experiencia a un entorno bidimensional y tridimensional. El TSP desafía a encontrar el camino más corto que visite cada ciudad exactamente una vez y regrese al punto de origen, persiguiendo la meta de minimizar la distancia total recorrida.
+
+## **Uso:**
+1. Ofrece la opción de ingresar manualmente las coordenadas de las ciudades o generarlas de manera aleatoria.
+2. La interfaz de Streamlit permite ajustar parámetros como el número de ciudades, el tamaño de la población, el número de generaciones y la probabilidad de mutación.
+3. Al ejecutar el código, se despliega una visualización de la evolución del mejor camino encontrado a lo largo de las generaciones, así como la representación gráfica del mejor camino y su distancia final.
+
+## **Aplicaciones:**
+- 🚚 **Logística y Distribución:** Optimización de rutas para vehículos de entrega, agilizando la logística empresarial.
+- 🗺️ **Planificación de Circuitos Electrónicos:** Conexión eficiente de componentes en placas de circuito, impulsando la ingeniería electrónica.
+- 🧬 **Biología Molecular:** Determinación de la secuencia genética más eficiente en el mapeo genético, contribuyendo a avances en biotecnología.
+- 🛠️ **Planificación de Proyectos:** Optimización de la secuencia de tareas para minimizar el tiempo total del proyecto, mejorando la gestión de proyectos.
+
+## 🌐 **Puntos a tocar:**
+- 🧬 Explora el Problema del Viajante.
+- 🚚 Optimiza Rutas en 2D y 3D.
+- 🗺️ Considerar ingreso de coordenadas manual o aleatorio 
+- 🧠 Utiliza un Algoritmo Genético para soluciones inteligentes y eficaces.
+"""
+)

pages/AG_2D.py

@@ -0,0 +1,306 @@
+import streamlit as st
+import random
+import plotly.graph_objects as go
+import pandas as pd
+
+# Se debe tener instalado plotly, streamlit y matplotlib
+
+st.set_page_config(layout="centered", page_title="AG for TSP 2D", page_icon="🧬"
+)
+
+# Función para generar una población inicial aleatoria
+def generar_poblacion(num_individuos, num_ciudades):
+    poblacion = []
+    for _ in range(num_individuos):
+        individuo = list(range(num_ciudades))
+        random.shuffle(individuo)
+        poblacion.append(individuo)
+    return poblacion
+
+
+# Función para evaluar la aptitud de un individuo (distancia total del recorrido)
+def calcular_aptitud(individuo, distancias, coordenadas):
+    distancia_total = 0
+    coordenadas_iguales = all(coord == coordenadas[0] for coord in coordenadas)
+
+    if not coordenadas_iguales:
+        for i in range(len(individuo) - 1):
+            ciudad_actual = individuo[i]
+            siguiente_ciudad = individuo[i + 1]
+            distancia_total += distancias[ciudad_actual][siguiente_ciudad]
+
+        distancia_total += distancias[individuo[-1]][individuo[0]]
+
+    return distancia_total
+
+
+# Función para seleccionar individuos para la reproducción (torneo binario)
+def seleccion_torneo(poblacion, distancias, coordenadas):
+    seleccionados = []
+    for _ in range(len(poblacion)):
+        torneo = random.sample(poblacion, 2)
+        aptitud_torneo = [
+            calcular_aptitud(individuo, distancias, coordenadas) for individuo in torneo
+        ]
+        seleccionado = torneo[aptitud_torneo.index(min(aptitud_torneo))]
+        seleccionados.append(seleccionado)
+    return seleccionados
+
+
+# Función para realizar el cruce de dos padres para producir un hijo
+def cruzar(padre1, padre2):
+    punto_cruce = random.randint(0, len(padre1) - 1)
+    hijo = padre1[:punto_cruce] + [
+        gen for gen in padre2 if gen not in padre1[:punto_cruce]
+    ]
+    return hijo
+
+
+# Función para aplicar mutaciones en la población
+def mutar(individuo, probabilidad_mutacion):
+    if random.random() < probabilidad_mutacion:
+        indices = random.sample(range(len(individuo)), 2)
+        individuo[indices[0]], individuo[indices[1]] = (
+            individuo[indices[1]],
+            individuo[indices[0]],
+        )
+    return individuo
+
+
+# Función para generar distancias aleatorias entre ciudades y sus coordenadas bidimensionales
+def generar_distancias(num_ciudades):
+    distancias = [[0] * num_ciudades for _ in range(num_ciudades)]
+    coordenadas = [
+        (random.uniform(0, 100), random.uniform(0, 100)) for _ in range(num_ciudades)
+    ]
+
+    for i in range(num_ciudades):
+        for j in range(i + 1, num_ciudades):
+            distancias[i][j] = distancias[j][i] = (
+                sum((x - y) ** 2 for x, y in zip(coordenadas[i], coordenadas[j])) ** 0.5
+            )
+
+    return distancias, coordenadas
+
+
+# Función para visualizar el camino en 2D
+def visualizar_camino(camino, coordenadas, mejor_distancia):
+    fig = go.Figure()
+
+    # Añadir el camino como un trazado 2D interactivo
+    x = [coordenadas[i][0] for i in camino]
+    y = [coordenadas[i][1] for i in camino]
+
+    fig.add_trace(go.Scatter(x=x, y=y, mode="lines+markers", name="Camino"))
+
+    # Añadir el punto de inicio
+    fig.add_trace(
+        go.Scatter(
+            x=[x[0]],
+            y=[y[0]],
+            mode="markers",
+            marker=dict(color="green", size=10),
+            name="Inicio",
+        )
+    )
+
+    # Añadir el punto de fin
+    fig.add_trace(
+        go.Scatter(
+            x=[x[-1]],
+            y=[y[-1]],
+            mode="markers",
+            marker=dict(color="red", size=10),
+            name="Fin",
+        )
+    )
+
+    # Configuraciones adicionales
+    fig.update_layout(
+        title=f"Mejor Camino Encontrado\nDistancia: {mejor_distancia:.2f}"
+    )
+
+    # Mostrar el gráfico interactivo en Streamlit
+    st.plotly_chart(fig)
+
+
+def visualizar_camino_streamlit(camino, coordenadas, mejor_distancia):
+    fig_camino = go.Figure()
+
+    # Añadir el camino como un trazado 2D interactivo
+    x = [coordenadas[i][0] for i in camino]
+    y = [coordenadas[i][1] for i in camino]
+
+    # Añadir el camino como un trazado 2D interactivo con identificadores
+    fig_camino.add_trace(
+        go.Scatter(x=x, y=y, mode="lines+markers", marker=dict(size=5), name="Camino")
+    )
+
+    # Añadir los puntos de inicio y fin con etiquetas
+    fig_camino.add_trace(
+        go.Scatter(
+            x=[x[0]],
+            y=[y[0]],
+            mode="markers+text",
+            marker=dict(color="green", size=10),
+            name="Inicio",
+            text=[str(camino[0])],
+            textposition="top center",
+        )
+    )
+
+    fig_camino.add_trace(
+        go.Scatter(
+            x=[x[-1]],
+            y=[y[-1]],
+            mode="markers+text",
+            marker=dict(color="red", size=10),
+            name="Fin",
+            text=[str(camino[-1])],
+            textposition="top center",
+        )
+    )
+
+    # Añadir etiquetas a los puntos intermedios
+    for i, (xi, yi) in enumerate(zip(x[1:-1], y[1:-1])):
+        fig_camino.add_trace(
+            go.Scatter(
+                x=[xi],
+                y=[yi],
+                mode="markers+text",
+                marker=dict(size=5),
+                text=[str(camino[i + 1])],
+                textposition="top center",
+            )
+        )
+
+    # Configuraciones adicionales
+    fig_camino.update_layout(
+        title=f"Mejor Camino Encontrado\nDistancia: {mejor_distancia:.2f}"
+    )
+
+    # Mostrar el gráfico interactivo en Streamlit
+    st.plotly_chart(fig_camino)
+
+
+def algoritmo_genetico(
+    num_generaciones,
+    num_ciudades,
+    num_individuos,
+    probabilidad_mutacion,
+    distancias,
+    coordenadas,
+):
+    poblacion = generar_poblacion(num_individuos, num_ciudades)
+    mejor_solucion_historial = []
+    mejor_distancia_historial = []
+    for generacion in range(num_generaciones):
+        poblacion = sorted(
+            poblacion, key=lambda x: calcular_aptitud(x, distancias, coordenadas)
+        )
+        mejor_individuo = poblacion[0]
+        mejor_distancia = calcular_aptitud(mejor_individuo, distancias, coordenadas)
+        mejor_solucion_historial.append(mejor_individuo)
+        mejor_distancia_historial.append(mejor_distancia)
+        seleccionados = seleccion_torneo(poblacion, distancias, coordenadas)
+        nueva_poblacion = []
+        for i in range(0, len(seleccionados), 2):
+            padre1, padre2 = seleccionados[i], seleccionados[i + 1]
+            hijo1 = cruzar(padre1, padre2)
+            hijo2 = cruzar(padre2, padre1)
+            hijo1 = mutar(hijo1, probabilidad_mutacion)
+            hijo2 = mutar(hijo2, probabilidad_mutacion)
+            nueva_poblacion.extend([hijo1, hijo2])
+        poblacion = nueva_poblacion
+    mejor_solucion = poblacion[0]
+    mejor_distancia = calcular_aptitud(mejor_solucion, distancias, coordenadas)
+    # Visualizar el proceso del algoritmo
+    visualizar_proceso_streamlit(
+        mejor_distancia_historial, mejor_solucion, coordenadas, mejor_distancia
+    )
+    # Visualizar el mejor camino encontrado
+    visualizar_camino_streamlit(mejor_solucion, coordenadas, mejor_distancia)
+
+    return mejor_solucion, mejor_distancia
+
+
+def visualizar_proceso_streamlit(
+    mejor_distancia_historial, mejor_solucion, coordenadas, mejor_distancia
+):
+    generaciones = list(range(len(mejor_distancia_historial)))
+
+    # Crear gráfico interactivo de evolución de la distancia
+    fig_distancia = go.Figure()
+    fig_distancia.add_trace(
+        go.Scatter(x=generaciones, y=mejor_distancia_historial, mode="lines+markers")
+    )
+    fig_distancia.update_layout(
+        title="Evolución de la Distancia en Cada Generación",
+        xaxis_title="Generación",
+        yaxis_title="Distancia",
+    )
+    st.plotly_chart(fig_distancia)
+
+
+if __name__ == "__main__":
+    st.title("Algoritmo Genético para el Problema del Viajante")
+    st.sidebar.header("Configuración")
+    manual_input = st.sidebar.checkbox("Ingresar datos manualmente")
+    # Ingresar datos manualmente o generarlos aleatoriamente (por defecto), además de generar las distancias
+    if manual_input:
+        st.sidebar.subheader("Ingresar coordenadas manualmente:")
+        num_ciudades = st.sidebar.number_input(
+            "Número de Ciudades", min_value=5, max_value=100, value=10, step=5
+        )
+
+        coordenadas = []
+        for i in range(num_ciudades):
+            st.sidebar.subheader(f"Coordenadas Ciudad {i + 1}")
+            x = st.sidebar.number_input(
+                f"X Ciudad {i + 1}:", value=0.0, key=f"x_{i}", step=1.0
+            )
+            y = st.sidebar.number_input(
+                f"Y Ciudad {i + 1}:", value=0.0, key=f"y_{i}", step=1.0
+            )
+            coordenadas.append((x, y))
+
+        data = pd.DataFrame(coordenadas, columns=["X", "Y"])
+        distancias, _ = generar_distancias(num_ciudades)
+    else:
+        num_ciudades = st.sidebar.number_input(
+            "Número de Ciudades", min_value=5, max_value=100, value=10, step=5
+        )
+
+        distancias, coordenadas = generar_distancias(num_ciudades)
+        data = pd.DataFrame(coordenadas, columns=["X", "Y"])
+
+    # Mostrar datos en la interfaz
+    st.write(
+        "Puntos en el espacio bidimensional (X, Y), donde cada punto es una ciudad"
+    )
+    st.dataframe(data=data, use_container_width=True)
+
+    # Configuraciones adicionales
+    num_generaciones = st.sidebar.slider(
+        "Número de Generaciones", min_value=10, max_value=100, value=50
+    )
+    num_individuos = st.sidebar.slider(
+        "Tamaño de la Población ($par$)", min_value=10, max_value=100, value=50, step=2
+    )
+    probabilidad_mutacion = st.sidebar.slider(
+        "Probabilidad de Mutación", min_value=0.01, max_value=0.5, value=0.1
+    )
+
+    # Ejecutar el algoritmo genético
+    mejor_solucion, mejor_distancia = algoritmo_genetico(
+        num_generaciones,
+        num_ciudades,
+        num_individuos,
+        probabilidad_mutacion,
+        distancias,
+        coordenadas,
+    )
+
+    # Mostrar resultados
+    st.success(f"Mejor solución encontrada: {mejor_solucion}")
+    st.success(f"Mejor distancia encontrada: {mejor_distancia:.2f}")

pages/AG_3D.py

@@ -0,0 +1,348 @@
+import streamlit as st
+import matplotlib.pyplot as plt
+import random
+from mpl_toolkits.mplot3d import Axes3D
+import plotly.graph_objects as go
+import pandas as pd
+
+# Se debe tener instalado plotly, streamlit y matplotlib
+st.set_page_config(layout="centered", page_title="AG for TSP 3D", page_icon="🧬")
+
+
+# Función para generar una población inicial aleatoria
+def generar_poblacion(num_individuos, num_ciudades):
+    poblacion = []
+    for _ in range(num_individuos):
+        individuo = list(range(num_ciudades))
+        random.shuffle(individuo)
+        poblacion.append(individuo)
+    return poblacion
+
+
+# Función para evaluar la aptitud de un individuo (distancia total del recorrido)
+# Función para evaluar la aptitud de un individuo (distancia total del recorrido)
+def calcular_aptitud(individuo, distancias, coordenadas):
+    distancia_total = 0
+
+    # Verificar si todas las coordenadas de inicio son cero
+    coordenadas_inicio_cero = all(coord == 0 for coord in coordenadas[0])
+
+    if not coordenadas_inicio_cero:
+        for i in range(len(individuo) - 1):
+            ciudad_actual = individuo[i]
+            siguiente_ciudad = individuo[i + 1]
+            distancia_total += distancias[ciudad_actual][siguiente_ciudad]
+        distancia_total += distancias[individuo[-1]][individuo[0]]
+
+    return distancia_total
+
+
+# Función para seleccionar individuos para la reproducción (torneo binario)
+def seleccion_torneo(poblacion, distancias, coordenadas):
+    seleccionados = []
+    for _ in range(len(poblacion)):
+        torneo = random.sample(poblacion, 2)
+        aptitud_torneo = [
+            calcular_aptitud(individuo, distancias, coordenadas) for individuo in torneo
+        ]
+        seleccionado = torneo[aptitud_torneo.index(min(aptitud_torneo))]
+        seleccionados.append(seleccionado)
+    return seleccionados
+
+
+# Función para realizar el cruce de dos padres para producir un hijo
+def cruzar(padre1, padre2):
+    punto_cruce = random.randint(0, len(padre1) - 1)
+    hijo = padre1[:punto_cruce] + [
+        gen for gen in padre2 if gen not in padre1[:punto_cruce]
+    ]
+    return hijo
+
+
+# Función para aplicar mutaciones en la población
+def mutar(individuo, probabilidad_mutacion):
+    if random.random() < probabilidad_mutacion:
+        indices = random.sample(range(len(individuo)), 2)
+        individuo[indices[0]], individuo[indices[1]] = (
+            individuo[indices[1]],
+            individuo[indices[0]],
+        )
+    return individuo
+
+
+# Función para generar distancias aleatorias entre ciudades y sus coordenadas tridimensionales
+def generar_distancias(num_ciudades):
+    distancias = [[0] * num_ciudades for _ in range(num_ciudades)]
+
+    # Verificar si todas las coordenadas de inicio son cero
+    coordenadas_inicio_cero = all(coord == 0 for coord in coordenadas[0])
+
+    if not coordenadas_inicio_cero:
+        for i in range(num_ciudades):
+            for j in range(i + 1, num_ciudades):
+                distancias[i][j] = distancias[j][i] = (
+                    sum((x - y) ** 2 for x, y in zip(coordenadas[i], coordenadas[j]))
+                    ** 0.5
+                )
+
+    return distancias
+
+
+def visualizar_camino(camino, coordenadas, mejor_distancia):
+    fig = go.Figure()
+
+    # Añadir el camino como un trazado 3D interactivo
+    x = [coordenadas[i][0] for i in camino]
+    y = [coordenadas[i][1] for i in camino]
+    z = [coordenadas[i][2] for i in camino]
+
+    fig.add_trace(go.Scatter3d(x=x, y=y, z=z, mode="lines+markers", name="Camino"))
+
+    # Añadir el punto de inicio
+    fig.add_trace(
+        go.Scatter3d(
+            x=[x[0]],
+            y=[y[0]],
+            z=[z[0]],
+            mode="markers",
+            marker=dict(color="green", size=10),
+            name="Inicio",
+        )
+    )
+
+    # Añadir el punto de fin
+    fig.add_trace(
+        go.Scatter3d(
+            x=[x[-1]],
+            y=[y[-1]],
+            z=[z[-1]],
+            mode="markers",
+            marker=dict(color="red", size=10),
+            name="Fin",
+        )
+    )
+
+    # Configuraciones adicionales
+    fig.update_layout(
+        scene=dict(aspectmode="cube"),
+        title=f"Mejor Camino Encontrado\nDistancia: {mejor_distancia:.2f}",
+    )
+
+    # Mostrar el gráfico interactivo en Streamlit
+    st.plotly_chart(fig)
+
+
+def visualizar_camino_streamlit(camino, coordenadas, mejor_distancia):
+    fig_camino = go.Figure()
+
+    # Añadir el camino como un trazado 3D interactivo
+    x = [coordenadas[i][0] for i in camino]
+    y = [coordenadas[i][1] for i in camino]
+    z = [coordenadas[i][2] for i in camino]
+
+    # Añadir el camino como un trazado 3D interactivo con identificadores
+    fig_camino.add_trace(
+        go.Scatter3d(
+            x=x, y=y, z=z, mode="lines+markers", marker=dict(size=5), name="Camino"
+        )
+    )
+
+    # Añadir los puntos de inicio y fin con etiquetas
+    fig_camino.add_trace(
+        go.Scatter3d(
+            x=[x[0]],
+            y=[y[0]],
+            z=[z[0]],
+            mode="markers+text",
+            marker=dict(color="green", size=10),
+            name="Inicio",
+            text=[str(camino[0])],
+            textposition="top center",
+        )
+    )
+
+    fig_camino.add_trace(
+        go.Scatter3d(
+            x=[x[-1]],
+            y=[y[-1]],
+            z=[z[-1]],
+            mode="markers+text",
+            marker=dict(color="red", size=10),
+            name="Fin",
+            text=[str(camino[-1])],
+            textposition="top center",
+        )
+    )
+
+    # Añadir etiquetas a los puntos intermedios
+    for i, (xi, yi, zi) in enumerate(zip(x[1:-1], y[1:-1], z[1:-1])):
+        fig_camino.add_trace(
+            go.Scatter3d(
+                x=[xi],
+                y=[yi],
+                z=[zi],
+                mode="markers+text",
+                marker=dict(size=5),
+                text=[str(camino[i + 1])],
+                textposition="top center",
+            )
+        )
+
+    # Configuraciones adicionales
+    fig_camino.update_layout(
+        scene=dict(aspectmode="cube"),
+        title=f"Mejor Camino Encontrado\nDistancia: {mejor_distancia:.2f}",
+    )
+
+    # Mostrar el gráfico interactivo en Streamlit
+    st.plotly_chart(fig_camino)
+
+
+# ...
+
+
+def algoritmo_genetico(
+    num_generaciones,
+    num_ciudades,
+    num_individuos,
+    probabilidad_mutacion,
+    distancias,
+    coordenadas,
+):
+    poblacion = generar_poblacion(num_individuos, num_ciudades)
+    mejor_solucion_historial = []
+    mejor_distancia_historial = []
+    for generacion in range(num_generaciones):
+        poblacion = sorted(
+            poblacion, key=lambda x: calcular_aptitud(x, distancias, coordenadas)
+        )
+        mejor_individuo = poblacion[0]
+        mejor_distancia = calcular_aptitud(mejor_individuo, distancias, coordenadas)
+        mejor_solucion_historial.append(mejor_individuo)
+        mejor_distancia_historial.append(mejor_distancia)
+        seleccionados = seleccion_torneo(poblacion, distancias, coordenadas)
+        nueva_poblacion = []
+        for i in range(0, len(seleccionados), 2):
+            padre1, padre2 = seleccionados[i], seleccionados[i + 1]
+            hijo1 = cruzar(padre1, padre2)
+            hijo2 = cruzar(padre2, padre1)
+            hijo1 = mutar(hijo1, probabilidad_mutacion)
+            hijo2 = mutar(hijo2, probabilidad_mutacion)
+            nueva_poblacion.extend([hijo1, hijo2])
+        poblacion = nueva_poblacion
+    mejor_solucion = poblacion[0]
+    mejor_distancia = calcular_aptitud(mejor_solucion, distancias, coordenadas)
+    # Visualizar el proceso del algoritmo
+    visualizar_proceso_streamlit(
+        mejor_distancia_historial, mejor_solucion, coordenadas, mejor_distancia
+    )
+    # Visualizar el mejor camino encontrado
+    visualizar_camino_streamlit(mejor_solucion, coordenadas, mejor_distancia)
+
+    return mejor_solucion, mejor_distancia
+
+
+def visualizar_proceso_streamlit(
+    mejor_distancia_historial, mejor_solucion, coordenadas, mejor_distancia
+):
+    generaciones = list(range(len(mejor_distancia_historial)))
+
+    # Crear gráfico interactivo de evolución de la distancia
+    fig_distancia = go.Figure()
+    fig_distancia.add_trace(
+        go.Scatter(x=generaciones, y=mejor_distancia_historial, mode="lines+markers")
+    )
+    fig_distancia.update_layout(
+        title="Evolución de la Distancia en Cada Generación",
+        xaxis_title="Generación",
+        yaxis_title="Distancia",
+    )
+    st.plotly_chart(fig_distancia)
+
+
+# Función para generar distancias aleatorias entre ciudades y sus coordenadas tridimensionales
+def generar_distancias_coordenadas(num_ciudades):
+    distancias = [[0] * num_ciudades for _ in range(num_ciudades)]
+    coordenadas = [
+        (random.uniform(0, 100), random.uniform(0, 100), random.uniform(0, 100))
+        for _ in range(num_ciudades)
+    ]
+
+    for i in range(num_ciudades):
+        for j in range(i + 1, num_ciudades):
+            distancias[i][j] = distancias[j][i] = (
+                sum((x - y) ** 2 for x, y in zip(coordenadas[i], coordenadas[j])) ** 0.5
+            )
+
+    return distancias, coordenadas
+
+
+if __name__ == "__main__":
+    st.title("Algoritmo Genético para el Problema del Viajante")
+    st.sidebar.header("Configuración")
+    manual_input = st.sidebar.checkbox("Ingresar datos manualmente")
+
+    # Ingresar datos manualmente o generarlos aleatoriamente (por defecto), además de generar las distancias
+    if manual_input:
+        st.sidebar.subheader("Ingresar coordenadas manualmente:")
+        num_ciudades = st.sidebar.number_input(
+            "Número de Ciudades", min_value=5, max_value=100, value=10, step=5
+        )
+
+        coordenadas = []
+        for i in range(num_ciudades):
+            st.sidebar.subheader(f"Coordenadas Ciudad {i + 1}")
+            x = st.sidebar.number_input(
+                f"X Ciudad {i + 1}:", value=0.0, key=f"x_{i}", step=1.0
+            )
+            y = st.sidebar.number_input(
+                f"Y Ciudad {i + 1}:", value=0.0, key=f"y_{i}", step=1.0
+            )
+            z = st.sidebar.number_input(
+                f"Z Ciudad {i + 1}:", value=0.0, key=f"z_{i}", step=1.0
+            )
+            coordenadas.append((x, y, z))
+
+        data = pd.DataFrame(coordenadas, columns=["X", "Y", "Z"])
+        distancias = generar_distancias(num_ciudades)
+    else:
+        num_ciudades = st.sidebar.number_input(
+            "Número de Ciudades", min_value=5, max_value=100, value=10, step=5
+        )
+
+        coordenadas = generar_distancias_coordenadas(num_ciudades)[1]
+        distancias = generar_distancias(num_ciudades)
+
+    # Mostrar datos en la interfaz
+    st.write(
+        "Puntos en el espacio tridimensional (X, Y, Z), donde cada punto es una ciudad"
+    )
+    st.dataframe(
+        data=pd.DataFrame(coordenadas, columns=["X", "Y", "Z"]),
+        use_container_width=True,
+    )
+
+    # Configuraciones adicionales
+    num_generaciones = st.sidebar.slider(
+        "Número de Generaciones", min_value=10, max_value=100, value=50
+    )
+    num_individuos = st.sidebar.slider(
+        "Tamaño de la Población ($par$)", min_value=10, max_value=100, value=50, step=2
+    )
+    probabilidad_mutacion = st.sidebar.slider(
+        "Probabilidad de Mutación", min_value=0.01, max_value=0.5, value=0.1
+    )
+
+    # Ejecutar el algoritmo genético
+    mejor_solucion, mejor_distancia = algoritmo_genetico(
+        num_generaciones,
+        num_ciudades,
+        num_individuos,
+        probabilidad_mutacion,
+        distancias,
+        coordenadas,  # Se añade este argumento
+    )
+
+    # Mostrar resultados
+    st.success(f"Mejor solución encontrada: {mejor_solucion}")
+    st.success(f"Mejor distancia encontrada: {mejor_distancia:.2f}")