Rapport final

2008-2009

2009-
2010
LOGICIEL DE CUISINE
VIRTUELLE

Fayçal De Poltorasky Moctar

Mbodj
Cédric Lingani Hicham
Mgueraman

Type de rapport : Phase

d’Analyse

Tuteur : Yves Gaël Billet

Date : 11/01/2010
1
Rapport final
2008-2009

1
Rapport final
2008-2009

SOMMAIRE

1 - Introduction..............................................................................................4

1.1. Présentation du sujet : Logiciel de cuisine virtuelle.........................5

1.2. Objectifs du logiciel........................................................................5

2 - Bilan de la phase d’analyse........................................................................6

2.1. Principe de fonctionnement............................................................6

2.2. Les grandes fonctions de l’Application............................................6

2.3. Interaction homme-machine...........................................................7

2.4 Cas d’utilisations............................................................................7

2-5 Diagramme d’état..........................................................................8

2.6 Diagrammes de collaboration..........................................................9

2.7 Contraintes...................................................................................12

2.8 Limites.........................................................................................12

3 Mise en œuvre du logiciel de cuisine virtuelle ............................................13

3.1 Consulter une recette....................................................................13

3.2 Exécuter une recette.....................................................................14

3.3 Ajouter une recette.......................................................................17

3.4 Recherche Par mot-clé...................................................................19

3.5 Définition des étapes d’une recette................................................21

3.6 Création de la Base de Donnée.......................................................25

3.7 Diagramme de classes du Projet....................................................28

4 Gestion du projet.......................................................................................29

4.1 Découpage du projet.....................................................................29

4.2 Planning (confer Annexe p.33)......................................................29

4.3 Travail collaboratif........................................................................29

5 Conclusion................................................................................................31

6 Annexe.......................................................................................................1

6.1 Planning prévisionnel......................................................................1

6.2 Etat d’avancement..........................................................................1

1
Rapport final
2008-2009

1 - Introduction

1
Rapport final
2008-2009

1.1. Présentation du sujet : Logiciel de cuisine virtuelle

Le logiciel doit permettre à partir d’une base de données de produits et d’action, de

simuler le déroulement d’une recette.
Différentes bases seront définies à partir de fichiers texte ou image:
• Base de recettes - texte de la recette ;
• Base de produits – images (farine, sucre, œuf, levure,…) ;
• Base de récipients – images (bol, casserole, …) ;
• Base d’ustensiles (couteau, batteur, spatule, …) ;
• Base d’actions (verser, casser, éplucher, …..).
Le logiciel permettra de gérer la base de recettes : insérer, consulter, supprimer,
rechercher par mots clés, commenter une recette.
Il sera également possible à partir de générer l’animation des différentes d’une recette
par analyse d’un fichier texte précisant la recette et par analogie aux éléments des bases
prédéfinies. L’animation sera enregistrée dans un fichier. Les actions, ustensiles seront
directement issus des mots du texte.

1.2. Objectifs du logiciel

Le but du projet informatique est de créer un logiciel interactif de cuisine virtuel.

L’objectif du logiciel est de permettre à un utilisateur d’une part de gérer ces recettes
et de les stocker, et d’autre part lui faciliter la préparation de celle-ci à l’aide d’un menu
et d’animations qui montre les outils, produits et actions nécessaire.

1
Rapport final
2008-2009

2 - Bilan de la phase d’analyse

2.1. Principe de fonctionnement
D’une part à partir d’un choix de recettes proposé, le logiciel lui indiquera les différentes
étapes de réalisation du plat. Chacune de ces étapes lui sera décrite sous forme de texte
mettant en évidence des actions et des tâches à faire avec à l’appui une animation pour
le coté pratique. D’autre part l’utilisateur pourra gérer et stoker ces recettes à l’aide du
logiciel.

2.2. Les grandes fonctions de l’Application

Nous avons identifié les grandes fonctions suivantes :

- Gestion de recettes existantes

Modification, suppression, consultation et recherche des recettes présentes

