Projet : étape 2.1
Laboratoire et boites de culture

Buts: Mettre en place l'environnement dans lequel évolueront les bactéries.

Préambule

Il s'agit lors de cette étape d'aboutir à un premier programme graphique nous permettant de visualiser des boites de culture et d'y placer des sources de nutriments capables de croître en fonction de la température.

La classe Application joue le même rôle que la classe du même nom fournie dans le corrigé avancé du mini-projet graphique. Plus précisément, cette classe dispose :

d'un attribut de type Laboratory contenant un ensemble de CultureDish;
de méthodes permettant d'appeler en boucle une méthode de mise à jour (update) et une méthode de dessin (drawOn) sur cet attribut. La méthode de mise à jour sera en charge de faire évoluer le «laboratoire» au cours du temps et la méthode de dessin d'en faire un rendu graphique. Le paramètre target de cette dernière représente la fenêtre graphique sur laquelle se fait le dessin. Chaque itération de la boucle est appelé un «cycle de simulation».

C'est par le biais de l'attribut de type Laboratory que se fait lien entre le noyau de simulation fourni et ce que vous codez. Vous noterez aussi que faire évoluer le laboratoire au cours du temps ou le dessiner revient pour nous à faire évoluer/dessiner le contenu ses boites de cultures.
La classe Application dispose par ailleurs d'une méthode handleEvent (ligne 503 de Application.cpp) qui permet à la simulation de réagir à des touches du clavier: par exemple, la touche Esc permet de mettre fin à la simulation (fermeture de la fenêtre). Prenez note de l'existence de cette méthode pour la suite.

Nous allons donc dans ce qui suit procéder au codage des classes CultureDish et Laboratory.

La classe `CultureDish`

Les bactéries que nous simulerons seront confinées dans une boite de culture. Les conditions dans cette boite, comme la température ou la quantité de nutriments, impacteront l'évolution des bactéries qui y vivent.

Une classe CultureDish s'impose et voici quelques attributs qu'il est naturel d'y placer:

l'ensemble de bactéries peuplant la boite. Nous n'en n'avons pas encore, mais elles viendront tôt ou tard : créez simplement une classe Bacterium dans le répertoire src/Lab. Cette classe sera vide pour le moment !
l'ensemble de sources de nutriments pour les bactéries. Vous prévoirez une classe Nutrient, vide aussi pour le moment, pour modéliser une source de nutriments. Le code de cette classe sera aussi placé dans le répertoire src/Lab.
et la température qu'il fait dans la boite (un double).

N'oubliez pas que tout ajout de fichier doit être suivi par

    Build > Run Cmake

dans QtCreator, si l'on souhaite qu'il soit correctement pris en compte lors d la prochaine compilation.

Pour modéliser un ensemble (de bacteries ou de sources de nutriments) vous pourrez utiliser un tableau dynamique et y stockerez des pointeurs sur les objets. Rappelons que le parcours d'un tableau dynamique peut se faire au moyen d'itérations sur ensemble de valeurs :

for (const auto& bacterie : lesBacteries)

for (auto& bacterie : lesBacteries)

Les méthodes décrites ci-dessous sont à prévoir pour la classe CultureDish :

Pour le moment vous laisserez le code des méthodes vides. Mettez simplement un commentaire tel que

//faire évoluer les bactéries ici:

// code pour ajouter les nutriments ici :

pour vous rappeler de la tâche à coder plus tard

(nous vous indiquerons à quels moments compléter ces méthodes)

une méthode bool addBacterium(Bacterium*) qui permettra de peupler la boite (ajouter une bactérie à l'ensemble de bactéries de la boite). Dans certaines conditions il ne sera pas possible de mettre la bactérie comme souhaité dans la boite. Le type de retour de type bool sert à savoir si l'on a réussit à placer la bactérie ou pas;
une méthode bool addNutrient(Nutrient*) qui permettra de placer des nutriments dans la boite. Le type de retour de type bool à la même fonction que pour les bactéries;
une méthode void update(sf::Time dt) qui sera en charge principalement de faire évoluer toutes les bactéries de la boite, ainsi que les sources de nutriments, à chaque pas de temps.
une méthode drawOn(sf::RenderTarget& targetWindow) qui sera en charge de dessiner sur une fenêtre graphique (targetWindow) le contour de la boite, ainsi que les bactéries et les nutriments qui s'y trouvent :
l'inclusion de <SFML/Graphics.hpp> est nécessaire pour l'accès au type RenderTarget.

À sa création, une boite de culture aura pour température la valeur retournée par la tournure getAppConfig()["culture dish"]["temperature"]["default"].toDouble() qui vous sera expliquée à l'étape suivante (l'inclusion de Application.hpp est nécessaire).

