Commit 52d91a60 authored by Jéhoiakim KINGNE's avatar Jéhoiakim KINGNE
Browse files

Version Finale

parent 141bc684
......@@ -10,27 +10,15 @@ import csv
import matplotlib as mpl
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" #On récupère la carte des altitudes
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" #On récupère la carte de la population
im_pop = Image.open(input_filename_poputation)
# This modules gives useful informations
width=im_alt.size[0]
heigth=im_alt.size[1]
print("width = ",width)
print("heigth = ", heigth)
# 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))
print(pix_sea,pix_sea_level,pix_mont_blanc) #rgb
def getAltitude(rgbValues):
'''assigne à un triplet RGB (gris) une altitude'''
greyValue=rgbValues[0]
......@@ -47,8 +35,8 @@ 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
if rgbValues[0]>=24: #la mer n'est pas totalement noire ((24,24,24) ou (16,16,16)), donc on filtre!
res=(rgbValues[0]-24)*pop_max/231 #231=255-24 Regression affine (la mer n'est pas noire et la valeur maximale des pixels de la mer est (24,24,24)).
else:
res=0
return(res)
......@@ -73,14 +61,16 @@ def denivele(graphe,case1,case2):
def lambdad(graphe,case1,case2):
"""Permet d'obtenir le slope entre deux cellules"""
res=0
d=denivele(graphe,case1,case2)
if d<pi/9:
res=(pi/9-d)*9/pi
return(res)
return(res) #Le slope vaut 1 pour un angle = 0 entre deux cellules, 0 pour un angle supérieur à 20 degrés en valeur absolue et est linéaire pour un angle entre 0 et 20 degrés.
def neighbors(node, size):
def neighbors(node, size, soldats):
"""permet d'obtenir les voisins d'une cellule dans le graphe"""
#size represent the whole size of the image
longueur,largeur=size
......@@ -89,20 +79,17 @@ def neighbors(node, size):
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):
if (point[0]>=0) & (point[0]<=largeur-1) & (point[1]>=0) & (point[1]<=longueur-1) & ([x,y]!=point) & (point not in soldats):
flat.append(point)
return(flat)
print("alt = ",altCaseXY((4435//15,2214//15)))
print("pop = ",popCaseXY((4435//15,2214//15)))
def exportgraphe(graphe, i):
"""Fonction permettant de transformer le graphe en un fichier csv"""
flat=[]
for line in graphe:
flat+=line
with open("D:/documents/IMT/datascience/challenge3/sauvegarde/"+str(i)+"jours.csv", 'a') as outcsv:
with open("../moodleBis/"+str(i)+"jours.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:
......@@ -111,7 +98,8 @@ def exportgraphe(graphe, i):
def importgraphe(nbline,nbcol, i):
with open("D:/documents/IMT/datascience/challenge3/sauvegarde/"+str(i)+"jours.csv",newline='') as f:
"""Fonction permettant de transformer le fichier csv en un graphe"""
with open("../moodleBis/"+str(i)+"jours.csv",newline='') as f:
reader = csv.reader(f,delimiter=',')
uidlist = list(reader)
res=[[[] for _ in range(nbcol)] for _ in range(nbline)]
......@@ -124,6 +112,7 @@ def importgraphe(nbline,nbcol, i):
return(res)
def isZombie(case):
"""On vérifie ici s'il y a des zombies dans une cellule donnée du graphe"""
res=1
if case[0]==0:
res=0.5
......@@ -131,34 +120,17 @@ def isZombie(case):
res=0
return(res)
""" x=range(4830)
y=range(3510)
z=[[getAltXY((xi,yi)) for xi in x] for yi in y] #profil de l'altitude de la ligne du mont blanc (il est à x=1573)
print(max([max(zi) for zi in z])) """
#A décommenter
#Coordonnées du graphe initial
newWidth=4830//15
newHeigth=3510//15
#Graph=[[[popCaseXY((col,line)),altCaseXY((col,line)),[0 for _ in range(15)]] for col in range(newWidth)] for line in range(newHeigth)]
#exportgraphe(Graph)
#Graph=[[[popCaseXY((col,line)),0,[0 for _ in range(15)]] for col in range(newWidth)] for line in range(newHeigth)]
def importgrapheinitial(nbline,nbcol):
with open("D:/documents/IMT/datascience/challenge3/sauvegarde/grapheinitial.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)
nbline,nbcol=234,322
Graph=importgrapheinitial(nbline,nbcol)[::-1]
#On construit ici notre graphe initial
Graph=[[[popCaseXY((col,line)),altCaseXY((col,line)),[0 for _ in range(15)]] for col in range(newWidth)] for line in range(newHeigth)]
##On délimite la zone qui correspond à Rize
#### initialization of the graph and the zombies list with their age####
pixelOutOfRize=[[4422,2108],[4422,2109],[4422,2110],[4422,2111],[4423,2109],[4423,2110],[4423,2111],[4424,2110],[4425,2111]]
pixelOutOfRize.append([[i,2111] for i in range(4429,4436)])
pixelOutOfRize.append([[i,2110] for i in range(4430,4436)])
......@@ -166,8 +138,7 @@ pixelOutOfRize.append([4433,2109])
pixelOutOfRize.append([[4434,j] for j in range(2105,2110)])
pixelOutOfRize.append([[4435,j] for j in range(2104,2110)])
#print(Graph[2103//15][4422//15], 'un de Rize juste avant') # Résultat [182480.5194805195, 1175.629339729832, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] Ce qui est logique
#On initialise les zombies à Rize et de ce fait toute la population est mise à 0!
test=0
for col in range(4422,4436): #pixels de rize
for line in range(2103,2118):
......@@ -181,82 +152,23 @@ for col in range(4422,4436): #pixels de rize
print([col,line], Graph[line//15][col//15][0], 'pop')"""
test+=Graph[line//15][col//15][2][0]
#On va faire un truc pas beau du tout
#Fin de l'initialisation
Graph[2103//15][4422//15][2][0] = 182480.5194805195
Graph[2115//15][4422//15][2][0] = 229246.75324675324
Graph[2103//15][4425//15][2][0] = 212636.36363636368
Graph[2115//15][4425//15][2][0] = 80363.63636363635
#Maintenant on a ça dans le graphe à Rize et c'est plus logique
"""[4422, 2103] [0, 1175.629339729832, [182480.5194805195, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
[4422, 2115] [0, 2725.9298068425705, [229246.75324675324, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
[4425, 2103] [0, 2334.255775785886, [212636.36363636368, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
[4425, 2115] [0, 4284.731725792198, [80363.63636363635, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]"""
##
neighborCase1 = neighbors((2103//15, 4422//15),(len(Graph[0]),len(Graph)))
neighborCase2 = neighbors((2115//15, 4422//15),(len(Graph[0]),len(Graph)))
neighborCase3 = neighbors((2103//15, 4425//15),(len(Graph[0]),len(Graph)))
neighborCase4 = neighbors((2115//15, 4425//15),(len(Graph[0]),len(Graph)))
#print(len(neighborCase1), len(neighborCase2), len(neighborCase3), len(neighborCase4), 'len neighbors')
denivCase1 = [Graph[2103//15][4422//15][1]]
denivCase2 = [Graph[2115//15][4422//15][1]]
denivCase3 = [Graph[2103//15][4425//15][1]]
denivCase4 = [Graph[2115//15][4425//15][1]]
for i in neighborCase1:
denivCase1.append((i, lambdad(Graph,(2103//15, 4422//15),i), Graph[i[0]][i[1]][1]))
for i in neighborCase2:
denivCase2.append((i, lambdad(Graph,(2115//15, 4422//15),i), Graph[i[0]][i[1]][1]))
for i in neighborCase3:
denivCase3.append((i, lambdad(Graph,(2103//15, 4425//15),i), Graph[i[0]][i[1]][1]))
for i in neighborCase4:
denivCase4.append((i, lambdad(Graph,(2115//15, 4425//15),i), Graph[i[0]][i[1]][1]))
#print(denivCase1, denivCase2, denivCase3, denivCase4, 'deniv')
##
"""[1175.629339729832, ((139, 294), 0, 0.6072465597778058), ((140, 293), 0, 923.6220174220426), ((139, 293), 0, 0.6072465597778058), ((141, 294), 0, 2725.9298068425705), ((141, 293), 0, 2645.166014392122)]
[2725.9298068425705, ((140, 294), 0, 1175.629339729832), ((141, 293), 0, 2645.166014392122), ((140, 293), 0, 923.6220174220426), ((142, 294), 0, 3061.1299078399193), ((142, 293), 0, 3061.1299078399193)]
[2334.255775785886, ((139, 295), 0, 923.6220174220426), ((140, 294), 0, 1175.629339729832), ((139, 294), 0, 0.6072465597778058), ((141, 295), 0, 4284.731725792198), ((141, 294), 0, 2725.9298068425705)]
[4284.731725792198, ((140, 295), 0, 2334.255775785886), ((141, 294), 0, 2725.9298068425705), ((140, 294), 0, 1175.629339729832), ((142, 295), 0, 4702.517358919328), ((142, 294), 0, 3061.1299078399193)] """
##On bidouille un peu pour voir s'il y a propagation
"""Graph[139][294][1] = 1176
Graph[140][293][1] = 1176
Graph[139][293][1] = 1177
Graph[141][294][1] = 1176
Graph[141][293][1] = 1176
Graph[140][294][1] = 2725
Graph[141][293][1] = 2726"""
##
#print("pop totale de Rize = ", test)
#print(Graph[2103//15][4422//15], 'un de Rize avant') # [0, 1175.629339729832, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]] un de Rize avant pourtant dans le for juste avant on a une liste cohérente
#Cellules contenant la population de Rize
pop_totale_de_Rize = test
#On fait viellir les zombies grâce à cette fonction
def getZombiesOlder(zombiesList):
"""On fait viellir les zombies grâce à cette fonction"""
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
#Cette fonction 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:
......@@ -266,6 +178,7 @@ def are_they_zombies(zombies):
def zombies_repartition(zombies, N): #N is the number of zombies that we want to affect to a neighboring cell
"""Cette fonction permet de repartir de manière proportionnelle les zombies venant d'une cellule dans les cellules voisines"""
repartition = [] #This repartition is done giving the age of the zombies
for i in zombies:
if sum(zombies) != 0:
......@@ -276,17 +189,17 @@ def zombies_repartition(zombies, N): #N is the number of zombies that we want to
#Zombies présents dans une cellule
def enteredZombies(zombiesList):
"""Cette fonction permet d'obtenir le nombre de zombies entrés dans une cellules après une étape"""
return sum(zombiesList)
#Before StepOne
print(Graph[146][295], 'Où')
print(neighbors((146, 295),(len(Graph[0]),len(Graph))), (146,295))
print(neighbors((147, 296),(len(Graph[0]),len(Graph))), (147,296))
#Dans la suite on défini les différentes étapes de la propagation des zombies dans les différentes cellules
#STEP ONE
def stepOne(Graph):
def stepOne(Graph, soldats):
"""La première étape permet de calculer le nombre de zombies arrivant dans une cellule accessible (c'est-à-dire qui satisfait les contraintes sur l'altitude et qui a une population humaine)"""
graphe = Graph.copy()
#Calcul du nombre de zombies partant des cellules
zombiesStart = 0
......@@ -306,7 +219,7 @@ def stepOne(Graph):
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),larglong) #On récupère les cellules voisines
neighbor = neighbors((i, j),larglong, soldats) #On récupère les cellules voisines
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
......@@ -357,14 +270,15 @@ def stepOne(Graph):
#STEP TWO
def stepTwo(Graph):
def stepTwo(Graph, soldats):
"""Ensuite dans cette étape on calcule s'il y a lieu de le faire le nombre d'êtres humains tués par des zombies dans une cellule donnée"""
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)
updatedGraph = stepOne(graphe, soldats)
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
......@@ -390,14 +304,15 @@ def stepTwo(Graph):
#STEP THREE
def stepThree(Graph):
def stepThree(Graph, soldats):
"""Enfin, cette étape permet de calculer le nombre de zombies tués par des êtres humains qui ont survécu à l'attaque des zombies dans leur cellule"""
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)
updatedGraph = stepTwo(graphe, soldats)
for i in range(len(updatedGraph)):
for j in range(len(updatedGraph[i])):
potentialKilledZombies = 10*updatedGraph[i][j][0]
......@@ -418,33 +333,78 @@ def stepThree(Graph):
return updatedGraph
#Itérations
#(146,295)
gr = stepThree(Graph)
for i in range(300):
graphe = stepThree(Graph)
#Cette liste contient les cellules qui sont supposés correspondre à la mer: En effet dans notre première approche il y avait des liaisons qui ne se font normalement pas dans la réalité par exemple une cellule en Angleterre voisine d'une cellule en France, ce qui faussait nos résultats. Grâce à cette liste on est en mesure de remplacer ces liaisons incohérentes par la mer et d'avoir des résultats plus cohérents.
vide = [(68,74), (177,33), (177,34), (177,35), (177,36), (158,158), (158,159), (158,160), (158,161), (158,162), (108,266), (109,266), (110,266), (44, 120), (45, 120), (45, 121), (43, 118), (42, 118), (41, 118), (40, 118), (38, 118), (39, 118), (37, 118), (36, 118), (39, 126), (38, 125), (37, 125), (36, 125), (35, 125), (34, 125), (33, 125)]
#Question 2
#On a ici repertorié les cellules idéales où placer nos soldats afin de protéger un maximum de population de l'invasion des zombies
soldats = [(116,117), (116,118), (116,119), (116,120), (116,121), (116,122), (116,123), (116,124), (116,125), (116,126), (116,127), (116,128), (116,129), (116,130), (116,131), (116,132), (116,133), (116,134), (116,135), (1299//15, 666//15)]
pop_nulle = vide + soldats
#Cette action permet de représsenter de manière plus visuelle sur une image le fait que les soldats choisis assurent bien leur rôle et le fait que les zones incohérentes sont bien remplacés par la mer.
for node in pop_nulle:
Graph[node[0]][node[1]][0] = 0
#Opération permettant d'afficher l'image correspondant à un déplacement journalier des zombies.
graphetoplot=stepThree(Graph, pop_nulle)
som = 0
x = [[isZombie(case) for case in line] for line in graphetoplot]
for line in x:
for elt in line:
if elt == 1:
som += 1
print(som, 'som')
print(len(x), len(x[0]))
for point in pop_nulle:
x[point[0]][point[1]]=0.8
fig, ax = plt.subplots()
# define the colors
cmap = mpl.colors.ListedColormap(['b', 'g', 'c', 'm', 'y', 'k', 'w'])
# create a normalize object the describes the limits of
# each color
bounds = [0., 0.2, 0.7, 0.9, 1.]
norm = mpl.colors.BoundaryNorm(bounds, cmap.N)
# plot it
ax.imshow(x, interpolation='none', cmap=cmap, norm=norm)
plt.show()
#Opération permettant d'obtenir les déplacements des zombies sur une plus longue durée.
"""for i in range(500):
graphe = stepThree(Graph, soldats)
for node in pop_nulle:
graphe[node[0]][node[1]][0] = 0
nbline,nbcol=322,234
exportgraphe(graphe, i)
graphetoplot=importgraphe(nbline,nbcol, i)[::-1]
x = [[isZombie(case) for case in line] for line in graphetoplot]
soldats=[[231,139],[231,140],[231,141],[222,143],[221,143],[220,143],[219,143],[218,143],[217,143],[216,143]]
for point in soldats:
x[321-point[0]][point[1]]=0.8
fig, ax = plt.subplots()
# define the colors
cmap = mpl.colors.ListedColormap(['b', 'g', 'r', 'c', 'm', 'y', 'k', 'w'])
cmap = mpl.colors.ListedColormap(['b', 'g', 'c', 'm', 'y', 'k', 'w'])
# create a normalize object the describes the limits of
# each color
bounds = [0., 0.2, 0.7, 1.]
bounds = [0., 0.2, 0.7, 0.9, 1.]
norm = mpl.colors.BoundaryNorm(bounds, cmap.N)
# plot it
ax.imshow(x, interpolation='none', cmap=cmap, norm=norm)
plt.savefig('D:/documents/IMT/datascience/challenge3/sauvegarde/test'+str(i)+'.png')
print('Jour', i+1, 'terminé!')
#plt.savefig('D:/documents/IMT/datascience/challenge3/sauvegarde/test'+str(i)+'.png')
plt.savefig('../moodleBis/test'+str(i)+'.png')
print('Jour', i+1, 'terminé!')"""
# -*- 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)):