sur le logiciel.

- Gestion des animations

Montage et stockage des animations

- Gestion de l’ajout d’une recette

Transfert de la recette sous format texte (.txt) dans la base de données et

création des animations correspondantes tout ça grâce à l’aide de mot
clé. Le style d’écriture d’une recette au format de texte sera imposé à
l’utilisateur (standard d’écriture) de sorte que le logiciel puisse aisément y
effectuer des recherches.

- Gestion des opérations sur la base de données

Création, remplissage et gestion des accès à la base de données chose

totalement différente de gestion de recette puisque la on gère directement les
tables avec les droit d’accès.

1
Rapport final
2008-2009

2.3. Interaction homme-machine

La prise en main du logiciel par l’utilisateur et la découverte de ses fonctionnalités
devra être simple et facile.
De plus le logiciel devra satisfaire au mieux les demandes de l’utilisateur tout en lui
permettant une flexibilité dans la gestion des recettes de celui-ci.
L’utilisateur accèdera à une recette à partir du mode recherche grâce au nom des
ingrédients entrant dans la composition de la recette ou au nom de la recette (une
recette à la fois). Le logiciel va récupérer dans la base une liste de recettes contenant les
ingrédients spécifiés ou la recette indiquée si elle y existe. Sinon il peut accéder à une
recette à partir du mode consultation de recettes qui, lui présentera une liste de toutes
celles présentes dans la base de données et il n’aura qu’à faire un choix.

2.4 Cas d’utilisations

Nous avons identifié deux cas d’utilisations du logiciel par l’utilisateur qui sont les
suivants :
• Recherche de recettes existantes
- Recherche par mot-clé : Là l’utilisateur à deux possibilités. Soit il
connait le nom de la recette et il la saisit. Dans ce cas un message
est affiché lui indiquant l’existence de la recette dans la base ou
pas. Soit il ne la connait pas et il saisit une information permettant
de la retrouver (EX : une partie du nom de la recette). Dans ce cas
ci, une liste de recettes comportant le mot saisit est affichée.

- Recherche par liste : Ici l’ensemble des recettes présentent dans la

base de données est affiché à l’utilisateur.

1
Rapport final
2008-2009

Dans ces deux cas de recherches après avoir fait un choix de recette, l’utilisateur peut
exécuter un certains nombre d’actions ou tout simplement revenir au menu principal.
Les différentes actions que l’utilisateur peut exécuter après le choix d’une recette sont :

 Effectuer des modifications sur la recette (ajout de commentaires…) ;

 Exécuter la recette.

• Insertion d’une recette

Pour insérer une recette l’utilisateur doit la composer à partir des ingrédients (sans la
quantité), actions, ustensiles et récipients présentent dans la base.

«uses» Modifier
Rechercher recette
Saisir mot-clé
par mot-clé
«uses»

«uses»
Exécuter
Choix de l'action à faire
«uses» «uses» «uses»
Rechercher recette
Choix recette
par liste

«uses»
Consulter
Acteur1
vérification insertion
«extends»
Insérer recette

Figure 1 : Diagramme de cas d’utilisation

2-5 Diagramme d’état

1
Rapport final
2008-2009

Recette trouvée

consultation

ÉtatComposite1
Exécution
Recherche
d'une recette

Choix de l'action
Modification
Menu Principal

Recette non trouvée insertion d'une recette

Figure 3 : Diagramme d’état

Le cercle plein représente l’état initial du système (Menu principal). Les cercles à
bordure blanche représentent les différents états finaux c'est-à-dire l’état à après
l’exécution d’une action. Nous en avons quatre :
• Recette consultée ;
• Recette modifiée ;
• Recette exécutée ;
• Recette insérée.

2.6 Diagrammes de collaboration

1
Rapport final
2008-2009

aff

commentair Recette

Aff

pro
n
oix tio

po
ch ac

se
n u
Me
saisire

iste liste recettes

Aff l i x
cho

pro
po
se
sais ie re Quitter