[Question Q2.1] Pour pouvoir représenter graphiquement la boite de culture et pour pouvoir en délimiter le pourtour, par exemple pour empêcher les bactéries d'en sortir, nous souhaitons voir la boite comme étant un contour circulaire (qui aura une position dans l'environnement en deux dimensions servant de support à nos simulations et bien sûr). Comment utiliser la classe CircularBoundary pour modéliser cela ? Répondez à cette question dans votre fichier REPONSES, puis dotez la classe CultureDish d'un constructeur prenant en paramètre une position (un Vec2d) et un rayon (double).

[Question Q2.2] Quelles méthodes vous semble t-il judicieux de déclarer comme const? Répondez à cette question, en justifiant vos choix, dans votre fichier REPONSES.

[Question Q2.3] On souhaite ne pas permettre la copie d'une CultureDish ni l'affectation. Quelle(s) solution(s) proposeriez-vous pour satisfaire cette contrainte? Réfléchissez et répondez à cette question dans votre fichier REPONSES puis implémentez votre code en conséquence.

[Question Q2.4] La question Q2.3 suggère que chaque simulation s'intéressera à des boites disposant chacune de leur propre ensemble de bactéries et de nutriments. Il n'y a par ailleurs pas beaucoup de sens à faire vivre les bactéries sans les rattacher à une boite dans le contexte de ce projet. Une CultureDish peut donc être considérée comme responsable de la durée de vie des bactéries et des nutriments amenés à être créés dans la simulation. Quelle incidence cela a t-il sur la destruction d'une boite de culture ? La destruction peut-elle se faire en utilisant une méthode existante de la classe CultureDish. Répondez à ces questions dans votre fichier REPONSES puis codez le destructeur de CultureDish.

Dessin d'une boite de culture

Maintenant, que notre boite de culture a une rayon et une position, il est possible de revenir à la méthode CultureDish::drawOn pour lui faire faire quelque chose. Complétez le code de cette méthode pour lui faire dessiner le contour de la boite.

Pour dessiner un anneau dans une fenêtre graphique target, il suffira d'utiliser les fonctionnalités de la bibliothèque graphique SFML via les instructions suivantes :

  auto border = buildAnnulus(position, rayon, couleur, epaissseur);
  target.draw(border);

La fonction buildAnnulus est à disposition dans Utility.[hpp][cpp]

où :

