Nouveau Challenge3Bis à lancer

Challenge3/code/challenge3.py

@@ -6,14 +6,15 @@ from mpl_toolkits.mplot3d import Axes3D
 import matplotlib.pyplot as plt
 from math import atan, pi
 from matplotlib import pyplot
+import csv
 
 
-input_filename_altitude="D:/documents/IMT/datascience/challenge3/moodle/altitude-map.bmp"
-#input_filename_altitude="../moodle/altitude-map.bmp"
+#input_filename_altitude="D:/documents/IMT/datascience/challenge3/moodle/altitude-map.bmp"
+input_filename_altitude="../moodle/altitude-map.bmp"
 im_alt = Image.open(input_filename_altitude)
 
-input_filename_poputation="D:/documents/IMT/datascience/challenge3/moodle/population-density-map.bmp"
-#input_filename_poputation="../moodle/population-density-map.bmp"
+#input_filename_poputation="D:/documents/IMT/datascience/challenge3/moodle/population-density-map.bmp"
+input_filename_poputation="../moodle/population-density-map.bmp"
 im_pop = Image.open(input_filename_poputation)
 
 
@@ -120,6 +121,33 @@ def neighbors(node, size):
 print("alt = ",altCaseXY((4435//15,2214//15)))
 print("pop = ",popCaseXY((4435//15,2214//15)))
 
+def exportgraphe(graphe):
+    """Fonction permettant de transformer le graphe en un fichier csv"""
+    flat=[]
+    for line in graphe:
+        flat+=line
+    with open("../moodle/graphe60jours.csv", 'a') as outcsv:   
+        #configure writer to write standard csv file
+        writer = csv.writer(outcsv, delimiter=',', quotechar='|', quoting=csv.QUOTE_MINIMAL, lineterminator='\n')
+        for item in flat:
+            #Write item to outcsv
+            writer.writerow([item[0], item[1], item[2][0], item[2][1], item[2][2], item[2][3], item[2][4], item[2][5], item[2][6], item[2][7], item[2][8], item[2][9], item[2][10], item[2][11], item[2][12], item[2][13], item[2][14]])
+
+
+def importgraphe(nbline,nbcol):
+    """Fonction permettant de récupérer un fichier csv et de le transformer en graphe"""
+    with open("../moodle/graphe60jours.csv",newline='') as f:
+        reader = csv.reader(f,delimiter=',')
+        uidlist = list(reader)
+    res=[[[] for _ in range(nbcol)] for _ in range(nbline)]
+    compteur=0
+    for line in uidlist:
+        res[compteur%nbline][compteur//nbline].append(float(line[0]))
+        res[compteur%nbline][compteur//nbline].append(float(line[1]))
+        res[compteur%nbline][compteur//nbline].append([float(elt) for elt in line[2:]])
+        compteur+=1
+    return(res)
+
 
 """ x=range(4830)
 y=range(3510)
@@ -389,11 +417,17 @@ def stepThree(Graph):
     return updatedGraph
 
 
-#20 Itérations
+#Itérations
 
-for i in range(500):
+"""for i in range(60):
     print(stepThree(Graph)[87][43], len(Graph), len(Graph[0]))
     print('Jour', i+1, 'terminé!')
+    if i == 59:
+        exportgraphe(Graph) """ 
+
 
+#Graphe à 60 jours
+graphe60jours=importgraphe(3510//15, 4830//15)
 
-print(Graph[2103//15:229])       
+a = stepThree(graphe60jours)     
+print('bon')

Challenge3/code/challenge3Bis.py

+# -*- coding: utf-8 -*-
+from PIL import Image
+import numpy as np
+import mpl_toolkits.mplot3d
+from mpl_toolkits.mplot3d import Axes3D
+import matplotlib.pyplot as plt
+from math import atan, pi
+from matplotlib import pyplot
+import csv
+import math
+import matplotlib as mpl
+
+#input_filename_altitude="D:/documents/IMT/datascience/challenge3/moodle/altitude-map.bmp"
+input_filename_altitude="../moodle/altitude-map.bmp"
+im_alt = Image.open(input_filename_altitude)
+
+#input_filename_poputation="D:/documents/IMT/datascience/challenge3/moodle/population-density-map.bmp"
+input_filename_poputation="../moodle/population-density-map.bmp"
+im_pop = Image.open(input_filename_poputation)
+
+
+# This modules gives useful informations
+width=im_alt.size[0]
+heigth=im_alt.size[1]
+
+# To plot an histogram
+
+pix_mont_blanc=im_alt.getpixel((1573,1593))
+pix_sea_level=im_alt.getpixel((929,1666))
+pix_sea=im_alt.getpixel((1,1))
+
+def getAltitude(rgbValues):
+    '''assigne à un triplet RGB (gris) une altitude'''
+    greyValue=rgbValues[0]
+    return(4810/255*greyValue)
+
+def getAltXY(pixel):
+    '''Permet d'avoir l'altitude réelle pour un pixel'''
+    rgbValues=im_alt.getpixel(pixel)
+    return(getAltitude(rgbValues))
+
+
+def getPopXY(pixel):
+    '''Permet d'avoir la population réelle pour un pixel'''
+    pop_max=3000
+    rgbValues=im_pop.getpixel(pixel) #c'est des niveaux de gris, donc r=g=b
+    if rgbValues[0]>=24: #la mer n'est pas totalement noire ((24,24,24) ou (16,16,16)), on filtre donc
+        res=(rgbValues[0]-24)*pop_max/231 #231=255-24
+    else:
+        res=0
+    return(res)
+
+def popCaseXY(case): 
+    '''Permet d'avoir la population moyenne réelle d'une cellule (donc prend une cellule en entrée)'''
+    return(sum([sum([getPopXY((col,line)) for col in range(case[0]*15,case[0]*15+15)]) for line in range(case[1]*15,case[1]*15+15)]))
+
+
+def altCaseXY(case):
+    '''Permet d'avoir l'altitude moyenne réelle d'une cellule (donc prend une cellule en entrée)'''
+    return(max([max([getAltXY((col,line)) for col in range(case[0]*15,case[0]*15+15)]) for line in range(case[1]*15,case[1]*15+15)]))
+
+
+
+#### from now on, the functions deal with the graph with cells of 15*15 pixels ####
+
+def denivele(graphe,case1,case2): 
+    '''Donne le denivelé entre deux cellules du graphe'''
+    #print(case1, case2, 'deux cases')
+    return(abs(atan((graphe[case1[0]][case1[1]][1]-graphe[case2[0]][case2[1]][1])/15000))) #positif #Division par 15?
+
+
+def lambdad(graphe,case1,case2):
+    res=0
+    d=denivele(graphe,case1,case2)
+    if d<pi/9:
+        res=(pi/9-d)*9/pi
+    return(res)
+
+
+
+
+def voisins(graphe,x,y):
+    '''graphe représente notre graphe sous la forme [[  ,[pop,alt],  ,  ],...,[  ,  ,  ,  ]]'''
+
+    res=[[[xi,yi] for xi in range(x-1,x+2)] for yi in range(y-1,y+2)]
+    largeur=len(graphe[0])
+    longueur=len(graphe)
+    flat=[]
+    for ligne in res:
+        for point in ligne:
+            if (point[0]>=0) & (point[0]<=largeur-1) & (point[1]>=0) & (point[1]<=longueur-1) & ([x,y]!=point) & (graphe[point[0]][point[1]]!=-1) & (graphe[point[0]][point[1]]<=50):
+                flat.append(point)
+    return(flat)
+
+def neighbors(node, size):
+#size represent the whole size of the image
+
+    my_neighbors =[]
+    x,y = node[0],node[1]
+    if x-1>=0:
+        my_neighbors.append((x-1,y))
+    if y-1>=0:
+        my_neighbors.append((x,y-1))
+    if x-1>=0 and y-1>=0:
+        my_neighbors.append((x-1,y-1))
+    if x+1<size[0]:
+        my_neighbors.append((x+1,y))
+    if y+1<size[1]:
+        my_neighbors.append((x,y+1))
+    if x+1<size[0] and y+1<size[1]:
+        my_neighbors.append((x+1,y+1))
+    if x+1<size[0] and y-1>=0:
+        my_neighbors.append((x+1,y-1))
+    if y+1<size[1] and x-1>=0:
+        my_neighbors.append((x-1,y+1))
+    return my_neighbors
+
+
+
+def exportgraphe(graphe):
+    """Fonction permettant de transformer le graphe en un fichier csv"""
+    flat=[]
+    for line in graphe:
+        flat+=line
+    with open("../moodle/graphe60jours.csv", 'a') as outcsv:   
+        #configure writer to write standard csv file
+        writer = csv.writer(outcsv, delimiter=',', quotechar='|', quoting=csv.QUOTE_MINIMAL, lineterminator='\n')
+        for item in flat:
+            #Write item to outcsv
+            writer.writerow([item[0], item[1], item[2][0], item[2][1], item[2][2], item[2][3], item[2][4], item[2][5], item[2][6], item[2][7], item[2][8], item[2][9], item[2][10], item[2][11], item[2][12], item[2][13], item[2][14]])
+
+
+def importgraphe(nbline,nbcol):
+    """Fonction permettant de récupérer un fichier csv et de le transformer en graphe"""
+    with open("../moodle/graphe60jours.csv",newline='') as f:
+        reader = csv.reader(f,delimiter=',')
+        uidlist = list(reader)
+    res=[[[] for _ in range(nbcol)] for _ in range(nbline)]
+    compteur=0
+    for line in uidlist:
+        res[compteur%nbline][compteur//nbline].append(float(line[0]))
+        res[compteur%nbline][compteur//nbline].append(float(line[1]))
+        res[compteur%nbline][compteur//nbline].append([float(elt) for elt in line[2:]])
+        compteur+=1
+    return(res)
+
+def isZombie(case):
+    res=1
+    if case[0]==0:
+        res=0.5
+    if sum(case[2])!=0:
+        res=0
+    return(res)
+
+
+#On fait viellir les zombies grâce à cette fonction
+def getZombiesOlder(zombiesList):
+    for i in range(15):
+        zombiesList[14-i]=zombiesList[13-i]
+    zombiesList[0]=0
+
+#Sera utile pour vérifier si oui ou non une cellule contient des zombies : prend en paramètre la liste du nombre de zombies d'une cellule classés par âge
+def are_they_zombies(zombies):
+    boolean = False
+    for i in zombies:
+        if i!= 0:
+            boolean = True
+    return boolean
+            
+
+def zombies_repartition(zombies, N): #N is the number of zombies that we want to affect to a neighboring cell
+    repartition = [] #This repartition is done giving the age of the zombies
+    for i in zombies:
+        if sum(zombies) != 0:
+            repartition.append((i/sum(zombies))*N)  
+    return repartition  
+
+
+#Zombies présents dans une cellule
+
+def enteredZombies(zombiesList):
+    return sum(zombiesList)
+
+
+
+
+#STEP ONE
+def stepOne(Graph, protected):
+    graphe = Graph.copy()
+    #Calcul du nombre de zombies partant des cellules
+    zombiesStart = 0
+    for i in range(len(graphe)):
+        for j in range(len(graphe[i])):
+            zombiesStart = zombiesStart + sum(graphe[i][j][2])
+    
+    #Ici comme je ne peux pas faire une copie sans modifier la liste ensuite je suis obligé de faire un petit dico ce qui est un peu dommage
+    #graphe_memory = graphe.copy()
+    graphe_memory = {}
+    for i in range(len(graphe)):
+        for j in range(len(graphe[i])):
+            graphe_memory[(i,j)] = sum(graphe[i][j][2]) 
+    #On parcourt la liste de toutes les cellul es et on regarde pour chacune d'elle s'il y a des zombies si oui on les répartis dans les cellules voisines
+    for i in range(len(graphe)):
+        for j in range(len(graphe[i])):
+            #print((i,j), 'noeud en question')
+            if are_they_zombies(graphe[i][j][2]) == 1: #Cela signifie qu'on a bien des zombies dans cette cellule
+                neighbor = neighbors((i, j),(len(graphe),len(graphe[0]))) #On récupère les cellules voisines
+                if protected in neighbor:
+                    neighbor.remove(protected)
+                neighbors_population = 0
+                for n in neighbor:   
+                    neighbors_population = neighbors_population + graphe[n[0]][n[1]][0]     #On récupère la population totale de nos voisins
+
+                possible_neighbors = [] #Cette liste ne contiendra uniquement les voisins succeptibles d'être contaminés
+                lambdab_possible_neighbors = [] 
+                for k in neighbor:
+                    if lambdad(graphe,(i,j),k) != 0:
+                        possible_neighbors.append(k)
+                        lambdab_possible_neighbors.append(lambdad(graphe,(i,j),k)) #On est en possession des voisins contaminables et des coefficients correspondants
+                #print(len(lambdab_possible_neighbors), 'contaminables')
+                for  k in range(len(possible_neighbors)): #We compute the number of zombies going to a neighboring cell
+                    if neighbors_population != 0:
+                        N = ((graphe[possible_neighbors[k][0]][possible_neighbors[k][1]][0])/neighbors_population)*lambdab_possible_neighbors[k]*graphe_memory[(i,j)]
+                    else:
+                        N = 0
+                                 
+
+                    #From now on we can distribute the zombies on the possible neighboring cells 
+                    #On va repartir les zombies par rapport à leur quantité par groupes d'âges 
+                    repartition = zombies_repartition(graphe[i][j][2], N)
+                    
+                    #print(repartition, 'repartition', N, 'pop init',graphe_memory[(i,j)])
+
+                    #Ensuite on ajoute les nouveaux zombies dans la cellule en question
+                    #En supposant que les zombies ne disparaissent pas juste, on retire de la cellule actuelle les zombies qui partent dans cellules voisines
+                    for ind in range(len(repartition)):
+                        graphe[possible_neighbors[k][0]][possible_neighbors[k][1]][2][ind] = graphe[possible_neighbors[k][0]][possible_neighbors[k][1]][2][ind] + repartition[ind]
+                        graphe[i][j][2][ind] = graphe[i][j][2][ind] - repartition[ind]
+                        
+
+    #Maintenant on fait vieillir tout le monde
+    for i in range(len(graphe)):
+        for j in range(len(graphe[i])):
+            getZombiesOlder(graphe[i][j][2])
+
+
+    #Calcul du nombre de zombies arrivés dans les cellules
+    zombiesEnd = 0
+    for i in range(len(graphe)):
+        for j in range(len(graphe[i])):
+            zombiesEnd = zombiesEnd + sum(graphe[i][j][2])
+
+    #print(zombiesStart, zombiesEnd, 'start end') #C'est juste pour vérifier qu'on a bien la même chose 
+    return graphe
+
+                        
+#STEP TWO
+def stepTwo(Graph, protected):
+    graphe = Graph.copy()
+    #Calcul de la population initiale (zombies et humains)
+    zombiesHumainStart = 0
+    for i in range(len(graphe)):
+        for j in range(len(graphe[i])):
+            zombiesHumainStart = zombiesHumainStart + sum(graphe[i][j][2]) + graphe[i][j][0]
+    updatedGraph = stepOne(graphe, protected)
+    for i in range(len(updatedGraph)):
+        for j in range(len(updatedGraph[i])):
+            potentialKilledHuman = 10*enteredZombies(updatedGraph[i][j][2]) #Nombre d'humains potentiels qui seront tués    
+            #print(potentialKilledHuman, enteredZombies(updatedGraph[i][j][2]))
+            if potentialKilledHuman >= updatedGraph[i][j][0]: #Si on a moins d'humains que le nombre potentiel à détruire alors ils sont tous tués
+                newZombies = updatedGraph[i][j][0] #Et on la transforme en zombies
+                updatedGraph[i][j][2][0] = newZombies #Ils sont tous agés de 0 jour (ces nouveaux zombies).
+                updatedGraph[i][j][0] = 0    #L'ancienne population est détruite
+            
+            if potentialKilledHuman < updatedGraph[i][j][0]:#Si on a plus d'humains que le nombre potentiel à détruire alors on en conserve une partie 
+                newZombies = potentialKilledHuman
+                updatedGraph[i][j][2][0] = newZombies
+                updatedGraph[i][j][0] = updatedGraph[i][j][0] - potentialKilledHuman
+
+    #Calcul de la population finale 
+    zombiesHumainEnd = 0
+    for i in range(len(graphe)):
+        for j in range(len(graphe[i])):
+            zombiesHumainEnd = zombiesHumainEnd + sum(graphe[i][j][2]) + graphe[i][j][0]
+    #print(zombiesHumainStart, zombiesHumainEnd, 'pop init fin step 2') #Entre 0 et 15 jours on doit avoir la même chose
+    return updatedGraph
+
+
+
+#STEP THREE
+def stepThree(Graph, protected):
+    graphe = Graph.copy()
+    #Calcul de la population initiale
+    zombiesHumainStart = 0
+    for i in range(len(graphe)):
+        for j in range(len(graphe[i])):
+            zombiesHumainStart = zombiesHumainStart + sum(graphe[i][j][2]) + graphe[i][j][0]
+    updatedGraph = stepTwo(graphe, protected)
+    for i in range(len(updatedGraph)):
+        for j in range(len(updatedGraph[i])):
+            potentialKilledZombies = 10*updatedGraph[i][j][0]
+            if potentialKilledZombies >= enteredZombies(updatedGraph[i][j][2]): #On regarde si les zombies potentiels qui seront tués sont plus nombreux que ceux déjà présents
+                updatedGraph[i][j][2] = [0 for i in range(15)] #si c'est le cas on s'en débarasse
+            if potentialKilledZombies < enteredZombies(updatedGraph[i][j][2]): #Si on a plus de zombies que le nombre potentiel à tuer on conserve une partie
+                #On va répartir les zombies à tuer selon la quantité présente par tranche d'âge
+                killedZombiesRepartition = zombies_repartition(updatedGraph[i][j][2], potentialKilledZombies)
+                for p in range(len(updatedGraph[i][j][2])):
+                    updatedGraph[i][j][2][p] = updatedGraph[i][j][2][p] - killedZombiesRepartition[p] #On retire les zombies à tuer et on conserve le reste
+
+    #Calcul de la population finale 
+    zombiesHumainEnd = 0
+    for i in range(len(graphe)):
+        for j in range(len(graphe[i])):
+            zombiesHumainEnd = zombiesHumainEnd + sum(graphe[i][j][2]) + graphe[i][j][0]
+    #print(zombiesHumainStart, zombiesHumainEnd, 'pop init fin step 3')
+    return updatedGraph
+
+
+def population_totale(graphe):
+    pop = 0
+    for i in range(len(graphe)):
+        for j in range(len(graphe[0])):
+            pop = pop + graphe[i][j][0]
+    return pop
+
+#Graphe à 60 jours
+graphe60jours=importgraphe(3510//15, 4830//15)
+
+#Où sont les zombies?
+
+
+x = [[isZombie(case) for case in line] for line in graphe60jours]
+fig, ax = plt.subplots()
+
+# define the colors
+cmap = mpl.colors.ListedColormap(['b', 'g', 'r', 'c', 'm', 'y', 'k', 'w'])
+
+# create a normalize object the describes the limits of
+# each color
+bounds = [0., 0.3,0.6, 1.]
+norm = mpl.colors.BoundaryNorm(bounds, cmap.N)
+
+# plot it
+ax.imshow(x, interpolation='none', cmap=cmap, norm=norm)
+plt.show()
+
+##On cherche les 20 cases optimales
+pop_init = 0
+protected = (-1,-1)
+graphe = stepThree(importgraphe(3510//15, 4830//15), protected)
+
+"""for i in range(100, 105):
+    for j in range(175,180):
+        for d in range(29):
+            graphe = stepThree(graphe,(i,j))
+        print((i,j),d,'eme jour','terminé))
+        graphe = stepThree(importgraphe(3510//15, 4830//15), protected)
+        current_population = population_totale(graphe)
+        if current_population>=pop_init:
+            print(current_population)
+            pop_init = current_population
+            protected = (i,j)"""
+
+
+#print(protected, pop_init)
+        
+        
+
+