Aff
che rche
e
p os
p ro
Recherche
sa
isi
Paquet supérieur::Acteur1 e
inf
o

se
po
transer info

pro
Aff

Menu Erreur

choix

Recherche d’une recette par mot‐clé

1
Rapport final
2008-2009

commentair

pr
op
os
e
e
isir
sa

aff
propose
choix
Menu action Recette Quitter

Af f
l
cho iste

e
ix

os
op
pr
Aff
Acteur1

liste recettes

choix

Recherche d’une recette par liste

control erreur

pr
op
os
re e
is i ur
aff+tr info

sa erre
tr info

g
ms

propose
saisir Recette Quitter

sa
uv
e
sa gard
Acteur1 uv e
e g ef f
ar ec
de tué
Sauvegarde
choix

Insertion d’une recette

1
Rapport final
2008-2009

2.7 Contraintes

Contrainte de la plateforme : Visual C++

Contrainte graphique : utilisation de la console au lieu de la fenêtre graphique
Contrainte sur le format du fichier : Seuls les fichiers textes (.txt) pourront être traité par
le logiciel
Contrainte du sujet : Respect de l’énoncé et du cahier des charges

2.8 Limites
Nous avons identifiés comme limites :
• Erreur commise par l’utilisateur à la saisie ;
• Limite des actions, produit, et matériel qui pourra être utilisé dans les recettes ;
• Problème lié au format de l’animation que peut être ne pourra pas être lu par le PC
de l’utilisateur ;
• Ajout du son : il ne sera pas possible d’accompagner les différentes étapes de
notre recette à l’aide d’un commentaire audio.

1
Rapport final
2008-2009

3 Mise en œuvre du logiciel de cuisine virtuelle

3.1 Consulter une recette

• Utilité

Cette partie nous sert à présenter la recette à l’utilisateur une fois qu’il a
choisi de la recette à consulter. Pour cela, il est explicité la liste des
ingrédients et les étapes de la préparation.

• Implémentation