position est la position du centre de l'anneau (en l'occurence la position du centre de la CultureDish);
rayon son rayon,
couleur une couleur connue de SFML (prenez par exemple une couleur initialisée comme suit sf::Color color(255,255,255,100) pour un blanc un peu transparent, ou cherchez sf::Color dans la documentation pour connaître d'autres couleurs);
et epaisseur l'épaisseur du trait (prenez 25 par exemple).

Avant de pouvoir tester ces nouveaux développements, il va être nécessaire de pousser notre conception un peu plus loin, dans le sens suggéré par le préambule.

La classe `Laboratory`

La classe Laboratory va modéliser le support sur lequel sont posées des boites de culture. On part de l'idée qu'une seule boite de culture sera visible à la fois et que l'on pourra par la suite passer d'une boite à l'autre au moyen de touches de contrôle.

Pour commencer, un Laboratory aura comme caractéristiques principales un ensemble de CultureDish (vector), ainsi que l'indice de la boite courante : celle visible. Il ne doit pas pouvoir être copié.

Pour cette classe particulère, les méthodes principales vous sont dictées de façon assez détaillée et précise. Le but est d'assurer la compatibilité avec le noyau de simulation fourni. Souvenez-vous en effet que c'est par le biais d'un attribut de type Laboratory que se fait le lien entre votre code et le noyau de simulation (Application). Il vous faudra donc prévoir les méthodes suivantes :

void nextDish() qui permet d'augmenter d'une unité l'indice de la boite courante. Ceci se fera de façon circulaire: lorsque l'on dépasse l'indice maximal possible on revient à zéro;
void previousDish() qui permet de diminuer d'une unité l'indice de la boite courante. Ceci se fera aussi de façon circulaire: lorsque l'on est en dessous de zéro on revient à l'indice maximal possible;
size_t Laboratory::getCurrentDishId() qui retourne l'indice de la boite courante;
increaseTemperature() et void decreaseTemperature() dont le rôle est de permettre d'augmenter/diminuer la température de la boite courante; pour le moment vous pouvez vous contenter de les faire augmenter/diminuer d'une quelconque valeur fixe;
getTemperature() retournant la température de la boite courante;
reset permettant de vider la boite courante de son contenu (de ses bactéries et nutriments);
et void resetControls(), vide pour le moment et dont le rôle vous sera expliqué un peu plus tard.

pour une bonne encapsulation, la classe Lab ne doit pas donner accès à ses boites de cultures via des getters;
La méthode getAppEnv() utilisable après inclusion de Application.hpp retourne le Laboratory associé à tous les tests graphiques que vous lancerez.
Pour éviter les situations de dépendances circulaires inutiles entre classes, prenez soin de n'inclure Application.hpp que dans le fichier utilisant cette fonctionnalité. Par exemple, si c'est Laboratory.cpp qui utilise getAppEnv(), il faut inclure Application.hpp dans Laboratory.cpp et non pas dans Laboratory.hpp.

Exemple typique de dépendance circulaire: Laboratory.hpp inclut Application.hpp qui inclut Laboratory.hpp (et cela met en déroute le compilateur).

[Question Q2.5] Pour le moment, faire évoluer un Laboratory c'est simplement faire évoluer ses boites de culture et le dessiner c'est dessiner la boite d'indice courant car il est inutile de dessiner ce que l'on ne voit pas. Comment proposez-vous de coder le corps des méthodes Lab::drawOn et Lab::update ? Répondez à cette question dans votre fichier REPONSES.

Dotez ensuite votre classe Laboratory d'un constructeur permettant de positionner la boite de culture d'indice courant au centre de la fenêtre graphique associée au Laboratory et avec un diamètre occupant les 95% de la largeur de cette fenêtre. Ce constructeur dotera le Laboratory d'un nombre fixe de boites et l'indice courant pointera sur la première boite (celle d'indice zéro). Le nombre de boites est donné par la tournure getShortConfig().culture_dishes_number (nécessitant l'inclusion de Config.hpp). Cette tournure vous sera expliquée en détail à l'étape suivante et pour le moment il suffit de savoir qu'elle retourne la valeur de la constante définie à la ligne 78 de Config.hpp; c'est à dire 3. Cette valeur peut être changée à votre guise.

Indications:

la fenêtre graphique associée au Laboratory est en fait la partie mSimulationFrame telle que décrite dans les commentaires de la fonction fournie Application::createViews() dans le fichier Application.cpp;
l'instruction getApp().getCentre() retourne le centre de la fenêtre graphique associée au Laboratory;
getApp().getLabSize().x() donne la largeur de cette fenêtre

Pour pouvoir utiliser ces tournures, incluez simplement Application.hpp, mais attention de le faire dans les .cpp uniquement pour éviter les situations de dépendances circulaire.

Test 2 : boites de culture vide

Pour tester vos développements, une application graphique est fournie dans src/Tests/GraphicalTests/NutrientTest.[hpp][cpp].

Ce test doit son nom au fait qu'il permettra aussi de tester graphiquement la génération automatiques des nutriments dans la boite de culture :-)

La classe NutrientTest hérite de Application (elle dispose donc d'un attribut de type Laboratory!). Elle définit simplement la méthode onEvent de sorte à ce que :

appuyer sur la touche 'R' du clavier se traduise par un appel à la méthode Lab::reset qui doit impliquer de vider la boite de culture;
appuyer sur la touche 'N' se traduise par la création de source de nutriments (lorsque vous aurez fait le nécessaire, un peu plus loin).
appuyer sur la touche 'T' se traduise par puiser une certaine quantité de nutriments de la dernière source de nutriments créée.

Le fichier CMakeLists.txt fourni permet de lancer la compilation du test par le biais de la cible nutrientTest

N'oubliez pas de décommenter cette cible dans le fichier CMakeLists.txt (lignes 168 et 169) et d'exécuter Build > Run Cmake lorsque vous êtes prêt à tester.

Faites le nécessaire pour la touche 'R'. Si vous avez correctement codé les choses jusqu'ici, le lancement de ce test devrait vous permettre de voir se dessiner la boite de culture (anneau blanc) dans la partie de l'application graphique réservée à cet usage :

Contrôles

Certains paramètres importants de la simulation doivent pouvoir être directement contrôlés depuis l'interface graphique. C'est le cas de la boite courante de simulation : on aimerait pouvoir transiter d'une boite à l'autre en appuyant sur une touche.

Si vous ouvrez le fichier Application.cpp, vous pourrez en effet observer que les mécanismes nécessaires sont déjà en place. Par exemple, les méthodes nextDish et previousDish y sont bel et bien appelées par la méthode handleEvent. D'autres paramètres que la boite courante sont aussi contrôlables via l'interface; la température de l'assiette courante par exemple.

Lorsque vous lancez nutrientTest, les éléments qui s'affichent dans le menu en haut à droite sont les paramètres contrôlables et l'on peut passer de l'un à l'autre au moyen de la touche Tab ou de la touche Q. Le paramètre s'affichant en rouge est celui sur lequel on peut agir depuis l'interface graphique. Le bandeau explicatif en bas à droite, indique que les touche 'PgUp' ou X ainsi que 'PgDn' /Y permettent d'augmenter ou diminuer la valeur du paramètre sélectionné (celui en rouge).

Utilisez ces touches pour vous positionner sur le paramètre Dish id. Vérifiez alors que vos méthodes nextDish et previousDish ont été correctement codées. Pour chacune de valeurs possibles d'identifiant, une boite vide doit s'afficher.

Retour à l'énoncé du projet (partie 2) Module suivant (partie 2.2)

Projet : étape 2.1 Laboratoire et boites de culture