" tuple: visited pixels, not visited pixels, unique colors used\n",
" \"\"\"\n",
" # YOUR CODE HERE\n",
" raise NotImplementedError()"
]
...
...
@@ -539,7 +593,7 @@
"id": "057fa44d-2c9f-423c-af12-16731b401884",
"metadata": {},
"source": [
"**Question 2.1 -** Écrire une fonction de conversion d'image en niveaux de gris (soit la moyenne des triplets `(r,b,g)` ou en utilisant la formule suivante : \n",
"**Question 2.1 -** Écrire une fonction de conversion d'image en niveaux de gris (soit la moyenne des triplets `(r,g,b)` ou en utilisant la formule suivante : \n",
<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
raiseNotImplementedError()
```
(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.
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 et du code abordés.
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/)(ou toute fonction de [Pillow](https://pillow.readthedocs.io/en/stable/) sauf celles indiquées).
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 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 également de créer des images. Il est possible de l'initialiser comme suit pour 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`.
Pour tester sur le module est présent sur votre ordinateur, charger une image comme suit :
**Question 1.1 -** Définissez une fonction de lecture qui renvoie la couleur d'un pixel à la position $(x, y)$ d'une image donnée. Inspirez vous du code précédent ou de la documentation Pillow [(doc)](https://pillow.readthedocs.io/en/stable/)).
Afin de vérifier visuellement votre résultat, nous vous fournissons la fonction `draw_rectangle` qui permet de dessiner la couleur d'un pixel dans une cellule :
**Question 1.2 -** Définissez une fonction d'écriture d'un pixel à une position $(x, y)$ d'une image avec une couleur donnée en argument sous forme de `tuple` $(r, g, b)$.
**Question 1.3 -** Écrire une fonction permettant de peindre un rectangle de l'image avec une même couleur. Coloriez avec la couleur moyenne de cette région (et donc définir une fonction qui calcule cette couleur `moyenne`).
Nous allons maintenant réaliser un remplissage un peu plus intéressant de l'image à partir de son contenu (dans notre cas nous nous baserons sur les couleurs contenues dans l'image).
**Question 1.4 -** Ecrire une fonction de calcul de [distance Euclidienne](https://fr.wikipedia.org/wiki/Distance_(math%C3%A9matiques)) entre deux couleurs RGB (Red, Green, Blue) $C_1$ et $C_2$ comme suit :
**Question 1.5 -** Nous allons désormais travailler sur une méthode de remplissage de région basée sur l'homogénéité des couleurs dans la région. Pour cela nous allons ré-utiliser les méthodes ci-dessus en particulier la distance Euclidenne, en utilisant l'algorithme dit de _flood fill_ [(doc)](https://en.wikipedia.org/wiki/Flood_fill) et qui fonctionne comme suit :
1. Charger une image et initialiser deux listes vides : une liste de pixels à visiter et une liste de pixels déjà visités
2. Définir un pixel de départ $p_{(x, y)}$ et le rajouter dans la liste de pixels à visiter
3. Extraire un pixel $p_{(i, j)}$ de la liste des pixels à visiter, il constituera la couleur $c_{(i, j)}$ de la région homogène et le rajouter dans une troisième liste de pixels homogènes à colorier avec cette couleur
4. Tant que la liste de pixels homogènes n'est pas vide, extraire un pixel de cette liste :
- Colorier le pixel avec la couleur $c_{(i, j)}$ et le rajouter dans la liste des pixels visités
- Explorer les 4 voisins autour du pixel (haut, bas, gauche, droite) et pour chaque voisin :
- Si la couleur du voisin est en dessous d'un seuil d'homogénéité alors l'inclure dans la liste de pixels homogènes
- Sinon rajouter le pixel dans la liste de pixels à visiter
- Répéter cela tant que la liste de pixels homogènes n'est pas vide
5. Répéter cela tant que la liste des pixels non visités n'est pas vide
Le résultat attendu est une image remplie coloriée avec un nombre de couleur inférieur au nombre initial de couleurs.
Nous allons aborder un deuxième aspect de manipulation d'image : le traitement d'image, afin d'en extraire des informations intéressantes (contours, formes, etc.). En particulier nous allons créer différents _filtres_ dont le but sera de transformer les valeurs des pixels afin de par exemple réduire le bruit que les images peuvent contenir (à savoir les variations locales de valeur).
La plupart de ces méthodes étant couteuses en temps, nous travaillerons sur une version en niveau de gris.
**Question 2.1 -** Écrire une fonction de conversion d'image en niveaux de gris (soit la moyenne des triplets `(r,b,g)` ou en utilisant la formule suivante :
**Question 2.1 -** Écrire une fonction de conversion d'image en niveaux de gris (soit la moyenne des triplets `(r,g,b)` ou en utilisant la formule suivante :
Nous commençon avec le filtre dit de _Flou Gaussien_, basé sur une opération dite de _convolution_, permettant d'appliquer une fonction de distribution gaussienne aux voisins d'un pixel et d'en faire la moyenne. Autrement dit il s'agira de réaliser la moyenne pondérée de chaque pixel en réalisant la moyenne du pixel et de ses voisins en utilisant par exemple la matrice ci-dessous (dont les valeurs sont définies par la distribution gaussienne donnée en annexe pour une matrice $3 \times 3$) :
**Question 2.2 -** Implémentez le filtre gaussien tel que défini ci-dessus en définissant les filtres donnés ci-dessous. La fonction doit effectuer la multiplication des pixels centrés sur le pixel en cours avec les valeurs de la matrice, puis la somme pondérée. Vous pourrez utiliser les matrices ci-dessus d'approximation du filtre (en commençant par le filtre Gaussien $3 \times 3$ dont le total des valeurs est $16$). Utilisez la version de l'image en niveaux de gris afin de simplifier les traitements.
Commencez tout d'abord par définir une fonction qui calcul la somme des valeurs d'une matrice (de type `gauss3`).
Ecrire la fonction de convolution. Pensez à prendre en compte les bords de l'image. Conseil : ne vous approchez pas trop du bord afin de ne pas réaliser une convolution en dehors de l'image.
**Question 2.3 -** Testez votre code avec ces filtres ci-dessous avec un facteur de normalisation/pondération de 1 : que se passe-t-il ? [(doc)](https://en.wikipedia.org/wiki/Kernel_(image_processing)).
