2017/05/25 15:54 1/7 Automates cellulaires 2D : Généralités Automates cellulaires 2D : Généralités Ce document est le plus grand dénominateur commun entre les différents travaux pratiques concernant les automates cellulaires en dimension 2. Vous devez avoir compris ce document avant de consulter les spécificités de tel ou tel automate : Jeu de la vie Simulation de feux de forêt Propagation d'une épidémie Vous pouvez aussi consulter la documentation sur les automates cellulaires 1D. Cette page doit cependant être suffisante pour comprendre de quoi il retourne. Il est vivement recommandé de lire tout le sujet avant de commencer. Vous n'aurez pas ainsi à défaire ce que vous aurez fait… Qu'est-ce qu'un automate cellulaire ? Nous ne prétendons pas ici donner une définition exacte ou exhaustive de ce qu'est un automate cellulaire. Nous parlerons seulement du type d'automate 2D utilisé dans les TPs de programmation. Cellules et états Un automate cellulaire est une grille à maillage carré. Nous représenterons cette grille par un tableau en deux dimensions. Chaque case du tableau est appelé cellule. Chaque cellule peut être dans un certain état. En ce qui nous concerne, l'état pourra être représenté par un nombre entier et le tableau représentant la grille sera donc un tableau d'entiers. Le nombre d'états différents que peut prendre une cellule est une caractéristique de l'automate considéré. Par exemple, dans le jeu de la vie, il y a deux états (mort ou vivant). Dans la simulation de feu de forêts, il y en a 4 (vide, arbre, feu ou cendre). La grille (donc le tableau) sera modélisée par l'objet array de l'extension numpy : import numpy as np t=np.zeros((5,5)) # Tableau nul de 5 cases par 5 t[2,3]=42 # Modification d'une case Règles de transition Un automate cellulaire est un objet dynamique, qui change au cours du temps selon certaines règles. Informatique, Programmation, Python, Enseignement... - https://deptinfo-ensip.univ-poitiers.fr/ENS/doku/ Last update: stu:python:automates_cellulaires_2d https://deptinfo-ensip.univ-poitiers.fr/ENS/doku/doku.php/stu:python:automates_cellulaires_2d 2014/05/16 16:32 Ces changements concernent chacune des cellules. À la date t+1, l'état de toutes les cellules doit être recalculé et dépend uniquement des règles de transition et de l'état de ces cellules aux dates antérieures. En ce qui nous concerne, l'état d'une cellule particulière dépendra uniquement de l'état de ses cellules voisines (et d'elle même) à la date précédente. Nous pourrons considérer en revanche plusieurs types de voisinage, comme le voisinage de Moore (8 voisins) ou le voisinage de Von Neumann (4 voisins). L'étant de la cellule (i,j) à la date t dépend uniquement des règles de transition, de son propre état à la date t et de l'état des cellules voisines (en 4-connexité ou 8-connexité) à la date t. Pour la simulation de feu de forêt, par exemple, les règles de changement d'état sont : Vide ⇒ Vide Feu ⇒ Cendre Cendre ⇒ Cendre Arbres ⇒ Feu si un voisin est en feu et Arbre ⇒ Arbre sinon Avec ces règles, l'automate serait modifié de la manière suivante (les couleurs sont explicites…) : https://deptinfo-ensip.univ-poitiers.fr/ENS/doku/ Printed on 2017/05/25 15:54 2017/05/25 15:54 3/7 Automates cellulaires 2D : Généralités Représenter et animer un automate cellulaire Représentation de l'automate Pour représenter l'automate sur l'écran, nous devons représenter chaque case du tableau. On choisit généralement de représenter chaque état par un carré de couleur différente. Pour les feux de forêt, par exemple, on pourrait utiliser le code couleur suivant : Vide : Noir Arbre : Vert Feu : Rouge Cendre : Gris Il sera commode d'utiliser une procédure spécifique pour afficher l'automate à l'écran. Cette fonction aura comme unique paramètre le tableau représentant l'automate (plus éventuellement la taille en pixels des carrés à dessiner). afficher(tab) | Répéter pour chaque case (i,j) du tableau tab | | Si tab[i]|[j] = VIDE : Afficher un rectangle noir | | Si tab[i]|[j] = ARBRE : Afficher un rectangle vert | | Si tab[i]|[j] = FEU : Afficher un rectangle rouge | | Si tab[i]|[j] = CENDRE : Afficher un rectangle gris | |__ L'algorithme précédent n'est qu'une ébauche. En particulier, l'unique boucle en cache en fait deux (une pour les abscisses et une pour les ordonnées), et les coordonnées (i,j) doivent subir une transformation. Vous résoudrez ces différents points au moment de programmer (vous devrez adapter ce qui précède au langage Python et à la bibliothèque graphique que vous utiliserez). Évolution dans le temps Nous devrons aussi disposer d'une fonction ou procédure qui modifie l'automate en le faisant passer de l'étape t à l'étape t+1. Le seul paramètre nécessaire sera le tableau représentant l'automate à la date t. C'est ici que seront implantées les règles de transition de l'automate. Vous pouvez vous inspirer de l'algorithme suivant : suivant(tab) | Copier le contenu de tab dans un nouveau tableau tab2 | Répéter pour chaque case (i,j) du tableau tab2 | | Mettre dans tab[i][j] l'état suivant de la case i,j, | | qui dépend de tab2[i][j], des cases voisines, et | | des règles de transition. | |__ |__ Il est primordial d'avoir bien compris pourquoi un second tableau (ici tab2) est nécessaire. Demandez de l'aide à l'encadrant si nécessaire. Informatique, Programmation, Python, Enseignement... - https://deptinfo-ensip.univ-poitiers.fr/ENS/doku/ Last update: stu:python:automates_cellulaires_2d https://deptinfo-ensip.univ-poitiers.fr/ENS/doku/doku.php/stu:python:automates_cellulaires_2d 2014/05/16 16:32 Comme précédemment, les boucles Répéter pour cachent en fait deux boucles (une pour i, et une pour j). Enfin, le corps de la boucle principale dépend des règles de transition de l'automate. Il est conseillé de faire appel à d'autres fonctions dans cette partie, pour compter le nombre de voisins par exemple. Vous devrez aussi trouver un moyen de gérer le cas des cellules en bordure de tableau, car elles n'ont pas le même voisinage que les autres. À la fin, votre fonction ou procédure suivant doit être courte. Si elle grossit trop, c'est très certainement que vous avez oublié d'écrire des fonctions annexes. Animation L'animation de l'automate sera simplement obtenue en appelant alternativement suivant et afficher. Structure générale La structure générale du programme sera la suivante : Programme principal | Ouvrir une fenêtre graphique | Initialiser le tableau tab : procédure init() | Répéter indéfiniment | | suivant(tab) | | afficher(tab) | |-| Terminer le programme La procédure init() devra initialiser correctement l'automate cellulaire (placer des arbres dans le cas des feux de forêt par exemple). Le programme principal, en Python, devra être exécuté ainsi : if __name__=='__main__' : main() afin de permettre l'importation silencieuse de votre fichier. (Voir la documentation Notes sur Python - Programme propre) Détails... Il y a quelques détails techniques qui n'ont peut être pas été vus par ailleurs : Pour éviter de mentionner les états des cellules en donnant leur valeurs numériques, il est possible https://deptinfo-ensip.univ-poitiers.fr/ENS/doku/ Printed on 2017/05/25 15:54 2017/05/25 15:54 5/7 Automates cellulaires 2D : Généralités d'utiliser un dictionnaire Python : st={"VIDE":,"ARBRE":1,"FEU":2,"CENDRE":3} Puis, on fera référence aux états ainsi : if tab[i,j]==st["ARBRE"] : ce qui est plus lisible que : if tab[i,j]==1 : Arrivés à ce point, vous pouvez reprendre la lecture du sujet concernant Vous devrez adapter ce qui précède au langage Python et à la bibliothèque graphique que vous utiliserez. l'automate particulier que vous allez réaliser et commencer à le programmer. Le point suivant, que vos pourrez reprendre plsu tard est plus complexe et vous indique comment animer l'écran et permettre les interactions avec l'automate. Vous pourrez en prendre connaissance une fois que vous aurez réalisé l'automate de la manière que nous venons de décrire. Programmation de la version non interactive Votre programme doit impérativement comporter, en plus du programme principal : une fonction d'initialisation du tableau : init une fonction de passage au tableau suivant : suivant une fonction d'affichage : afficher Dans un premier temps, vous pouvez écrire un programme non interactif. Vous ne pourrez pas agir sur l'interface pendant l'exécution du programme, mais vous pourrez tester toutes vos fonctions. Il est conseillé de programmer dans cet ordre : 1. coder la fonction d'initialisation du tableau 2. coder la fonction d'affichage du tableau 3. coder le programme principal qui intialise et affiche (en appelant les fonctions écrites aux points 1 et 2) 4. tester et corriger les bugs 5. coder la fonction de passage au tableau suivant 6. modifier la procédure principale pour calculer quelques générations, en ménageant une pause entre chaque affichage de manière à pouvoir contrôler manuellement le bon fonctionnement entre chaque étape 7. tester et corriger les bugs 8. finaliser le programme 9. tester et corriger les bugs Informatique, Programmation, Python, Enseignement... - https://deptinfo-ensip.univ-poitiers.fr/ENS/doku/ Last update: stu:python:automates_cellulaires_2d https://deptinfo-ensip.univ-poitiers.fr/ENS/doku/doku.php/stu:python:automates_cellulaires_2d 2014/05/16 16:32 Programmation de l'automate interactif Cette partie est facultative dans un premier temps. Programmez d'abord l'automate avant de commencer ce travail L'idée est maintenant de réaliser un programme interactif. L'affichage sera animé, et l'utilisateur pourra agir sur la fenêtre pour, par exemple : 1. 2. 3. 4. Changer l'état d'une cellule dans le jeu de la vie Modifier les règles d'un automate pendant son exécution (appui sur une touche) Ajouter des foyers d'incendie dans la simulation des feux de forêt … Le principe est basé sur la gestion des événements. Le module graphique que vous utilisez permet probablement : de gérer les événements souris, clavier etc… d'appeler une fonction en tâche de fond : ce sera l'animation de l'automate Pour réaliser cette partie, vous devrez donc consulter la documentation (Graphismes en Python) et les exemples relatifs au module que vous utilisez pour réaliser la partie graphique. En particulier, recherchez les informations relatifs aux événements et à la boucle de gestion des événements. Python Pour représenter les tableaux, vous pouvez utiliser l'extension NumPy. Les fontions suivantes peuvent vous être utiles : import numpy as np t=np.zeros((100,100),dtype=np.int32) # tableau 100x100 d'entiers mis à 0 t2=t.copy() # Réalise une copie du tableau t (alors qu'une simple affectation ajouterait simplement une référence) t2.shape # Tuple de deux valeurs indique la taille de t2 Vous serez amené à utiliser des nombres aléatoires : import random a=random.randint(4,19) # nombre entier entre 4 et 19 inclus La partie graphique pourra être réalisée avec les outils présentés ici : graphismes_python https://deptinfo-ensip.univ-poitiers.fr/ENS/doku/ Printed on 2017/05/25 15:54 2017/05/25 15:54 7/7 Automates cellulaires 2D : Généralités From: https://deptinfo-ensip.univ-poitiers.fr/ENS/doku/ - Informatique, Programmation, Python, Enseignement... Permanent link: https://deptinfo-ensip.univ-poitiers.fr/ENS/doku/doku.php/stu:python:automates_cellulaires_2d Last update: 2014/05/16 16:32 Informatique, Programmation, Python, Enseignement... - https://deptinfo-ensip.univ-poitiers.fr/ENS/doku/