cambios efectivos sobre codigo

App/controller.py

@@ -128,30 +128,30 @@ def minimumCostPath(analyzer, destStation):
     return model.minimumCostPath(analyzer, destStation)
 
 
-def searchPaths(analyzer, initialStation, method="dfs"):
+def searchPaths(analyzer, initialStation, searchMethod):
     """
     Calcula todos los recorridos por "dfs" o "bfs" de initialStation a
     todas las otras estaciones del sistemas
     """
-    # TODO mods Lab 11, conectar con la funcion del model searchPaths
-    return None
+    # TODO Lab 11, conectar con la funcion del model searchPaths
+    return model.searchPaths(analyzer, initialStation, searchMethod)
 
 
-def hasSearchPath(analyzer, destStation, method="dfs"):
+def hasSearchPath(analyzer, destStation, searchMethod):
     """
     Informa si existe un camino entre initialStation y destStation segun
     el metodo de busqueda ("bfs" o "dfs")
     """
-    # TODO mods Lab 11, conectar con la funcion del model hasSearchPath
-    return None
+    # TODO Lab 11, conectar con la funcion del model hasSearchPath
+    return model.hasSearchPath(analyzer, destStation, searchMethod)
 
 
-def searchPath(analyzer, destStation, method="dfs"):
+def searchPathTo(analyzer, destStation, searchMethod):
     """
     Retorna el camino de busqueda entre initialStation y destStation
     """
-    # TODO mods Lab 11, conectar con la funcion del model searchPath
-    return None
+    # TODO Lab 11, conectar con la funcion del model searchPath
+    return model.searchPathTo(analyzer, destStation, searchMethod)
 
 
 def servedRoutes(analyzer):

App/model.py

@@ -29,8 +29,10 @@
 from DISClib.ADT import list as lt
 from DISClib.Algorithms.Graphs import scc
 from DISClib.Algorithms.Graphs import dijsktra as djk
+# TODO Lab 11, agregar importaciones dfs y bfs
+from DISClib.Algorithms.Graphs import dfs as dfs
+from DISClib.Algorithms.Graphs import bfs as bfs
 from DISClib.Utils import error as error
-# TODO mods Lab 11, agregar importaciones dfs y bfs
 assert config
 
 """
@@ -53,12 +55,13 @@ def newAnalyzer():
            vertice determinado a todos los otros vértices del grafo
     """
     try:
-        # TODO mods Lab 11, agregar llave "search" para usar dfs y bfs
+        # TODO Lab 11, agregar llave "search" para usar dfs y bfs
         analyzer = {
             'stops': None,
             'connections': None,
             'components': None,
-            'paths': None
+            'paths': None,
+            'search': None,
         }
 
         analyzer['stops'] = m.newMap(numelements=14000,
@@ -192,7 +195,17 @@ def hasPath(analyzer, destStation):
     return djk.hasPathTo(analyzer['paths'], destStation)
 
 
-def searchPaths(analyzer, initialStation, method="dfs"):
+def minimumCostPath(analyzer, destStation):
+    """
+    Retorna el camino de costo minimo entre la estacion de inicio
+    y la estacion destino
+    Se debe ejecutar primero la funcion minimumCostPaths
+    """
+    path = djk.pathTo(analyzer['paths'], destStation)
+    return path
+
+
+def searchPaths(analyzer, initialStation, method):
     """
     searchPaths Calcula los caminos posibles desde una estacion de origen
     y puede utilizar los algoritmos "dfs" o "bfs"
@@ -205,16 +218,18 @@ def searchPaths(analyzer, initialStation, method="dfs"):
     Returns:
         dict: devuelve el analyzer del modelo
     """
-    # TODO mods Lab 11, ejectutar DepthFirstSearch de dfs
+    # TODO Lab 11, ejectutar DepthFirstSearch de dfs
     if method == "dfs":
-        pass
-    # TODO mods Lab 11, ejectutar BreadhtFisrtSearch de bfs
+        analyzer['search'] = dfs.DepthFirstSearch(analyzer['connections'],
+                                                  initialStation)
+    # TODO Lab 11, ejectutar BreadhtFisrtSearch de bfs
     elif method == "bfs":
-        pass
+        analyzer['search'] = bfs.BreadhtFisrtSearch(analyzer['connections'],
+                                                    initialStation)
     return analyzer
 
 
-def hasSearchPath(analyzer, destStation, method="dfs"):
+def hasSearchPath(analyzer, destStation, method):
     """
     hasSearchPath indica si existe un camino desde la estacion inicial a
     la estación destino. Se debe ejecutar primero la funcion searchPaths()
@@ -224,15 +239,15 @@ def hasSearchPath(analyzer, destStation, method="dfs"):
         destStation (vertice): estacion de destino para el recorrido
         method (str, optional): algoritmo de busqueda. Por defecto es "dfs"
     """
-    # TODO mods Lab 11, ejectutar hasPathTo por dfs
+    # TODO Lab 11, ejectutar hasPathTo por dfs
     if method == "dfs":
-        pass
-    # TODO mods Lab 11, ejectutar hasPathTo por bfs
+        return dfs.hasPathTo(analyzer['search'], destStation)
+    # TODO Lab 11, ejectutar hasPathTo por bfs
     elif method == "bfs":
-        pass
+        return bfs.hasPathTo(analyzer['search'], destStation)
 
 
-def searchPath(analyzer, destStation, method="dfs"):
+def searchPathTo(analyzer, destStation, method):
     """
     searchPath retorna el camino de encontrado entre la estacion de inicio
     y la estacion destino Se debe ejecutar primero la funcion searchPaths
@@ -246,22 +261,12 @@ def searchPath(analyzer, destStation, method="dfs"):
         stack: devuele una pila con el camino encontrado en la busqueda.
     """
     path = None
-    # TODO mods Lab 11, ejectutar pathTo por dfs
+    # TODO Lab 11, ejectutar pathTo por dfs
     if method == "dfs":
-        pass
-    # TODO mods Lab 11, ejectutar pathTo por bfs
+        path = dfs.pathTo(analyzer['search'], destStation)
+    # TODO Lab 11, ejectutar pathTo por bfs
     elif method == "bfs":
-        pass
-    return path
-
-
-def minimumCostPath(analyzer, destStation):
-    """
-    Retorna el camino de costo minimo entre la estacion de inicio
-    y la estacion destino
-    Se debe ejecutar primero la funcion minimumCostPaths
-    """
-    path = djk.pathTo(analyzer['paths'], destStation)
+        path = dfs.pathTo(analyzer['search'], destStation)
     return path
 
 

App/view.py

@@ -56,16 +56,16 @@
 def printMenu():
     print("\n")
     print("*******************************************")
+    # TODO Lab 11, asegurarse de completar las opciones 4, 9 y 10
     print("Bienvenido")
     print("1- Inicializar Analizador")
     print("2- Cargar información de buses de singapur")
     print("3- Calcular componentes conectados")
-    print("4- Establecer estación base:")
-    print("5- Hay camino entre estacion base y estación: ")
-    print("6- Ruta de costo mínimo desde la estación base y estación: ")
-    print("7- Estación que sirve a mas rutas: ")
-    # TODO mods Lab 11, asegurarse de completar las opciones 8, 9 y 10
-    print("8- Cambiar metodo de busqueda ('bfs' o 'dfs'):")
+    print("4- Configurar metodo de busqueda ('bfs' o 'dfs'):")
+    print("5- Establecer estación base:")
+    print("6- Hay camino entre estacion base y estación: ")
+    print("7- Ruta de costo mínimo desde la estación base y estación: ")
+    print("8- Estación que sirve a mas rutas: ")
     print("9- Existe un camino de busqueda entre base y estación: ")
     print("10- Ruta de busqueda entre la estación base y estación: ")
     print("0- Salir")
@@ -88,22 +88,26 @@ def optionThree(cont):
 
 
 def optionFour(cont, initialStation):
+    print('Calculando costo de caminos')
     controller.minimumCostPaths(cont, initialStation)
-    # TODO mods Lab 11, conectar con la funcion del controller searchPaths
-    if searchMethod is not None:
-        pass
-    else:
-        pass
+    print("FIN!")
+
+
+def optionFive(cont, initialStation, searchMethod):
+    # TODO Lab 11, conectar con la funcion del controller searchPaths
+    print('Calculando caminos de busqueda con ' + searchMethod)
+    controller.searchPaths(cont, initialStation, searchMethod)
+    print("FIN!")
 
 
-def optionFive(cont, destStation):
+def optionSix(cont, destStation):
     haspath = controller.hasPath(cont, destStation)
     print('Hay camino entre la estación base : ' +
           'y la estación: ' + destStation + ': ')
     print(haspath)
 
 
-def optionSix(cont, destStation):
+def optionSeven(cont, destStation):
     path = controller.minimumCostPath(cont, destStation)
     if path is not None:
         pathlen = stack.size(path)
@@ -115,28 +119,29 @@ def optionSix(cont, destStation):
         print('No hay camino')
 
 
-def optionSeven(cont):
+def optionEight(cont):
     maxvert, maxdeg = controller.servedRoutes(cont)
     print('Estación: ' + maxvert + '  Total rutas servidas: '
           + str(maxdeg))
 
 
-def optionEight(cont, searchMethod):
-    # TODO mods Lab 11, conectar con la funcion del controller searchPaths
-    pass
-
-
-def optionNine(cont, destStation):
-    # TODO mods Lab 11, conectar con la funcion del controller hasSearchPath
-    haspath = None
+def optionNine(cont, destStation, searchMethod):
+    # TODO Lab 11, conectar con la funcion del controller hasSearchPath
+    haspath = controller.hasSearchPath(cont, destStation, searchMethod)
+    print('Hay camino de busqueda entre la estación base : ' +
+          'y la estación: ' + destStation + ': ')
     print(haspath)
 
 
-def optionTen(cont, destStation):
-    # TODO mods Lab 11, conectar con la funcion del controller searchPath
-    path = None
+def optionTen(cont, destStation, searchMethod):
+    # TODO Lab 11, conectar con la funcion del controller searchPath
+    path = controller.searchPathTo(cont, destStation, searchMethod)
     if path is not None:
-        pass
+        pathlen = stack.size(path)
+        print('El camino de busqueda es de longitud: ' + str(pathlen))
+        while (not stack.isEmpty(path)):
+            stop = stack.pop(path)
+            print(stop)
     else:
         print('No hay camino')
 
@@ -168,30 +173,32 @@ def thread_cycle():
             optionFour(cont, initialStation)
 
         elif int(inputs) == 5:
-            destStation = input("Estación destino (Ej: 15151-10): ")
-            optionFive(cont, destStation)
+            # TODO Lab 11, completar inputs opt 8
+            msg = "Estación Base: BusStopCode-ServiceNo (Ej: 75009-10): "
+            initialStation = input(msg)
+            searchMethod = input("Seleccione 'dfs' o 'bfs' como algoritmo: ")
+            optionFive(cont, initialStation, searchMethod)
 
         elif int(inputs) == 6:
             destStation = input("Estación destino (Ej: 15151-10): ")
             optionSix(cont, destStation)
 
         elif int(inputs) == 7:
-            optionSeven(cont)
+            destStation = input("Estación destino (Ej: 15151-10): ")
+            optionSeven(cont, destStation)
 
-        elif int(inputs) == 8:
-            # TODO mods Lab 11, completar inputs opt 8
-            searchMethod = input("Seleccione 'dfs' o 'bfs' como algoritmo: ")
-            optionEight(cont, searchMethod)
+        elif int(inputs) == 7:
+            optionEight(cont)
 
         elif int(inputs) == 9:
-            # TODO mods Lab 11, completar inputs opt 9
+            # TODO Lab 11, completar inputs opt 9
             destStation = input("Estación destino (Ej: 15151-10): ")
-            optionNine(cont, destStation)
+            optionNine(cont, destStation, searchMethod)
 
         elif int(inputs) == 10:
-            # TODO mods Lab 11, completar inputs opt 10
+            # TODO Lab 11, completar inputs opt 10
             destStation = input("Estación destino (Ej: 15151-10): ")
-            optionTen(cont, destStation)
+            optionTen(cont, destStation, searchMethod)
 
         else:
             sys.exit(0)