Moteur de simulation d'un automate cellulaire à 2 dimensions. More...

#include <GOL.h>

Classes
struct	Author
	Le type représentant les informations permettant d'identifier les auteurs de l'implémentation. More...

struct	Color
	Le type représentant une couleur. More...

struct	ImplementationInformation
	Le type représentant les informations documentant l'implémentation. More...

struct	Statistics
	Le type représentant des données statistiques de la simulation. More...

Public Types
enum class	State : uint8_t { dead = 0 , alive = 1 }
	Le type représentant l'état d'une cellule. More...

enum class	BorderManagement : uint8_t { immutableAsIs = 0 , foreverDead , foreverAlive , warping , mirror }
	Le type représentant la stratégie de gestion de bord. More...

using	IterationType = uint32_t
	Le type représentant le nombre d'itération de la simulation.

using	ColorChannelType = uint8_t
	Le type représentant un canal de couleur.

Public Member Functions
	GOL ()=default
	Constructeur par défaut.

	GOL (size_t width, size_t height, State defaultState=State::dead)
	Constructeur d'initialisation personnalisé.

virtual	~GOL ()=default
	Destructeur.

virtual size_t	width () const =0
	Accesseur retournant la largeur de la grille de simualtion.

virtual size_t	height () const =0
	Accesseur retournant la hauteur de la grille de simualtion.

virtual size_t	size () const =0
	Accesseur retournant le nombre total de cellules de la grille de simualtion.

virtual State	state (int x, int y) const =0
	Accesseur retournant l'état d'une cellule.

virtual std::string	rule () const =0
	Accesseur retournant la chaîne de caractères correspondant à la règle courante.

virtual BorderManagement	borderManagement () const =0
	Accesseur retournant la stratégie courante de gestion des bords.

virtual Color	color (State state) const =0
	Accesseur retournant la couleur d'un état.

virtual Statistics	statistics () const =0
	Accesseurs retournant des informations générales sur la simulation en cours.

virtual ImplementationInformation	information () const =0
	Accesseurs retournant les informations sur la réalisation de l'implémentation.

virtual void	resize (size_t width, size_t height, State defaultState=State::dead)=0
	Mutateur modifiant la taille de la grille de simulation.

virtual bool	setRule (std::string const &rule)=0
	Mutateur modifiant la règle de la simulation.

virtual void	setBorderManagement (BorderManagement borderManagement)=0
	Mutateur modifiant la stratégie de gestion de bord.

virtual void	setState (int x, int y, State state)=0
	Mutateur modifiant l'état d'une cellule de la grille.

virtual void	fill (State state=State::dead)=0
	Mutateur remplissant de façon uniforme toutes les cellules de la grille.

virtual void	fillAlternately (State firstCell=State::dead)=0
	Mutateur remplissant de façon alternée toutes les cellules de la grille.

virtual void	randomize (double percentAlive=0.5)=0
	Mutateur remplissant de façon aléatoire toutes les cellules de la grille.

virtual bool	setFromPattern (std::string const &pattern, int centerX, int centerY)=0
	Mutateur remplissant la grille par le patron passé en argument.

virtual bool	setFromPattern (std::string const &pattern)=0
	Mutateur remplissant la grille par le patron passé en argument.

virtual void	setSolidColor (State state, Color const &color)=0
	Mutateur modifiant la couleur d'un état.

virtual void	processOneStep ()=0
	Fonction effectuant une itération de la simulation.

virtual void	updateImage (uint32_t *buffer, size_t buffer_size) const =0
	Fonction dessinant l'état de la simulation sur une image passée en paramètre.

Detailed Description

Moteur de simulation d'un automate cellulaire à 2 dimensions.

La classe GOL représente une interface standardisée visant l'implémentation complète et suffisante d'un engin de simulation d'un automate cellulaire à 2 dimensions.

Cette classe abstraite ne fait rien et ne possède aucun attribut. Elle ne constitue qu'un modèle standardisé pouvant être facilement utilisé pour réaliser une simulation.

