Mini projet de C++

46 downloads 1108 Views 162KB Size Report
GENDRE Laurent. Polytech'Nice-Sophia – c/o ESINSA. 1645 route des Lucioles – Parc de Sophia Antipolis. 06410 BIOT. Mini projet de C++. Programmation ...
GENDRE Laurent Polytech’Nice-Sophia – c/o ESINSA 1645 route des Lucioles – Parc de Sophia Antipolis 06410 BIOT

Mini projet de C++

Programmation d'un automate cellulaire

Table des matières Table des matières................................................................................................................................ 3 I - Introduction......................................................................................................................................3 II - Description..................................................................................................................................... 4 III - Execution.......................................................................................................................................5 IV - Programmation..............................................................................................................................6 V - Conclusion......................................................................................................................................7

I - Introduction Le but de ce miniprojet est de concevoir un automate cellulaire de dimension 1 dans un langage de programmation C++. Les automates cellulaires sont dans la majorité des cas assimilés à des modèles discrets utilisés en mathématique. Un automate peut avoir plusieurs dimensions mais dans notre cas on en étudiera un de dimension 1. Un automate cellulaire est en fait un tableau de cellules étant chacune activée ou desactivée. L'état de chacune de ces cellules est calculé en fonction de ses cellules parentes. Ainsi, en associant une règle avec les différentes cellules, il est possible de générer un tel automate. Les premières études sur ces automates debutèrent en 1940 et évoluèrent au fil du temps. De nos jours, leurs utilisation première est la cryptographie puisque s'il est facile de générer un automate cellulaire, il est très difficile de faire l'inverse (en extraire la règle utilisée).

Illustration 1: Automate Cellulaire généré avec la règle 30

II - Description Dans cette partie, on va décrire un peu plus en profondeur le principe de création d'un automate cellulaire pour faciliter la compréhension de la suite. Un automate cellulaire est un modèle avec des combinaisons assez simples, ainsi on peut créer des images relatives à cet automate à partir d'une règle. Pour comprendre le principe d'une règle, il faut tout d'abord comprendre comment est calculé un pixel (cellule). Chaque pixel est en noir ou en blanc, il est définit par le pixel en haut à gauche de lui, juste haut dessus de lui et en haut à droite de lui :

Ici, on a la combinaison (1,0,0) => 1, c'est à dire que le pixel est activé si le pixel en haut a gauche de lui est actif et pas les deux autres. En associant les 8 combinaisons possibles et le résultat de chacune, on obtient une règle :

Ici, on a la règle 30 -> 00011110, une des plus intéressante. Concrêtement, une règle est un nombre décimal entre 0 et 255 (il y a 256 règles possibles) correspondant à un équivalent binaire sur 8 bits. Cette équivalent binaire représente en fait le résultat des 8 combinaisons. Il est utile de savoir ceci puisque l'on sait maintenant que l'on peut passer la règle (en decimale) comme paramètre à notre programme. Grâce à n'importe qu'elle règle, on peut générer un automate cellulaire complexe avec un programme bien conçu.

III - Execution Le dossier du projet contient :      

main.cc : fichier c++ principal Automate_Cellulaire.cc : fichier c++ secondaire Automate_Cellulaire.h : fichier c++ librairie makefile : donne les règles de compilation readme : fichier à lire avant d'éxecuter le programme rapport.pdf : mini rapport

Pour éxecuter le programme sous linux, il faut lancer un shell de commande puis faire les commandes suivantes : $ $ $ $

cd repertoire_du_projet make ./Automate_Cellulaire 30 800 600 1 | convert pgm:- png:Image.png display Image.png

Paramètres d'éxecution : 30 correspond ici à la règle utilisé 800 est la largeur 600 est la hauteur 1 est la taille d'un pixel '| convert pgm:- png:Image.png' permet de convertir l'image en format png pour pouvoir la lire

Dépendance : Par défaut, le paquet ImageMagick est installé sur les systèmes linux récents, dans le cas contraire, vous pourrez le trouver sur http://www.imagemagick.org/

IV - Programmation Graphique d'éxecution standard : Appel + paramètres

Main() Paramètres insuffisants

Utilisation()

Paramètre de règle

ConvDec2Bin()

-> Conversion

Tableau contenant la règle en binaire

Automate()

-> Création de l'objet

flux de sortie stdout

Lignes

PrintImage()

CalculLigne() Ligne courante

~Automate()

-> Execution cyclique

-> Destruction de l'objet

Automate() crée l'objet car c'est le constructeur de la classe, il crée entre autre le tableau contenant les 8 combinaisons possibles utile pour CalculLigne() PrintImage() appel la fonction CalculLigne() en faisant varier la hauteur (en changeant de ligne)(en tenant compte de la taille du pixel aussi). Il actualise aussi la ligne du dessus et la ligne courante. La fonction écrit le résultat dans stdout. CalculLigne() crée le contenu des lignes en faisant varier la largeur et en identifiant la combinaison sur la ligne parente. La fonction renvoie la ligne courante pour être traité dans PrintImage().

Difficultés rencontrés : la méthode pour afficher correctement l'image de sortie n'a pas été simple à trouver, il a fallut se documenter sur internet.

V - Conclusion Ce projet m'a permis d'aborder le domaine de la programmation orientée objet en C++ et m'a permis de connaître le domaine passionant des automates cellulaires. Ces automates sont très utiles dans certains cas comme la cryptographie ou la biologie. Un automate cellulaire est en fin de compte un ensemble de cellules générées à partir d'une règle composée de combinaisons. Le résultat d'un tel automate est un assemblage complexe de cellules dur à decrypter. Il est possible de modifier les sources du projet afin de générer un automate à 2 dimensions (avec des couleurs par exemple), il suffit de modifier les dimensions du tableau de la règle, du tableau de combinaisons et de changer quelques occurrences de l'algorithme dans CalculLigne().