bool Recettes::Consulter()
{
Récupération du nom de la recette saisie par l’utilisateur
SetNom(name);

Récupération ,à partir du nom de la recette, de l’ID correcpondant dans la BDD

GetID(req,0);

Récupération ,à partir de l’ID de la recette, de la liste de ingredients, ustensiles,

récipients ainsi que du texte de préparation GetIngr(requete);
GetIngr(requete1);
GetUst(requete2,nbr2);
GetRec(requete3,nbr3);
GetPrepa(requete4,nbr4);

Affichage ordonné des résultats

Affichtext();

• Problèmes rencontrés

Il n’y a pas eu de difficulté particulière, juste l’affichage ordonné des données a

pris du temps.

Diagramme de séquence

1
Rapport final
2008-2009

3.2 Exécuter une recette

1
Rapport final
2008-2009

• Utilité

Cette méthode nous sert à présenter à l’utilisateur les étapes pour la

préparation tout en lui faisant défiler les images correspondantes aux verbes
d’action et aux ingrédients à utiliser.

• Implémentation

La méthode commence par afficher la liste des ingrédients, ustensiles et

récipients et après les étapes de la préparation.

Ensuite, on passe à la partie animation qui consiste à afficher les étapes de la

préparation ligne par ligne accompagné d'images. On utilise pour cela les
méthodes animer et affichertab

Animer:

Une méthode de la classe recette qui récupère un string qui est le nom de
l'image correspondante à une partie de l'étape soit l’action, soit l’ingrédient,
soit l’ustensile ou le récipient.

Affichertab :

Cette méthode utilise la table étape où sont enregistrées les identifiants de

chaque composant de l'étape. Elle transforme l'ID en texte et appelle la
méthode animer

Utilisation des images :

Les images des actions sont précédées de 0

Les images des ingrédients sont précédées de 1

Les images des récipients sont précédées de 2

Les images des ustensiles sont précédées de 3

• Problèmes rencontrés

Utiliser une vraie animation, les conversions du string pour utiliser avec la
fonction cls ou les méthodes de la classe bdd.

Utilisation de la classe bdd et le contrôle des erreurs de saisie par l'utilisateur.

1
Rapport final
2008-2009

Diagramme de séquence

1
Rapport final
2008-2009

3.3 Ajouter une recette

• Utilité

Cette méthode permet à l’utilisateur d’ajouter une nouvelle recette à la notre

base de recette existante. Ainsi, l’utilisateur devra suivre des instructions
précises afin que sa recette puisse être transférée à la base de données.

• Implémentation

La méthode Ajouter recette permet à partir d’une liste d’ingredients, d’actions, de

récipients et d’ustensiles,de composer une recette.

bool Recettes::AjouterRecette()
{
 Affichage des listes
Recuperation du nom de la recette à créer
GetNom();

Recuperation de la liste de tous les ingredients, ustensiles et actions presente dans la

BDD (1)
GetIng(requete,nbr1);
GetUst(requete2,nbr2);
GetRec(requete3,nbr3);
GetAct(requete4,nbr4);

Affichage à l’ecran des differentes listes

Afficher();
 Composition de la recette
permet a l’utilisateur de composer les etapes de preparation de sa recette
ComposerRecette();
}

• Problèmes rencontrés

Difficulté: conversion des types des données à insérer dans la BDD.

Manipulation de grands tableaux (2 dimensions) surtout lors de la
modification des informations par l’utilisateur avant l’enregistrement dans la
BDD.

1
Rapport final
2008-2009

Solution : utilisation de fonction pour les conversions des types et conversion

de tableaux de type vector à la place des tableaux classiques.

Diagramme de séquence

1
Rapport final
2008-2009

3.4 Recherche Par mot-clé

• Utilité

La recherche par mot-clé consiste à aider l’utilisateur pour qu’il n’ait pas à défiler
toutes les recettes. Ainsi dès son entrée dans le logiciel, il lui est proposé
d’effectuer une recherche par mot clé pour s’il détient une recette en tête.

• Implémentation

Le but principal du code est de trouver le mot clé recherché par l’utilisateur.
Ainsi, il s’agit de chercher dans la base de données toutes les recettes
contenant une partie du mot clé saisi.

Pour cela, lorsque le nom d’une recette est constitué de plusieurs mots, on
découpe cela en mettant chaque mot dans un tableau et on regarde s’il est
constitué du mot clé. Si c’est le cas, on propose à l’utilisateur la liste des
recettes trouvées sinon nous l’invitons à saisir un autre mot clé.

Ensuite, on récupère l’ID de la recette trouvée afin de la communiquer aux

méthodes de consultation et d’exécution de recette afin qu’ils puissent
montrer les étapes de cuisine de la recette mais aussi générer les animations
en fonction des étapes.

De plus, il a fallu générer les requêtes nécessaires pour parcourir la liste de

noms de toutes les recettes et d’en récupérer celle qui contiennent le mot clé
choisi par l’utilisateur.

Enfin, l’utilisation de tableau dynamique a été nécessaire car les tableaux

statiques ne sont pas très pratiques du fait qu’ils ne sont pas
redimensionnables. De plus, il peut contenir n'importe quel type ou un objet
de n'importe quelle classe.

• Problèmes rencontrés

1
Rapport final
2008-2009

Le seul problème a été la connexion avec la base de donnée qui s’est avéré
moins compliqué une fois les fondements de sqlite maîtrisés.

Diagramme de séquence

1
Rapport final
2008-2009

3.5 Définition des étapes d’une recette

1
Rapport final
2008-2009

• Utilité

Cette méthode nous permet de composer les étapes qui définissent la

préparation d’une recette. Ainsi, cela permettra à la méthode Exécuter de
récupérer les informations directement et enfin de générer les images
correspondantes à l’étape.

• Implémentation

void Recettes::ChoixEtape()
{
Do{
Récupère dans un objet Etape des identifiants de l’ustensile, recipient, et action saisie
par l’utilisateur à partir de listes ci-dessus(1)

etap.AjouterElement(ustensile);
etap.AjouterElement(recipient);
etap.AjouterElement(recipient);

Récupère dans un objet Etape de la quantité et de l’identifiant d’un ingrédient saisie par
l’utilisateur à partir de listes ci-dessus(1)

etap.AjouterElement(qt);
etap.AjouterElement(ingredient);

Remarque :Toutes ces informations sont enregistrées dans un tableau de type

vector<string>.

Enregristrement de l’étapes dans un tableau de type vector< vector<string>> et Vidage

du premier tableau après la composition d’une étape.

etap.Effacertab();

Demande à l’utilisateur s’il veux saisir une autre étape

}
While(reponse==’o’) ;

1
Rapport final
2008-2009

Remarque : Les informations sont saisies autant de fois qu’il y’a d’étapes dans la
préparation de la recette. Nous avons donc à la fin de la saisie un tableau d’étapes qui
contient chacun de ses éléments un tableau d’ingredients, d’actions, d’ustensiles et de
récipients.

Permet à l’utilisateur de modifier les étapes qu’il a saisie avant l’enregistrement dans la
BDD
Modifier(etap);

Insertion dans la table Recettes de la BDD du nom saisie par l’utilisateur et récupération
de l’ID correspondant

Ba.querysave(requete);
GetID(req,0);
Boucle permettant de parcourir le tableau d’étapes afin de les insérer dans la table
Etapes de la BDD.
for(int i=0;i<(int)etap.list.size();i++)
{
Requete permettant l’insersion dans la BDD
Ba.querysave(req);
}
}

• Problèmes rencontrés

Le problème le plus important a été le respect des identifiants affectés à

chaque verbe d’actions et à chaque ingrédient afin de bien définir les étapes.

1
Rapport final
2008-2009

Diagramme de séquence

1
Rapport final
2008-2009

3.6 Création de la Base de Donnée

• Utilité

La base de donnée nous permet de stocker toutes les informations émanent

du logiciel de cuisine tel que le nom des recettes, les ingrédients, les
ustensiles etc.… Une connexion est aussi faite dessus pour en extraire les
informations.

• Implémentation

class BDD
{
public:
constructeur
BDD();
destructeur
~BDD();

Permet de récupérer un entier dans la colonne d’une table

long find_long(char *sql_rec,unsigned long num_colonne);

Permet de récupérer un entier dans la colonne d’une table

string find_text(char *sql_rec,unsigned long num_colonne);

Permet de récupérer la liste des étapes constituant une recette

vector<vector<string>> queryfind_etape(char *sql_rec);

Permet de récupérer un entier dans la colonne d’une table

vector<long> queryfind_long(char *sql_rec,unsigned long num_colonne);

Permet de récupérer un entier dans la colonne d’une table

vector<string> queryfind_text(char *sql_rec,unsigned long num_colonne);

Permet de récupérer la liste des ingrédients de la table Etapes

vector<string> queryfind_te(char *sql_rec);

1
Rapport final
2008-2009

Permet d’insérer des éléments dans une table

int querysave(char *sql_rec);
}

La BDD est composée de six tables :

- Recettes - Ingrédients - Récipients

- Actions - Ustensiles - Etapes

• Modèle des tables de la base de données

Table Recette

Table Ingrédients

Nom

IDingrédient
IDrecette Nom

1 Tarte aux pommes

1 Pommes

Table Actions

IDaction Nom

3 Couper

Table Ustensiles

1
Rapport final
2008-2009

IDustensile Nom

12 couteau

Table Actions-Ingrédients-Quantités

IDaction_ingrédie IDaction Quantité IDingrédient IDustensile IDRecipient IDeta

nt pe

4 3 6 1 _ 12

Table Recipients

IDRecipient Nom

5 saladière

Table Etapes

IDrecette IDetape IDaction_ingrédient

1 1 4

• Problèmes rencontrés

Difficulté: Pour la récupération des données de la BDD à partir des méthodes de

bas niveau
de sqlite3. Complexité à observer les tables de la BDD en mode console.

Solution: Utilisation d'une bibliothèque encapsulant les méthodes de sqlite3 et

permettant un
accès simple aux données. Installation du logiciel sqliteconverter(freesoft) pour la
visualisation
en mode graphique des tables et pour effectuer des tests sur la BDD sans en
modifier le

1
Rapport final
2008-2009

contenu.

3.7 Diagramme de classes du Projet

1
Rapport final
2008-2009

4 Gestion du projet
La méthode de gestion de projet permet de travailler en équipe, et de réaliser
le produit dans le temps imparti.

4.1 Découpage du projet

Ce projet se décompose en 5 grandes phases :
- Etape 1 : Cahier des charges – Expression du besoin du client
- Etape 2 : Spécifications – Compréhension du besoin
- Etape 3 : Conception Orientée Objet – Comment réaliser le besoin ?
- Etape 4 : Analyse – Synthèse sur la conception
- Etape 5 : Implémentation – Réalisation
Chacune de ces phases est découpée en sous phases, qui sont :
- Des réunions « internes »
- Une réunion avec le tuteur
- La création d’un document faisant office de livrable.
Nous avons achevé les trois premières étapes et nous commençons l’étape
quatre selon le planning donné.

4.2 Planning (confer Annexe p.33)

Pour nous situer dans le temps au cours du projet un planning a été défini, sur
le modèle d’un diagramme de Gantt.

Pour l’instant nous respectons le planning donné par la responsable de projet.

En confrontant notre emploi du temps scolaire et le planning du projet, nous
avons pu trouver des créneaux pour nous réunir pour discuter du projet, avec un
minimum de contraintes.

4.3 Travail collaboratif

Un des points important de ce projet est le travail collaboratif, il se présente
sous forme d’entraide et de répartition de tâches.

L’élaboration du contenu des différents documents, qui modélisent notre

logiciel, tel que le cahier des charges, le cahier de spécifications et le modèle de
conception orienté objet, est issue de réunions que nous avons eu en commun.

1
Rapport final
2008-2009

Pour chaque première réunion de phases, chacun membre de l’équipe a préparer

l’ensemble de la réunion, ceci dans l’idée de créer un logiciel qui corresponde à
l’équipe et pas à un individu du groupes, nous avons ainsi pu tirer parti des idées
de chacun. A l’issue de ces réunions, nous avons partagé le travail pour la
rédaction des différents documents.

BIBLIOGRAPHIE

Modifications apportées dans les spécifications

En raison de la difficulté à gérer le retour vers le menu principal de notre

application nous avons
opté pour la gestion par des options menu en plus du menu principal . Chaque
option menu étant
un élément du menu principale et chacune de ces options est associé une
variable booléenne permettant
de revenir au menu principal ou de quitter l'application.

Supplément apporté

Nous avons jugé contenu de notre avancement assez rapide dans notre projet
d'associer une interface
graphique à notre logiciel. Ce qui à pour avantage d'améliorer très
significativement sa maniabilité et sa
facilité d'appréhension. Bien cet interface n'est qu'un prototype mais cela indique
va quelle fin nous
destinons ce logiciel.

1
Rapport final
2008-2009

5 Conclusion
Ce projet nous a permis de pouvoir s’adapter au travail de
groupe. En effet, nous avons pu nous rendre compte que le
travail de groupe doit être organisé et nécessite de la rigueur et
l’entente entre les membres du groupe. Il nous a permis aussi
de mettre en pratique nos connaissances acquises et de se
rendre comptes de leurs utilités dans la vie quotidienne.

Pour cela, on est parti de différentes solutions, nous avons pu

grâce à nos connaissances acquises pendant notre cursus
scolaire, adapter chacune de ces solutions à notre sujet afin
d’établir un meilleur chemin pour résoudre certains problèmes
liés au développement du logiciel de cuisine.

1
Rapport final
2008-2009

1
Rapport final
2008-2009

6 Annexe
6.1 Planning prévisionnel

6.2 Etat d’avancement