La classe possède :

la définition des types utilitaires
la définition et l'implémentation de :
- le constructeur par défaut
- un constructeur personnalisé (cette définition est absolument inutile et en temps normal elle serait absente de ce fichier, sa présence n'est qu'à titre d'exemples pédagogiques)
- le destructeur virtuel
la définition de plusieurs fonctions abstraites (virtuelles pures).

L'approche utilisée est donc un parfait exemple d'un développement modulaire s'appuyant sur le polymorphisme. Néanmoins, pour rester critique, cette classe présente un défaut de conception du fait qu'elle réalise beaucoup trop de tâches à elle seule. Un découpage mieux structuré serait préférable considérant un projet d'envergure. La forme actuelle de cette conception vise à mettre l'emphase du développement sur les objetifs du projet sans être dérangé par d'autres aspects : conception et implémentation de structures de données et d'algorithmes.

Puisque cette classe est abstraite, elle est destiné à être héritée afin que vous implémentiez entièrement un engin de type automate cellulaire répondant strictement à l'interface présentée.

Éléments importants :

Vous devez implémenter entièrement le moteur de simulation.
La grille est 2d de dimensions finies.
En tout temps la classe doit être dans un état consistant. Peu importe l'ordre d'appel des fonctions. De plus, il doit être possible d'appeler n'importe quelle fonction et que son effet soit immédiat (dans la mesure de la logique).
À l'initialisation de votre engin, la configuration par défaut est :
- grille de 100 x 100
- toutes les cellules sont mortes
- règle de Conway : B3/S23
- stratégie de gestion de bord : BorderManagement::foreverDead
- itération courante : 0
- les couleurs sont noires pour les cellules mortes et blanches pour les cellules vivantes
Vous devez avoir une représentation interne indépendante de la représentation à l'écran.
Vous devez être en mesure de gérer n'importe quelle règle. Les règles sont définies par une chaîne de caractère suivant ce format : B###.../S###...
Vous devez être en mesure de gérer les effets de bord selon 5 stratégies différentes :
1. immuable tel quel
2. mort pour toujours
3. vivant pour toujours
4. téléportation
5. miroir
Vous devez être en mesure d'initialiser la grille de plusieurs façons :
1. remplir avec une valeur uniforme (mort ou vivant)
2. remplir en forme de damier (en pouvant préciser la valeur de la première cellule : mort ou vivant)
3. remplir aléatoirement avec un pourcentage de probabilité, pour chaque cellule, d'être vivant
4. mettre un patron centré sur la grille
5. manuellement, cellule par cellule, avec la fonction setState(...)
La fonction GOL::processOneStep doit faire un pas de simulation.
Vous devez utiliser le type GOL::State pour représenter chaque cellule de la simulation utilise, .
Vous devez être capable de produire une représentation visuelle de la représentation interne. La fonction GOL::updateImage vous passe le buffer où se trouve l'image de sortie. C'est dans cette zone mémoire que vous devez dessiner la représentation visuelle de la simulation.
Plusieurs mutateurs réinitialisent le compteur d'itération à 0.
- Voici ceux qui réinitialisent le compteur d'itération :
- Ce dernier laisse inchangé le compteur d'itération :
  - GOL::setState
À tout moment, il doit être possible de questionner la simulation afin d'obtenir les informations contenues dans la structure GOL::Statistics. On remarque que toutes les informations sont stockées dans un std::optional. Ainsi, si vous n'avez pas la réponse, vous pouvez simplement laissé la valeur indéterminée.
Vous devez implémenter une autre classe qui s'occupe de gérer une structure de données 2d. Cette classe, nommée Grid, est une encapsulation dirigée d'une matrice 2d. Voir plus bas dans cette page pour les détails.

Member Typedef Documentation

◆ ColorChannelType

using GOL::ColorChannelType = uint8_t

Le type représentant un canal de couleur.

Le type choisi est un entier non signé de 8 bits.

◆ IterationType

using GOL::IterationType = uint32_t

Le type représentant le nombre d'itération de la simulation.

Le type choisi est un entier non signé de 32 bits.

Member Enumeration Documentation

◆ BorderManagement

enum class GOL::BorderManagement : uint8_t

strong

Le type représentant la stratégie de gestion de bord.

L'algorithme de simulation doit gérer les effets de bord. C'est-à-dire que les calculs de voisinage doivent être adaptés pour les cellules situées sur les bords de la grille.

5 modes de gestion sont possibles.

Enumerator
immutableAsIs	Les cellules du contour ne sont jamais modifiées. Elles sont laissées dans leur état courant.
foreverDead	Les cellules du contour ne sont jamais modifiées. Elles sont toujours mortes.
foreverAlive	Les cellules du contour ne sont jamais modifiées. Elles sont toujours vivantes.
warping	Les cellules du contour sont évaluées. On utilise les cellules du côté opposé de la grille pour les cellules extérieures.
mirror	Les cellules du contour sont évaluées. On utilise les cellules du côté opposé de la cellule pour les cellules extérieures.

◆ State

enum class GOL::State : uint8_t

strong

Le type représentant l'état d'une cellule.

L'état d'une cellule peut être mort ou vivant.

Enumerator
dead	L'état mort.
alive	L'état vivant.

Member Function Documentation

◆ borderManagement()

virtual BorderManagement GOL::borderManagement ( ) const

pure virtual

Accesseur retournant la stratégie courante de gestion des bords.

Returns: La stratégie courante de gestion des bords.

◆ color()

virtual Color GOL::color ( State state ) const

pure virtual

Accesseur retournant la couleur d'un état.

Cette fonction retourne la couleur associée à l'état passé en argument.

Parameters

state L'état dont on veut connaître la couleur.

Returns: La couleur associée à l'état.

◆ fill()

virtual void GOL::fill ( State state = State::dead )

pure virtual

Mutateur remplissant de façon uniforme toutes les cellules de la grille.

Cette fonction remplit toutes les cellules de la grille avec l'état passé en argument.

L'itération courante est remise à 0.

Parameters

state L'état d'initialisation des cellules.

◆ fillAlternately()

virtual void GOL::fillAlternately ( State firstCell = State::dead )

pure virtual

Mutateur remplissant de façon alternée toutes les cellules de la grille.

Cette fonction remplit toutes les cellules de la grille avec un motif en damier. La première cellule, en haut à gauche, est de l'état passée en argument.

L'itération courante est remise à 0.

Parameters

firstCell L'état de la première cellule.

◆ height()

virtual size_t GOL::height ( ) const

pure virtual

Accesseur retournant la hauteur de la grille de simualtion.

Returns: La hauteur de la grille.

◆ information()

virtual ImplementationInformation GOL::information ( ) const

pure virtual

Accesseurs retournant les informations sur la réalisation de l'implémentation.

Retourne plusieurs informations sur la réalisation de l'implémentation. Chaque valeur est optionnelle et peut être indéterminée.

En quelque sorte, c'est l'approche utilisée pour produire un mini rapport utilitaire.

Voir la documentation liée à la structure ImplementationInformation pour plus de détails.

Pour les réponses 'answers', l'objectif est d'utiliser clairement le vocabulaire technique approprié tout en étant très concis et très précis.

Returns: Une structure contenant les informations sur la réalisation

◆ processOneStep()

virtual void GOL::processOneStep ( )

pure virtual

Fonction effectuant une itération de la simulation.

Cette fonction constitue la partie centrale de la simulation. Elle est responsable de faire évoluer la grille d'une itération.

Cette fonction doit appliquer la logique de l'automate cellulaire en tenant compte pour chaque cellule :

de la grille
de l'état de chacune des cellules voisines
de la règle de la simulation
de la stratégie de gestion de bord

Après l'appel de cette fonction, la grille est mise à jour avec le nouvel état de chaque cellule suivant l'état précédent. Les statistiques doivent tenir compte de cette évolution.

◆ randomize()

virtual void GOL::randomize ( double percentAlive = 0.5 )

pure virtual

Mutateur remplissant de façon aléatoire toutes les cellules de la grille.

Cette fonction remplit toutes les cellules de la grille avec un motif aléatoire. Le pourcentage de probabilité d'une cellule d'être vivante est passé en argument.

L'itération courante est remise à 0.

Parameters

percentAlive Le pourcentage de probabilité d'une cellule d'être vivante. La valeur doit être comprise entre 0.0 et 1.0 inclusivement.

◆ resize()

virtual void GOL::resize	(	size_t	width,
		size_t	height,
		State	defaultState = `State::dead`
	)

pure virtual

Mutateur modifiant la taille de la grille de simulation.

Cette fonction réinitialise la taille et le contenu de la grille. La taille est spécifié peut être 0 x 0. Le contenu de la grille est entièrement mis à l'état passé en argument.

Cette fonction s'assure que si l'une des dimensions est 0, alors les deux sont mises à 0.

L'ancient motif de la grille est perdu. L'itération courante est remise à 0.

Parameters

width	La nouvelle largeur de la grille.
height	La nouvelle hauteur de la grille.
defaultState	L'état d'initialisation des cellules.

◆ rule()

virtual std::string GOL::rule ( ) const

pure virtual

Accesseur retournant la chaîne de caractères correspondant à la règle courante.

La chaîne de caractères est de la forme "B###/S###".

Returns: La chaîne de caractères correspondant à la règle courante selon le format B###.../S###....

◆ setBorderManagement()

virtual void GOL::setBorderManagement ( BorderManagement borderManagement )

pure virtual

Mutateur modifiant la stratégie de gestion de bord.

Cette fonction assigne la nouvelle stratégie pour que les prochaines évolutions l'utilisent.

L'ancienne stratégie est perdue. L'itération courante est remise à 0.

Vous devez être en mesure de gérer les effets de bord selon 5 stratégies différentes :

BorderManagement::immutableAsIs : immuable tel quel. Les cellules du contour ne sont jamais modifiées.
BorderManagement::foreverDead : mort pour toujours. Les cellules du contour ne sont jamais modifiées, elles sont toujours mortes.
BorderManagement::foreverAlive : vivant pour toujours. Les cellules du contour ne sont jamais modifiées, elles sont toujours vivantes.
BorderManagement::warping : téléportation. Les cellules du contour sont évaluées. On utilise les cellules du côté opposé de la grille pour les cellules extérieures.
BorderManagement::mirror : miroir. Les cellules du contour sont évaluées. On utilise les cellules du côté opposé de la cellule pour les cellules extérieures.

Pour les 2 exemples suivants, la cellule analysée -*- possède 3 voisins situés à l'extérieur de la grille 'x', 'y' et 'z'. Ces cellules sont substituées par les voisins opposés 'X', 'Y' et 'Z'.

BorderManagement::warping utilise les voisins opposés par rapport à la grille.

    +---+---+---+---+---+ 
  x |   |   |   |   | X |
    +---+---+---+---+---+
  y |-*-|   |   |   | Y |
    +---+---+---+---+---+
  z |   |   |   |   | Z |

BorderManagement::mirror utilise les voisins opposés par rapport à la cellule.

    +---+---+---+---+---+ 
  x |   | X |   |   |   |
    +---+---+---+---+---+
  y |-*-| Y |   |   |   |
    +---+---+---+---+---+
  z |   | Z |   |   |   |

Parameters

borderManagement La nouvelle stratégie de gestion de bord.

◆ setFromPattern() [1/2]

virtual bool GOL::setFromPattern ( std::string const & pattern )

pure virtual

Mutateur remplissant la grille par le patron passé en argument.

Cette fonction est une surcharge utilitaire de la fonction setFromPattern(std::string const & pattern, int centerX, int centerY). Cette version utilise le centre de la grille comme centre du patron.

L'itération courante est remise à 0.

Parameters

pattern Le patron à appliquer.

Returns: true si le patron est valide, false sinon.

◆ setFromPattern() [2/2]

virtual bool GOL::setFromPattern	(	std::string const &	pattern,
		int	centerX,
		int	centerY
	)

pure virtual

Mutateur remplissant la grille par le patron passé en argument.

Cette fonction remplit la grille avec le patron donné. Le patron est centré sur la coordonnées (centerX, centerY).

Le patron respecte un format précis. Se référer à l'énoncé pour voir tous les détails.

Si le patron n'est pas valide, la grille n'est pas modifiée et on retourne false. Sinon, on retourne vrai.

L'itération courante est remise à 0.

Parameters

pattern	Le patron à appliquer.
centerX	La coordonnée en x de la grille où se trouve centré le patron.
centerY	La coordonnée en y de la grille où se trouve centré le patron.

Returns: true si le patron est valide, false sinon.

◆ setRule()

virtual bool GOL::setRule ( std::string const & rule )

pure virtual

Mutateur modifiant la règle de la simulation.

Cette fonction s'assure que la chaîne de caractères est valide et assigne la nouvelle règle pour que les prochaines évolutions l'utilisent.

Si la règle est valide, on assigne la novuelle règle, l'ancienne règle est perdue et l'itération courante est remise à 0. Si la règle est invalide, on ne fait rien.

La simulation doit être en mesure de supporté les règles valides.

Les règles sont définies par une chaîne de caractère suivant ce format: B###.../S###..., par exemple : B3/S23.

La lettre B (minuscule ou majuscule) débute la section 'B'orn concernant les états morts qui naissent
Suit une série de n caractères pouvant contenir une instance de chacun de ces caractères : '0', '1', '2', '3', '4', '5', '6', '7', '8'. La valeur de n peut varier de 0 à 9. Cette séquence indique toutes les combinaisons du nombre de cellules voisines vivantes qui font naître une cellule morte.
Le caractère barre oblique / (slash) qui indique la transition vers la section suivante.
La lettre S (minuscule ou majuscule) débute la section 'S'urvive concernant les états vivants qui survivent (qui restent vivantes).
Suit une série de n caractères pouvant contenir une instance de chacun de ces caractères : '0', '1', '2', '3', '4', '5', '6', '7', '8'. La valeur de n peut varier de 0 à 9. Cette séquence indique toutes les combinaisons du nombre de cellules voisines vivantes qui font naître une cellule morte.

Par exemple : B02/S1357 indique que :

si une cellule est morte :
- elle naît se elle possède 0 ou 2 voisins vivants
si la cellule est vivante :
- elle survie si elle possède 1, 3, 5 ou 7 voisins vivants

La règle de Conway B3/S23 est celle par défaut.

◆ setSolidColor()

virtual void GOL::setSolidColor	(	State	state,
		Color const &	color
	)

pure virtual

Mutateur modifiant la couleur d'un état.

Cette fonction modifie la couleur d'un état.

Formellement, cette fonction ne modifie rien en soit mais plutôt permet de stocker quelle couleur utiliser pour représenter un état lors de l'affichage de la grille sur une image.

Parameters

state	L'état dont on veut modifier la couleur.
color	La nouvelle couleur de l'état.

◆ setState()

virtual void GOL::setState	(	int	x,
		int	y,
		State	state
	)

pure virtual

Mutateur modifiant l'état d'une cellule de la grille.

Cette fonction ne valide pas les entrées pour une raison de performance. L'origine est le coin supérieur gauche de la grille.

Parameters

x	La coordonnée en x de la cellule.
y	La coordonnée en y de la cellule.
state	Le nouvel état de la cellule.

◆ size()

virtual size_t GOL::size ( ) const

pure virtual

Accesseur retournant le nombre total de cellules de la grille de simualtion.

Returns: Le nombre total de cellules de la grille.

◆ state()

virtual State GOL::state	(	int	x,
		int	y
	)		const

pure virtual

Accesseur retournant l'état d'une cellule.

Cette fonction ne valide pas les entrées pour une raison de performance. L'origine est le coin supérieur gauche de la grille.

Parameters

x	La coordonnée en x de la cellule.
y	La coordonnée en y de la cellule.

Returns: L'état de la cellule.

◆ statistics()

virtual Statistics GOL::statistics ( ) const

pure virtual

Accesseurs retournant des informations générales sur la simulation en cours.

Retourne plusieurs informations sur la simulation. Chaque valeur est optionnelle et peut être indéterminée.

Voir la documentation liée à la structure Statistics pour plus de détails.

Toutefois, les tendances sont définies ainsi :

La tendance indique la variation entre le nombre de cellules mortes et vivantes en valeur absolue et relative.
Une tendance est à la hausse s'il y a plus de cellules naissantes que mourantes.
Un premier caractères indique si la tendance est à la hausse (+) ou à la baisse (-).
La tendance doit se faire sur un certain nombre d'itérations. Ce nombre est défini par l'implémentation mais doit être supérieur à 10 itérations. L'objectif est d'avoir une lecture relativement stable de la tendance afin qu'elle soit agréable à lire dans l'interface usager.
Optionnellement, vous pouvez ajouter un second caractère indiquant la stabilité de la tendance. Voici la légende :
- '-' : stable
- '~' : légèrement instable
- 'w' : instable
- 'W' : très instable

Returns: Une structure contenant les informations sur la simulation.

◆ updateImage()

virtual void GOL::updateImage	(	uint32_t *	buffer,
		size_t	buffer_size
	)		const

pure virtual

Fonction dessinant l'état de la simulation sur une image passée en paramètre.

Cette fonction dessine l'état courant de chaque cellule sur l'image donnée. Chaque pixel de l'image correspond à une cellule de la grille de simulation.

La couleur de chaque pixel est déterminée par la couleur associée à l'état de la cellule.

L'organisation en mémoire est ce qu'on appel 'Packed Pixel' suivant l'ordre ARGB. Ainsi, toutes les données d'un pixel est contiguë en mémoire. Les 4 canaux de couleurs sont stockés dans un entier non signé de 32 bits. Chaque canal est codé sur 8 bits. Le canal alpha est le plus significatif et le canal bleu est le moins significatif.

La variable buffer pointe vers un tableau de pixels de taille buffer_size. La taille de l'image est donc buffer_size / sizeof(uint32_t).

[           32 bits            ]
[8 bits][8 bits][8 bits][8 bits]
[alpha ][red   ][green ][blue  ]
[alpha ][rouge ][vert  ][bleu  ]

Vous pouvez considérer que l'image a été créée avec le format de Qt QImage::Format_ARGB32.

Il est attendu que vous fassiez une validation minimum des intrants.

Parameters

buffer	Le tableau de pixels de l'image.
buffer_size	La taille du tableau de pixels.

◆ width()

virtual size_t GOL::width ( ) const

pure virtual

Accesseur retournant la largeur de la grille de simualtion.

Returns: La largeur de la grille.

Classes

Public Types

Public Member Functions

Detailed Description

Member Typedef Documentation

◆ ColorChannelType

◆ IterationType

Member Enumeration Documentation

◆ BorderManagement

◆ State

Member Function Documentation

◆ borderManagement()

◆ color()

◆ fill()

◆ fillAlternately()

◆ height()

◆ information()

◆ processOneStep()

◆ randomize()

◆ resize()

◆ rule()

◆ setBorderManagement()

◆ setFromPattern() [1/2]

◆ setFromPattern() [2/2]

◆ setRule()

◆ setSolidColor()

◆ setState()

◆ size()

◆ state()

◆ statistics()

◆ updateImage()

◆ width()