Commit 28bfed64 authored by Jéhoiakim KINGNE's avatar Jéhoiakim KINGNE
Browse files

Nouveau Challenge3Bis à lancer

parent 367e25df
......@@ -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')
# -*- 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)
This diff is collapsed.
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment