4c6746f44df030832ae4a91c43e4ef945b7d9ad0 to master · Vuillemot Romain / INF-TC1

Original line number	Diff line number	Diff line
		%% Cell type:markdown id:4770edbf tags:
		%% Cell type:markdown id:39a8f123 tags:

		NAME:

		%% Cell type:markdown id:e1098061-ab50-4ba8-aa59-0b76ec1049a2 tags:

		# INF TC1 - TD3 (2h) - Arbres binaires

		%% Cell type:markdown id:fc6c7558-96c4-435b-a841-e38c5d14bc9f tags:

		---

		%% Cell type:markdown id:b0997389-5a87-4e8d-9600-29ed76e01759 tags:

		<details style="border: 1px">
		<summary> RAPPELS SUR L'UTILISATION DES NOTEBOOKS</summary>

		### Comment utiliser ces notebooks ?

		Le but de votre travail est de répondre aux questions des exercices en remplissant certaines cellules de ce notebook avec votre solution. Ces cellules, une foit remplies et lancées au fur et à mesure de vos avancées, permettront de valider des tests écrits dans d'autres cellules de ce notebook. Il est donc important de bien suivre les instructions et répondre aux questions dans l'ordre, et ne pas changer le nom des fonctions et/ou les cellules. En particulier :

		1) Répondez aux questions dans les cellules en dessous des questions.

		2) Votre code devra remplacer le texte suivant :

		```python
		# YOUR CODE HERE
		raise NotImplementedError()
		```

		(vous pouvez effacer ces deux lignes quand vous les rencontrez mais ne modifiez pas les noms de fonctions sinon les tests ne marchent plus).

		3) Exécuter enfin les cellules dans leur ordre d'apparition, de haut en bas et si votre code est correct alors les tests (sous forme d'`assert` seront validés (ils ne lanceront pas d'exception du type `AssertionError` ). Vous pouvez lancer plusieurs fois la même cellule, cela ne pose pas de soucis.

		4) Vous pouvez créer de nouvelles cellules comme bon vous semble.

		En cas de problème, une solution est de relancer les cellules depuis le début du notebook une par une. Pensez à bien sauvegarder ce notebook et ne pas le remplacer par un notebook qui a le même nom.
		</details>

		%% Cell type:markdown id:de645c99-52cf-4cff-9c6b-b156101ad47c tags:

		## Objectif du TD

		Ce TD vous fera manipuler les Arbres Binaires, qui sont une structure de données permettant de stocker des informations de manière hierarchique, et de les récupérer grace à des méthodes de parcours.

		%% Cell type:markdown id:abde77ea-e21d-434e-b72e-a62ac464c793 tags:

		## Exercice 1 : Introduction aux Arbres Binaires

		Dans ce exercice nous allons créer et parcourir un Arbre Binaire. Un Arbre Binaire est un Arbre qui a les propriétés suivantes :
		Dans ce exercice vous allez créer et parcourir un Arbre Binaire. Un Arbre Binaire est un Arbre qui a les propriétés suivantes :

		- il comporte des noeuds ayant au _maximum deux enfants_
		- il est dit _binaire_ car il comporte des noeuds ayant au _maximum_ deux enfants
		- il est dit _complet_ si tous les niveaux de l'arbre sont remplis (sauf éventuellement le dernier), et dans lequel les feuilles sont alignées à gauche
		- il est dit _équilibré_ si la différence de hauteur entre les sous-arbres gauche et droit de chaque nœud est au plus 1

		Voici un exemple d'Arbre Binaire :

		```
		1
		/ \
		2 3
		```

		Dans cet exercice nous stockeront l'Arbre Binaire avec une structure de donnée _explicite_ en POO (comme ci-dessous) qui contient des valeurs entières (et uniques, à savoir deux noeuds n'auront pas la même valeur `value`) dans chaque noeud :
		Dans cet exercice nous stockeront l'Arbre Binaire avec une structure de donnée _explicite_ (en POO comme ci-dessous, et non plus dans un tableau comme pour le tas dans le TD 2) qui contient des valeurs entières (et uniques, à savoir deux noeuds n'auront pas la même valeur `value`) dans chaque noeud :

		%% Cell type:code id:9318f291-f289-4eb6-a7f7-94cbc4e3f459 tags:

		``` python
		class Node:
		def __init__(self, value : int, left = None, right = None):
		self.value = value
		self.left = left
		self.right = right
		```

		%% Cell type:markdown id:31993aa6-7361-4a58-856d-32f3a3fcec36 tags:

		Question 1.1 - Utilisez la structure de donnée `Node` ci-dessus afin d'implémenter l'arbre donné en introduction. Votre arbre sera stocké dans la variable `root`. Vous pouvez rajouter des noeuds supplémentaires à cet arbre (mais il doit rester binaire).

		%% Cell type:code id:48a9b647-260e-40a5-a3da-c11ed77a9e62 tags:

		``` python
		root = Node(1) # a modifier
		# YOUR CODE HERE
		raise NotImplementedError()
		```

		%% Cell type:markdown id:0a4461c4-09b8-4f9f-ad70-6b953dc4b7e6 tags:

		Les tests suivant doivent être validés (vous pouvez rajouter d'autres tests) :
		Les tests suivant doivent être validés (rajoutez d'autres tests) :

		%% Cell type:code id:c08d3050-ccba-4b51-8a01-1d2689455e96 tags:

		``` python
		assert root.value == 1
		assert root.left.value == 2
		assert root.right.value == 3
		```

		%% Cell type:markdown id:24670502-ecd5-4d86-a32c-1d7d43eb04fe tags:

		Question 1.2. Proposer une méthode `bfs` de _parcours en largeur_ de l'Arbre afin d'afficher la valeur des noeuds dans l'ordre croissant. Pour cela vous utiliserez une structure de données de File (sous forme de liste, cela sera suffisant). Une méthode possible pour mener cela à bien consiste à :
		Question 1.2. Proposez une méthode `bfs` de _parcours en largeur_ de l'Arbre afin d'afficher la valeur des noeuds dans l'ordre croissant. Pour cela vous utiliserez une structure de données de File (sous forme de liste, cela sera suffisant). Une méthode possible pour mener cela à bien consiste à :

		1. Intialiser la File avec la racine de l'Arbre
		2. Dé-filer une valeur et la stocker dans une liste de résultat
		3. En-filer ses enfants (si il y en a) dans la File
		4. Répéter l'étape 2 jusqu'à ce que la File soit vide, renvoyer le résultat
		1. intialiser la File avec la racine de l'Arbre;
		2. dé-filer une valeur et la stocker dans une liste de résultats;
		3. en-filer ses enfants (si il y en a) dans la File;
		4. répéter l'étape 2 jusqu'à ce que la File soit vide, renvoyer le résultat.

		%% Cell type:code id:1f92e83b-ba51-4fa4-a127-2aa970a96a26 tags:

		``` python
		def bfs(node: Node):
		# YOUR CODE HERE
		raise NotImplementedError()
		```

		%% Cell type:code id:c1b198c7-8387-4552-a163-7a70a70c61a3 tags:

		``` python
		assert bfs(root) == [1, 2, 3]
		```

		%% Cell type:markdown id:675c8c46-ed69-4a2e-a9cf-57301112e3ab tags:

		Question 1.3 - Écrire une fonction `depth` de calcul de la _profondeur_ d'un noeud d'un Arbre. La profondeur est défini comme la distance entre ce noeud et la racine (celle-ci aura une profondeur de `0`) ou autrement dit le nombre d'arête entre le noeud et la racine. Cette fonction prendra en paramètre la racine de l'arbre `root`, ainsi que le noeud dont on veut calculer la profondeur avec le paramètre `target_value`.
		Question 1.3 - Écrivez une fonction `depth` de calcul de la _profondeur_ d'un noeud d'un Arbre. La profondeur est défini comme la distance entre ce noeud et la racine (celle-ci aura une profondeur de `0`). Autrement dit la profondeur correspond au nombre d'arêtes entre un noeud et la racine de l'arbre. Cette fonction prendra en paramètre la racine de l'arbre `root`, ainsi que le noeud dont on veut calculer la profondeur avec le paramètre `target_value`.

		Conseils :

		- s'inspirer de la fonction précédente en incluant la profondeur de chaque noeud parcouru lors de son ajout dans la file;
		- autrement dit rajouter un tuple `(noeud, profondeur)` au lieu du simple noeud parcouru.
		- s'inspirer de la fonction précédente de parcours en largeur en incluant la profondeur de chaque noeud parcouru lors de son ajout dans la file;
		- autrement dit rajouter un tuple `(noeud, profondeur)` au lieu du simple noeud parcouru afin de mémoriser la profondeur des noeuds parcourus.

		%% Cell type:code id:6c21f3f7-0f21-47ad-a4ce-a2af7b9743d4 tags:

		``` python
		def depth(root: Node, target_value: int) -> int:
		# YOUR CODE HERE
		raise NotImplementedError()
		```

		%% Cell type:code id:37a27a50-68f4-486b-a0da-b0905b8db8dd tags:

		``` python
		assert depth(root, 1) == 0
		assert depth(root, 2) == 1
		assert depth(root, 3) == 1
		```

		%% Cell type:markdown id:f8abb2f4-24dc-4346-9081-4400df30e3af tags:

		Question 1.4 - Écrire une fonction `height` de calcul de la _hauteur_ d'un Arbre définie comme la prodondeur maximale possible dans un Arbe. Vous pouvez l'implémenter comme la profondeur maximale des noeuds de l'Arbre, ou bien de manière récursive.
		Question 1.4 - Écrivez une fonction `height` de calcul de la _hauteur_ d'un Arbre définie comme la prodondeur maximale possible dans un Arbe. Vous pouvez l'implémenter comme la profondeur maximale des noeuds de l'Arbre, ou bien de manière récursive.

		%% Cell type:code id:4944b0bb-5f59-41c2-b5d9-052a0d5386dd tags:

		``` python
		def height(root: Node) -> int:
		# YOUR CODE HERE
		raise NotImplementedError()
		```

		%% Cell type:code id:2d11935c-2212-4ec3-ba57-5303ec05b274 tags:

		``` python
		assert height(root) == 2
		assert height(root) == 1
		```

		%% Cell type:markdown id:29fca7e0-aaf9-495b-822d-f20e1a672092 tags:

		Question 1.5 - Valider si l'Arbre est bien équilibré, autrement dit si il n'y a pas de différence de profondeur suppérieur à 1 entre les feuilles d'un arbre.
		Question 1.5 - Ecrivez une fonction de validation afin de déterminer si un Arbre est bien équilibré, autrement dit si il n'y a pas de différence de profondeur suppérieur à 1 entre les feuilles d'un arbre. Conseil : utilisez une approche récursive.

		%% Cell type:code id:3b4f56e8-e4bf-4d27-97eb-b24995d741fe tags:

		``` python
		def est_equlibre(root: Node) -> bool:
		# YOUR CODE HERE
		raise NotImplementedError()
		```

		%% Cell type:code id:69b03c9b-2092-4343-b9e4-7d9904a445b0 tags:

		``` python
		assert est_equlibre(root)
		```

		%% Cell type:markdown id:9e29fddc-c249-4b2a-a9d3-26e56f5474ab tags:

		## Exercice 2 : Arbres syntaxiques

		Un Arbre _syntaxique_ permet le stockage d'une expression structurée, par exemple une équation. Dans cet exercice nous allons modéliser un tel arbre sous forme d'arbre binaire (exemple ci-dessous à gauche) afin de réaliser un calcul arithmétique simple à partir de l'expression fournie de manière textuelle :

		Expression : `(3-2) * (7+(10/2))`

		Résultat : `12.0`

		Nous ferons l'hypothèse que les opérations sont limitées à `+ - / *`, seront toujours binaires et porteront sur des valeurs numériques entières (mais le résultat peut ne pas être un entier).

		```
		*
		/ \
		- +
		/ \ / \
		3 2 7 /
		/ \
		10 2
		```

		Vous utiliserez la structure d'arbre binaire ci-dessous afin de le stocker :
		Vous utiliserez la structure d'arbre binaire ci-dessous afin de stocker l'arbre comme pour l'abre binaire précédent :

		%% Cell type:code id:e78ec913-cd5f-4304-8c8a-438758d909f4 tags:

		``` python
		class Noeud:
		def __init__(self, v = None, g = None, d = None) -> None:
		self.valeur = v
		self.gauche = g
		self.droit = d
		```

		%% Cell type:markdown id:88fbc62f-ae5a-4765-bf8f-bb127f5d5a13 tags:

		Question 2.1 - Utilisez la structure de données d'Arbre ci-dessus afin de stocker l'Arbre syntaxique donné en exemple.
		Question 2.1 - Stockez l'Arbre syntaxique donné en exemple graphique en utilisant la structure de données d'arbre binaire ci-dessus (il s'agit d'écrire une instance d'arbre dans la variable `arbre`, et non une fonction).

		%% Cell type:code id:4661ca46-489c-4330-9e72-64fe25e4b49c tags:

		``` python
		arbre = None # à changer
		# YOUR CODE HERE
		raise NotImplementedError()
		```

		%% Cell type:code id:cee8c8d3-f4ab-4dcc-931e-f0b8681b225c tags:

		``` python
		assert arbre.valeur == "*"
		assert arbre.gauche.valeur == "-"
		assert arbre.droit.valeur == "+"
		```

		%% Cell type:markdown id:0be8aab9-1aba-4340-9235-eb3d1cc7fd29 tags:

		Question 2.2 - Implémenter désormais une méthode d'évaluation (autrement dit de calcul) automatique d'un arbre syntaxique tel que vous l'avez stocké dans la variable `arbre` ci-dessus.
		Question 2.2 - Implémentez désormais une méthode d'évaluation (autrement dit de calcul) automatique d'un arbre syntaxique tel que vous l'avez stocké dans la variable `arbre` ci-dessus.

		Conseil : proposer une solution récursive avec un cas d'arrêt et des appels récursifs comme suit :
		Conseil : proposez une solution récursive avec un cas d'arrêt et des appels récursifs comme suit :
		- si la valeur du noeud en cours est un opérateur, l'appliquer sur les deux sous-branches;
		- si c'est une valeur numérique, renvoyer cette valeur (cas d'arrêt car c'est une feuille de l'arbre)
		- si il s'agit d'une valeur numérique, renvoyez cette valeur (cas d'arrêt car c'est une feuille de l'arbre).

		%% Cell type:code id:dc899d17-67fd-4cc9-bf92-f5f32e08f89e tags:

		``` python
		def eval(r: Noeud) -> float:
		# YOUR CODE HERE
		raise NotImplementedError()
		```

		%% Cell type:code id:00eb3e33-64b1-486f-97c8-d87de80f3a1a tags:

		``` python
		eval(arbre)
		```

		%% Cell type:markdown id:de5c394d-df35-4d7b-b057-164620b0b38d tags:

		Question 2.3 - Écrire une méthode permettant de construire l'Arbre à partir d'une expression fournie sous forme de chaîne de caractère en entrée comme `( ( 3 - 2 ) * ( 7 + ( 10 / 2 ) ) )"`. Les espaces sont nécessaires et vous permettront de faire un `.split(" ")}`.
		Question 2.3 - Écrivez une méthode permettant de construire l'Arbre à partir d'une expression fournie sous forme de chaîne de caractère en entrée comme `( ( 3 - 2 ) * ( 7 + ( 10 / 2 ) ) )`. Les espaces sont nécessaires et vous permettront de faire un `.split(" ")`.

		Conseil :
		- parcourez caractère par caractère l'expression textuelle transformée en liste;
		- créez au fur et à mesure l'arbre initialisé par une racine et une variable stockage le noeud courant en cours de construction
		- identifiez les 4 cas possibles : début d'une expression, valeurs numériques, opérateur, fin d'une expression
		- si une expression commence, créer un nouveau fils gauche au noeud courant et stockez le noeud courant dans une Pile
		- créez au fur et à mesure l'arbre initialisé par une racine et une variable stockage le noeud courant en cours de construction;
		- identifiez les 4 cas possibles : début d'une expression, valeurs numériques, opérateur, fin d'une expression :
		- si une expression commence, créez un nouveau fils gauche au noeud courant et stockez le noeud courant dans une Pile
		- si une expression finie, considérez comme noeud courant l'élément que vous dé-Pilerez
		- si un opérateur, stocker sa valeur dans le noeud courant, empiliez ce noeud mais avant lui rajoute un fils droit qui devient le noeud courant
		- si un opérateur, stockez sa valeur dans le noeud courant, empilez ce noeud mais avant lui rajoute un fils droit qui devient le noeud courant
		- si une valeur numérique, la stocker dans le noeud courant et considérez comme noeud courant l'élément que vous dé-Pilerez

		%% Cell type:code id:1c33faaa-2289-498f-9ef1-5afeb4da4628 tags:

		``` python
		def construit_arbre(exp: str) -> int:
		# YOUR CODE HERE
		raise NotImplementedError()
		```

		%% Cell type:code id:b56d0304-5d23-4e1c-91fb-09b511465ad5 tags:

		``` python
		r = construit_arbre("( ( 3 - 2 ) * ( 7 + ( 10 / 2 ) )")
		```

		%% Cell type:markdown id:89a9015c-dd4e-409d-91b2-9b64b55288e9 tags:

		Enfin vérifiez que vous obtenez la bonne valeur en évaluant l'expression.

		%% Cell type:code id:e5c49c1f-75e0-4872-8578-40a532c7cea1 tags:

		``` python
		assert eval(r) == 12.0
		```

		%% Cell type:markdown id:012a5378-a2b7-498f-8115-e35f55c529ce tags:

		Question 2.4 (Bonus) - - Ecrire une fonction qui renvoie `True` ou `False` si l'Arbre est bien un arbre syntaxique tel que défini en introduction. Autrement dit qu'il est binaire, et comporte des opérateurs partout sauf aux feuilles.
		Question 2.4 (Bonus) - Ecrire une fonction qui renvoie `True` ou `False` si l'Arbre est bien un arbre syntaxique tel que défini en introduction. Autrement dit qu'il est binaire, et comporte des opérateurs partout sauf aux feuilles.

		Proposez une méthode itérative :
		Proposez d'abord une méthode itérative :

		%% Cell type:code id:823d29e7-66c3-41a0-bdad-da6862a5e420 tags:

		``` python
		def valide_ite(r: Noeud) -> bool:
		# YOUR CODE HERE
		raise NotImplementedError()
		```

		%% Cell type:code id:06e73b57-959a-436f-bd7a-e12c615c805c tags:

		``` python
		assert valide_ite(arbre)
		```

		%% Cell type:markdown id:dfdf1d42-60bb-4a7e-9cd4-e6cb72b8130a tags:

		Proposez une méthode récursive :
		Proposez ensuite une méthode récursive :

		%% Cell type:code id:df0033e9-c076-4cde-ab6f-982a3677ce05 tags:

		``` python
		def valide_rec(r: Noeud) -> bool:
		# YOUR CODE HERE
		raise NotImplementedError()
		```

		%% Cell type:code id:9998c852-ec74-4225-9f01-4368899e303f tags:

		``` python
		assert valide_rec(arbre)
		```

		%% Cell type:markdown id:3503e6a5-2bc1-46d2-bef0-d1f1ceb6827e tags:

		Montrez que les deux méthodes ont un comportement identique :

		%% Cell type:code id:81e1b468-5d22-4a25-a2c3-17ab165627e5 tags:

		``` python
		# YOUR CODE HERE
		raise NotImplementedError()
		```

		%% Cell type:markdown id:81842c6c-1784-432b-8322-f3793d633e03 tags:

		Question 2.5 (Bonus) - Créez une table de hachage afin de mémoriser les opérations déja réalisées pour l'Arbre syntaxique. Conseil : utilisez les informations sur le noeud comme clé (valeurs, opérateur).

		%% Cell type:code id:fb91bda6-7076-44be-9014-ceb5507eb01c tags:

		``` python
		def eval_hash(r: Noeud, memo=None) -> float:
		# YOUR CODE HERE
		raise NotImplementedError()
		```

		%% Cell type:code id:22979a11-3455-4525-b816-a84b2164291c tags:

		``` python
		assert eval_hash(arbre) == eval(arbre)
		```

		%% Cell type:markdown id:85c6a3e6-dea0-4e86-b7d9-b0c5735c3630 tags:

		## Pour aller plus loin

		- Rajouter des tests dans les exemples ci-dessus avec des arbres plus complexes, des cas particuliers, etc.
		- Inclure des Exceptions dans votre code afin de gérer par exemple l'accès à un index de liste inexistant, etc.
		- Créer une table de hachage afin de mémoriser les opérations déja réalisées pour l'Arbre syntaxique
		- Inclure des [Exceptions](https://docs.python.org/3/tutorial/errors.html) dans votre code afin de gérer par exemple l'accès à un index de liste inexistant, etc.
		- Modulariser votre code afin de créer des fonctions auxiliaires (par exemple pour vérifier la valeur des noeuds de l'Arbre syntaxique).

		%% Cell type:markdown id:08c48261 tags:

		## Visualiser avec Graphviz

		Graphviz est une bibliothèque de visualisation de graphe. Elle peut être très pratique afin de comprendre la structure de votre instance de graphe.

		Cependant, la bibliothèque pose quelques soucis d'installation en Python, voici des étapes éventuellement à suivre.

		Tout d'abord vérifiez que le module est bien installé :

		%% Cell type:code id:c8c95b89 tags:

		``` python
		!pip install graphviz
		```

		%% Cell type:markdown id:5a9ebd95 tags:

		Si oui (vous avez le message du type `Requirement already satisfied:`) testez l'import du module :

		%% Cell type:code id:e897987f tags:

		``` python
		import graphviz
		from graphviz import Digraph
		```

		%% Cell type:markdown id:2bf9b677 tags:

		Si vous avez des erreurs, essayer l'installation du module à partir des exécutables

		%% Cell type:code id:bd3cfb66 tags:

		``` python
		https://graphviz.org/
		```

		%% Cell type:markdown id:9373f3bc tags:

		Un autre source d'erreur est l'installation à partir de la mauvaise version de Python qu'il faut utiliser avec pip.

		%% Cell type:code id:504eff4a tags:

		``` python
		!python --version
		```

		%% Cell type:code id:5eb4ab77 tags:

		``` python
		from IPython.display import display
		def visualize_oop(root):
		def build(node, dot=None):
		if dot is None:
		dot = graphviz.Digraph(format='png')

		if node is not None:
		dot.node(str(node.value))

		if node.left is not None:
		dot.edge(str(node.value), str(node.left.value))
		build(node.left, dot)

		if node.right is not None:
		dot.edge(str(node.value), str(node.right.value))
		build(node.right, dot)

		return dot

		return build(root)
		```

		%% Cell type:code id:ded5b1fe tags:

		``` python
		visualize_oop(root)
		```

TD04/INF-TC1-td04.ipynb

+35 −40

Original line number	Diff line number	Diff line
		%% Cell type:markdown id:ee8e369b tags:
		%% Cell type:markdown id:f6c54511 tags:

		NAME:

		%% Cell type:markdown id:b97bad7e-82ff-44a7-9779-13c139085623 tags:

		# INF TC1 - TD4 (2h) - Images

		%% Cell type:markdown id:1bb26026-8560-4a3c-90e6-2cfd7a49320a tags:

		---

		%% Cell type:markdown id:99ee8fad-7f32-4fe2-85d3-3b8da49f317f tags:

		<details style="border: 1px">
		<summary> RAPPELS SUR L'UTILISATION DES NOTEBOOKS</summary>

		### Comment utiliser ces notebooks ?

		Le but de votre travail est de répondre aux questions des exercices en remplissant certaines cellules de ce notebook avec votre solution. Ces cellules, une foit remplies et lancées au fur et à mesure de vos avancées, permettront de valider des tests écrits dans d'autres cellules de ce notebook. Il est donc important de bien suivre les instructions et répondre aux questions dans l'ordre, et ne pas changer le nom des fonctions et/ou les cellules. En particulier :

		1) Répondez aux questions dans les cellules en dessous des questions.

		2) Votre code devra remplacer le texte suivant :

		```python
		# YOUR CODE HERE
		raise NotImplementedError()
		```

		(vous pouvez effacer ces deux lignes quand vous les rencontrez mais ne modifiez pas les noms de fonctions sinon les tests ne marchent plus).

		3) Exécuter enfin les cellules dans leur ordre d'apparition, de haut en bas et si votre code est correct alors les tests (sous forme d'`assert` seront validés (ils ne lanceront pas d'exception du type `AssertionError` ). Vous pouvez lancer plusieurs fois la même cellule, cela ne pose pas de soucis.

		4) Vous pouvez créer de nouvelles cellules comme bon vous semble.

		En cas de problème, une solution est de relancer les cellules depuis le début du notebook une par une. Pensez à bien sauvegarder ce notebook et ne pas le remplacer par un notebook qui a le même nom.
		</details>

		%% Cell type:markdown id:d48155b2-8db8-4557-a66b-363351712560 tags:

		## Objectif du TD

		Ce TD vous fera manipuler des images en Python, et réaliser un algorithme de remplissage basé sur le contenu. Nous verrons en particulier la structure de données matricielle et les méthodes de parcours associées. Enfin ce TD sera une préparation au TD 5 qui fera l'objet d'un rendu à réaliser à partir des concepts abordés dans ce TD.
		Ce TD vous fera manipuler des images en Python, et réaliser un algorithme de remplissage basé sur leur contenu (par exemple leur couleur). Nous verrons en particulier la structure de données matricielle et les méthodes de parcours associées. Enfin ce TD sera une préparation au TD 5 qui fera l'objet d'un rendu à réaliser à partir des concepts abordés dans ce TD.

		IMPORTANT : Dans le cadre de ce TD, nous n'autorisons pas l'utilisation des modules [OpenCV](https://docs.opencv.org/4.x/) ou [NumPy](https://numpy.org/) (et concernant le module [Pillow](https://pillow.readthedocs.io/en/stable/) seules celles indiquées sont autorisées).
		IMPORTANT : Dans le cadre de ce TD 4 (mais aussi le prchain TD 5), nous n'autorisons pas l'utilisation de [OpenCV](https://docs.opencv.org/4.x/), [NumPy](https://numpy.org/) ou tout autre module permettant la manipulation et le traitement d'imag. Sauf le module [Pillow](https://pillow.readthedocs.io/en/stable/) mais dont seules quelques fonctions seront autorisées (cela sera indiqué dans les questions).

		%% Cell type:markdown id:647cb3f9-cd85-4bf3-8a18-18262f58041c tags:

		## Exercice 1 : Charger une image et dessiner

		Une image en informatique est stockée sous forme d'une matrice de pixels qui contiennent les couleurs. Le model classique de couleurs est dit "RGB" (Red, Green, Blue) [(doc)](https://fr.wikipedia.org/wiki/Rouge-vert-bleu) où chaque pixel contient une information colorimétrique encodée sous forme de triplets `(r, g, b)` (red, green, blue). Les valeurs de couleur peuvent varier de 0 à 255 pour chaque composante de couleur. Par exemple le rouge est encodé en `(255, 0, 0)`, le gris en `(128, 128, 128)`, etc. Ces couleurs sont organisées en une matrice de dimension égale à celle de l'image, les couleurs sont indépendantes les unes des autres.
		Une image en informatique est stockée sous forme de matrice de pixels qui contiennent les couleurs pour chaque cellule. Le modèle classique de couleurs est dit "RGB" (Red, Green, Blue) [(doc)](https://fr.wikipedia.org/wiki/Rouge-vert-bleu) où chaque pixel contient une information colorimétrique encodée sous forme de triplets `(r, g, b)` (red, green, blue). Les valeurs de couleur peuvent varier de 0 à 255 pour chacune de ces composantes. Par exemple le rouge <span style="display:inline-block;width:15px;height:15px;background-color:rgb(255,0,0);"></span> est encodé en `(255, 0, 0)`, le gris <span style="display:inline-block;width:15px;height:15px;background-color:rgb(128,128,128);"></span> en `(128, 128, 128)`, etc. Ces couleurs sont organisées en une matrice de dimension égale à celle de l'image. Les couleurs sont indépendantes les unes des autres.

		Dans ce TD nous allons utiliser un module Python appelé PIL (Pillow [doc](https://pillow.readthedocs.io/en/stable/)). Ce module permettra de créer et manipuler des images. Il est possible de l'initialiser avec le code ci-dessous en important le module correspondant. Une fois le module importé, vous pourrez charger une image dans une variable `px` dite d'accès de pixel `PixelAccess` [(doc)](https://pillow.readthedocs.io/en/stable/reference/PixelAccess.html). Le module Pillow est normalement installé, si ce n'est pas le cas, vous devez exécuter la commande suivante dans une fenêtre de terminal Anaconda (Menu Démarrer / Anaconda 64bit / Anaconda PowerShell Prompt) : `pip3 install Pillow`.
		Dans ce TD nous allons utiliser un module Python appelé PIL (Pillow [doc](https://pillow.readthedocs.io/en/stable/)) pour créer et manipuler des images. Il est possible de l'initialiser avec le code ci-dessous. Une fois le module importé, vous pourrez charger une image dans une variable `px` dite d'accès de pixel `PixelAccess` [(doc)](https://pillow.readthedocs.io/en/stable/reference/PixelAccess.html). Le module Pillow est normalement installé, si ce n'est pas le cas, vous devez exécuter la commande suivante dans une fenêtre de terminal Anaconda (Menu Démarrer / Anaconda 64bit / Anaconda PowerShell Prompt) : `pip install Pillow`. Si vous l'installer dans un notebook même utilisez la commande `!pip install Pillow`.

		Pour tester si le module est présent sur votre ordinateur, charger une image comme suit :

		%% Cell type:code id:5a97d177-3289-451f-bb64-3d97ad023cd4 tags:

		``` python
		from PIL import Image
		from IPython.display import display

		im = Image.open("lyon.png")
		im = im.convert("RGB") # important pour bien avoir 3 couleurs
		px = im.load()

		W, H = im.size # taille de l'image
		r, g, b = px[10, 20] # on récupère un pixel
		px[10, 21] = r, g, b # on change un pixel

		im = im.resize((W//2, H//2))

		display(im) # on affiche l'image dans la cellule
		# im.show() # on affiche l'image si vous n'utilisez pas de notebook
		```

		%% Cell type:markdown id:c2a6f43f-7d5d-46ff-85cb-37d0fb717c85 tags:

		Vous pouvez également créer une nouvelle image `im2` vide (noire) de taille identique à `im` :

Compare revisions

Source

Target

Commits on Source 11

Files

TD01/BE1-INF-TC1-22-23-version-eleves.pdf

TD01/BE1-INF-TC1-23-24-eleves.pdf

TD01/BE1-INF-TC1-25-26-Eleves.pdf

TD02/INF-TC1-td02.ipynb

TD03/INF-TC1-td03.ipynb

TD04/INF-TC1-td04.ipynb