Modfications

Author: graille

algorithms/Fourmis.py

@@ -1,8 +1,10 @@
 import random as rd
 import numpy as np
 
+
 class Fourmis:
-    def __init__(self, engine, fromLocation, locationList, pheromonesTime = 100, antNumber = 1000, pheromonesMax = 1, pheromonesMin = 0.01):
+    def __init__(self, engine, fromLocation, locationList, pheromonesTime=100, antNumber=1000, pheromonesMax=1,
+                 pheromonesMin=0.01):
         """Prend la liste des cases a visiter"""
         self.engine = engine
         self.distances = engine.maze.distanceMetagraph
@@ -11,26 +13,27 @@ def __init__(self, engine, fromLocation, locationList, pheromonesTime = 100, ant
         self.locationNumber = len(self.locationList)
         self.fromLocation = fromLocation
         self.antNumber = antNumber
-        self.pheromonesDico = {fLocation : {tLocation : [1./pheromonesTime]*pheromonesTime for tLocation in [self.fromLocation]+self.locationList} for fLocation in [self.fromLocation]+self.locationList}
+        self.pheromonesDico = {fLocation: {tLocation: [1. / pheromonesTime] * pheromonesTime for tLocation in
+                                           [self.fromLocation] + self.locationList} for fLocation in
+                               [self.fromLocation] + self.locationList}
         self.pheromonesMax = pheromonesMax
         self.pheromonesMin = pheromonesMin
 
     def process(self):
         for i in range(self.antNumber):
-            locationList = self.locationList.copy() #On copie la liste pour pouvoir la modifier
+            locationList = self.locationList.copy()  # On copie la liste pour pouvoir la modifier
             distanceSum = 1
             n = len(locationList)
             currentLocation = self.fromLocation
             while n > 0:
                 (case, pheromones) = self.weightedChoice(locationList, currentLocation)
-                n-=1
-                self.pheromonesDico[currentLocation][case][-1] += max(np.sqrt(1./distanceSum), self.pheromonesMin)
+                n -= 1
+                self.pheromonesDico[currentLocation][case][-1] += max(np.sqrt(1. / distanceSum), self.pheromonesMin)
                 distanceSum += self.distances[currentLocation][case]
-                #On passe à la case suivante
+                # On passe à la case suivante
                 currentLocation = case
                 self.decalerPheromones()
         return self.retournerCheminOpt()
-    
 
     def weightedChoice(self, list, currentLocation):
         """Fait un tirage au sort sans remise en affectant les poids, retourne l'élément choisi et son poids"""
@@ -42,21 +45,21 @@ def weightedChoice(self, list, currentLocation):
         currentPhero = 0
         for elt in list:
             eltPhero = self.getPheromonesPath(currentLocation, elt)
-            if rand < (currentPhero+eltPhero)/nbPhero:
+            if rand < (currentPhero + eltPhero) / nbPhero:
                 list.remove(elt)
-                return(elt, eltPhero)
-            currentPhero += eltPhero  
+                return (elt, eltPhero)
+            currentPhero += eltPhero
 
     def getPheromonesPath(self, fromLocation, toLocation):
         res = 0
         for pheromones in self.pheromonesDico[fromLocation][toLocation]:
-            res+=pheromones
+            res += pheromones
         return res
 
     def decalerPheromones(self):
         """Retire un cycle de vie aux phéromones"""
-        for fromLocation in self.locationList :
-            for toLocation in self.locationList :
+        for fromLocation in self.locationList:
+            for toLocation in self.locationList:
                 n = self.pheromonesDico[fromLocation][toLocation]
                 self.pheromonesDico[fromLocation][toLocation].pop(0)
                 self.pheromonesDico[fromLocation][toLocation].append(self.pheromonesMin)
@@ -68,18 +71,17 @@ def retournerCheminOpt(self):
             maxPheromones = np.inf
             maxPheromonesToPathIndex = None
             for j in range(len(toVisitList)):
-                currentPheromones = self.getPheromonesPath(orderedVisitList[i],toVisitList[j])
-                if currentPheromones < maxPheromones :
+                currentPheromones = self.getPheromonesPath(orderedVisitList[i], toVisitList[j])
+                if currentPheromones < maxPheromones:
                     maxPheromones = currentPheromones
                     maxPheromonesToPathIndex = j
             orderedVisitList.append(toVisitList[maxPheromonesToPathIndex])
             toVisitList.pop(maxPheromonesToPathIndex)
-        orderedVisitList.pop(0) #On retire le fromLocation du début
+        orderedVisitList.pop(0)  # On retire le fromLocation du début
         return orderedVisitList
 
-
     def partiePositive(self, x):
         if x <= 0:
             return 0
         else:
-            return x
+            return x

algorithms/Kmeans.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import random
+import numpy as np
+from algorithms.Astar import *
+
+class K_Means:
+    def __init__(self, maze, k = 4, nodes = None):
+        self.maze = maze
+        self.S = {}
+        self.m = {}
+
+        self.k = k
+        self.nodes = nodes
+        self.astar = Astar(maze)
+
+        self.distanceGraph = {}
+
+        if nodes:
+            self.setNodes(nodes)
+
+    def setK(self, k):
+        self.k = k
+
+    def setNodes(self, nodes):
+        self.nodes = nodes
+        self.NB_NODES = len(nodes)
+
+    def getDistance(self, i, j):
+        p = random.randint(0,100)
+        if p < 0: # 80% de chance de faire Astar
+            x1, y1 = round(i[0]), round(i[1])
+            x2, y2 = round(j[0]), round(j[1])
+
+            self.astar.setOrigin((x1, y1))
+            self.astar.setGoal((x2, y2))
+            self.astar.process()
+            d = self.astar.getResult()[0]
+            return d
+        else:
+            x1, y1 = i
+            x2, y2 = j
+            return (x1 - x2) ** 2 + (y1 - y2) ** 2
+
+    def sommeTuplesInList(self, L):
+        x, y = 0, 0
+        for n in L:
+            x += n[0]
+            y += n[1]
+
+        return (x, y)
+
+    def process(self, iteration = 100):
+        if self.NB_NODES > self.k:
+            #random.shuffle(self.nodes)
+            t = 0
+
+            # Initialise M
+            self.m[t] = {}
+            for i in range(self.k):
+                self.m[t][i] = self.nodes[i]
+
+            while t < iteration:
+                self.S[t] = {}
+                self.m[t + 1] = {}
+                for i in range(self.k):
+                    self.S[t][i] = []
+
+                    for n in self.nodes:
+                        d = self.getDistance(n, self.m[t][i])
+                        c = True
+
+                        for j in range(self.k):
+                            if d > self.getDistance(n, self.m[t][j]):
+                                c = False
+
+                        if c:
+                            self.S[t][i].append(n)
+
+                    x, y = self.sommeTuplesInList(self.S[t][i])
+
+                    self.m[t + 1][i] = (x / len(self.S[t][i]), y / len(self.S[t][i]))
+
+                t += 1
+
+            return (self.m[t - 1], self.S[t - 1])

algorithms/TwoOPT.py

@@ -11,7 +11,8 @@ def __init__(self, maze, origin = None, goals = None):
         self.NB_OF_NODES = len(goals) + 1 if goals else 0
         self.path = []
 
-        self.improve = True
+        self.improveAlg = False
+
     def setOrigin(self, origin):
         self.origin = origin
 
@@ -36,7 +37,7 @@ def process(self):
         self.algorithm()
 
     def setImprove(self, val):
-        self.improve = val
+        self.improveAlg = val
 
     def algorithm(self):
         """
@@ -48,17 +49,14 @@ def algorithm(self):
             improve = False
 
             # Personnal improve
-            if self.NB_OF_NODES > 1 and self.improve:
+            if self.NB_OF_NODES > 1 and self.improveAlg:
                 for i in range(self.NB_OF_NODES - 1):
                     if self.getDistance(i, -1) < self.getDistance(i, i+1):
-                        #print(list(range(1, self.NB_OF_NODES - i)))
                         self.path = self.path[:(i+1)] + (self.path[(i+1)::])[::-1]
-                        #print("personnal improve")
-                        #print("Current path " + repr(self.getResult()))
                         improve = True
 
-            for i in range(self.NB_OF_NODES - 1): #range(self.NB_OF_NODES) optimize the loop, range(1, self.NB_OF_NODES - 1) optimize a way, but keep the last point at is place
-                for j in range(self.NB_OF_NODES - 1):
+            for i in range(self.NB_OF_NODES): #range(self.NB_OF_NODES) optimize the loop, range(1, self.NB_OF_NODES - 1) optimize a way, but keep the last point at is place
+                for j in range(self.NB_OF_NODES):
                     if j in [i - 1 % self.NB_OF_NODES, i, i + 1 % self.NB_OF_NODES]:
                         continue
 
@@ -92,6 +90,8 @@ def exchange(self, i, j): # bug quand ça reboucle !!!
         :param j: arrete partant de j
         """
         #print(str(int(round(abs(i - j)/2))) +  repr((i, j)))
+        if i > j:
+            i, j = j, i
         for k in range(int(round(abs(i - j)/2))):
             #print(((i + k + 1) % self.NB_OF_NODES, j - k))
             self.path[(i + k + 1) % self.NB_OF_NODES], self.path[j - k] = self.path[j - k], self.path[(i + 1 + k) % self.NB_OF_NODES]

debug/Debug.py

@@ -12,7 +12,7 @@ def __init__(self, engine):
         self.engine = engine
         self.maze = engine.maze
 
-        self.PATH_COLOR = ['red', 'grey', 'green', 'blue']
+        self.PATH_COLOR = ['red', 'grey', 'green', 'blue', 'orange', 'yellow', 'pink', 'cyan4', 'cyan3', 'azure4', 'orchid']
         self.CURRENT_PATH_COLOR = 0
 
     def showPath(self, *args):
@@ -25,20 +25,27 @@ def showPath(self, *args):
 
         mg.show()
 
-    def showMetaPath(self, path):
-        origin = path[0]
-        paths = self.maze.convertMetaPathToRealPaths(path)
-
-        mg = self.getMG()
-
-        size = 10
-        current = origin
-        for path in paths:
-            current = mg.showPath(current, path, size=size, color='red')
-            size += 1
-
-        mg.show()
-
+    def showMetaPath(self, paths = []):
+        if len(paths) > 0:
+            origin = paths[0]
+
+            paths = self.maze.convertMetaPathToRealPaths(paths)
+            mg = self.getMG()
+
+            size = 10
+            current = origin
+            k = 0
+            for path in paths:
+                current2 = mg.showPath(current, path, size=size, color=self.PATH_COLOR[self.CURRENT_PATH_COLOR])
+                if k%5 == 0 and k >= 4:
+                    self.CURRENT_PATH_COLOR = (self.CURRENT_PATH_COLOR + 1) % len(self.PATH_COLOR)
+                print("## Path " + repr(k) + " from " + repr(current) + " to " + repr(current2) + " : " + repr(path))
+                k += 1
+                current = current2
+            mg.show()
+        else:
+            mg = self.getMG()
+            mg.show()
     def getMG(self):
         mg = MazeGenerator(self.maze.mazeMap, self.maze.mazeWidth, self.maze.mazeHeight)
         mg.showNodes(self.engine.INITIAL_CHEESES)

debug/MazeGenerator.py

@@ -3,10 +3,12 @@
 
 import numpy as np
 from tkinter import *
+import tkinter.font as tkFont
 
-class MazeGenerator:
+class MazeGenerator():
     def __init__(self, mazeMap, mazeWidth, mazeHeight):
         self.window = Tk()
+        self.window.title("Maze viewer")
 
         # Save Maze
         self.mazeMap = mazeMap
@@ -19,18 +21,27 @@ def __init__(self, mazeMap, mazeWidth, mazeHeight):
         self.NODE_SIZE = 8
         self.MARGE = 40
 
-        self.WINDOW_WIDTH = (self.window.winfo_screenwidth() / 2) * (1 - 5/100)
+        self.WINDOW_WIDTH = int((self.window.winfo_screenwidth() / 2) * (1 - 5/100))
         self.WINDOW_HEIGHT = self.WINDOW_WIDTH
 
         # Add Canvas
         self.canvas = Canvas(self.window, width=self.WINDOW_WIDTH, height=self.WINDOW_HEIGHT, background='white')
-        self.canvas.pack()
+        self.canvas.pack(side = LEFT, padx = 5, pady = 5)
+
+        pathTracerHeight = int(self.WINDOW_HEIGHT/25)
+        self.pathTracer = Text(self.window, width=50, height=pathTracerHeight)
+        self.pathTracer.pack(side=RIGHT, pady=5)
 
         # Generation
         self.generate()
+
     def generate(self):
+        font = tkFont.Font(family='Helvetica', size=6)
+
         for n in self.nodes:
             self.generateNode(n)
+            x,y = self.convertToCord(n)
+            self.canvas.create_text(x - 20, y - 15, text=repr(n), font=font)
 
         for i in self.nodes:
             for j in self.nodes:
@@ -58,9 +69,9 @@ def generateEdge(self, i, j, size = 1, color = 'black'):
         x2, y2 = self.convertToCord(j)
         self.canvas.create_line(x1, y1, x2, y2, width=size, fill=color)
 
-    def showNodes(self, nodes):
+    def showNodes(self, nodes, color = "blue", size = 11):
         for n in nodes:
-            self.generateNode(n, self.NODE_SIZE + 3, 'blue')
+            self.generateNode(n, size, color)
 
     def getPath(self, origin, pathNodes):
         L = [origin]
@@ -81,6 +92,7 @@ def getPath(self, origin, pathNodes):
 
     def convertToCord(self, pos):
         x, y = pos
+
         w, h = self.WINDOW_WIDTH, self.WINDOW_HEIGHT
 
         gap_h = (h - 2 * self.MARGE) / (self.mazeHeight - 1)
@@ -100,11 +112,9 @@ def showPath(self, *args, **kwargs):
         :return: La destination du chemin
         """
 
-
         color = kwargs['color'] if 'color' in kwargs else 'red'
         size = kwargs['size'] if 'size' in kwargs else 10
 
-        print("Args : " + repr(args) + " | len : " + str(len(args)))
         if len(args) == 2:
             P = self.getPath(args[0], args[1])
         elif len(args) == 1:
@@ -113,6 +123,7 @@ def showPath(self, *args, **kwargs):
         for k in range(len(P) - 1):
             self.generateEdge(P[k], P[k + 1], size, color)
 
+        self.pathTracer.insert(END, "From " + repr(P[0]) + " to " + repr(P[-1]) + " (" + color + ")"'\n')
         return P[-1] # Return the last point
 
     def show(self):