diff --git a/TD04/INF-TC1-td04.ipynb b/TD04/INF-TC1-td04.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..c848deb001506b410c785c86d4de5381f2633886
--- /dev/null
+++ b/TD04/INF-TC1-td04.ipynb
@@ -0,0 +1,847 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "918b7e37",
+ "metadata": {},
+ "source": [
+ "NAME:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b97bad7e-82ff-44a7-9779-13c139085623",
+ "metadata": {},
+ "source": [
+ "# INF TC1 - TD4 (2h) - Images"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1bb26026-8560-4a3c-90e6-2cfd7a49320a",
+ "metadata": {},
+ "source": [
+ "---"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "99ee8fad-7f32-4fe2-85d3-3b8da49f317f",
+ "metadata": {},
+ "source": [
+ "<details style=\"border: 1px\">\n",
+ "<summary> RAPPELS SUR L'UTILISATION DES NOTEBOOKS</summary>\n",
+ "\n",
+ "### Comment utiliser ces notebooks ?\n",
+ "\n",
+ "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 :\n",
+ " \n",
+ "1) Répondez aux questions dans les cellules en dessous des questions.\n",
+ "\n",
+ "2) Votre code devra remplacer le texte suivant : \n",
+ "\n",
+ "```python\n",
+ "# YOUR CODE HERE\n",
+ "raise NotImplementedError()\n",
+ "```\n",
+ "\n",
+ "(vous pouvez effacer ces deux lignes quand vous les rencontrez mais ne modifiez pas les noms de fonctions sinon les tests ne marchent plus).\n",
+ "\n",
+ "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.\n",
+ " \n",
+ "4) Vous pouvez créer de nouvelles cellules comme bon vous semble.\n",
+ "\n",
+ "**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.\n",
+ "</details>"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d48155b2-8db8-4557-a66b-363351712560",
+ "metadata": {},
+ "source": [
+ "## Objectif du TD\n",
+ "\n",
+ "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. \n",
+ "\n",
+ "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).\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "647cb3f9-cd85-4bf3-8a18-18262f58041c",
+ "metadata": {},
+ "source": [
+ "## Exercice 1 : Charger une image et dessiner\n",
+ "\n",
+ "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.\n",
+ "\n",
+ "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`.\n",
+ "\n",
+ "Pour tester sur le module est présent sur votre ordinateur, charger une image comme suit :"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5a97d177-3289-451f-bb64-3d97ad023cd4",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "from PIL import Image\n",
+ "from IPython.display import display\n",
+ "\n",
+ "im = Image.open(\"lyon.png\")\n",
+ "px = im.load() \n",
+ "\n",
+ "W, H = im.size # taille de l'image\n",
+ "r, g, b = px[10, 20] # on récupère un pixel\n",
+ "px[10, 21] = r, g, b # on change un pixel\n",
+ "\n",
+ "im = im.resize((W//2, H//2))\n",
+ "\n",
+ "display(im) # on affiche l'image dans la cellule\n",
+ "# im.show() # on affiche l'image si vous n'utilisez pas de notebook"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c2a6f43f-7d5d-46ff-85cb-37d0fb717c85",
+ "metadata": {},
+ "source": [
+ "Vous pouvez également créer une **nouvelle image** `im2` vide (noire) de taille identique à `im` :"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "11e98fc1-9f60-476b-909b-d632d802f3f4",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "im2 = Image.new('RGB', (im.width, im.height)) \n",
+ "px2 = im2.load()\n",
+ "display(im2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "482f0b25-342e-403c-975b-65a42283e1cc",
+ "metadata": {},
+ "source": [
+ "**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/))."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "567ca46f-9a29-44da-93a0-9f3992f39b03",
+ "metadata": {
+ "deletable": false,
+ "nbgrader": {
+ "cell_type": "code",
+ "checksum": "f498d16eb464fc9d943f9c4a474fa9ef",
+ "grade": false,
+ "grade_id": "cell-04652e636c091bef",
+ "locked": false,
+ "schema_version": 3,
+ "solution": true,
+ "task": false
+ },
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "def getPixel(x: int, y: int, px) -> tuple:\n",
+ " # YOUR CODE HERE\n",
+ " raise NotImplementedError()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "08846407-027f-4b9e-86c7-43cce4234cd6",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "assert getPixel(0, 0, px) == (69, 119, 170) # bleu\n",
+ "assert getPixel(0, 0, px2) == (0, 0, 0) # noir"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "49116049-3a09-4415-84c7-e71c6ea85c55",
+ "metadata": {},
+ "source": [
+ "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 :"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b2098f50-57c2-4c4b-9a07-b695103590fa",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "from IPython.display import display, HTML\n",
+ "\n",
+ "def draw_rectangle(rgb_color):\n",
+ " color = f'rgb({rgb_color[0]}, {rgb_color[1]}, {rgb_color[2]})'\n",
+ " html = f'<svg width=\"100\" height=\"100\"><rect width=\"100\" height=\"100\" fill=\"{color}\" /></svg>'\n",
+ "\n",
+ " display(HTML(html))\n",
+ "# utilisation : draw_rectangle((69, 119, 170)) "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c02ced7f-22bb-41c0-83d8-e91485dc4c5c",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "draw_rectangle(getPixel(0, 0, px)) # bleu"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "aa9391e7-8623-4c7e-9865-99ce35dc8683",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "draw_rectangle(getPixel(0, 0, px2)) # noir"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "69c1f988-3e28-45a7-a6c2-e0a7075c19f6",
+ "metadata": {},
+ "source": [
+ "**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)$."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "df54ba88-6681-4eaa-9608-20c8d8db67ae",
+ "metadata": {
+ "deletable": false,
+ "nbgrader": {
+ "cell_type": "code",
+ "checksum": "5bd8bb5e0f60872037ff81bb1b945865",
+ "grade": false,
+ "grade_id": "cell-efbe1bd53dfaf01f",
+ "locked": false,
+ "schema_version": 3,
+ "solution": true,
+ "task": false
+ },
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "def setPixel(x: int, y:int, color: tuple, px) -> None:\n",
+ " # YOUR CODE HERE\n",
+ " raise NotImplementedError()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ab0b00f6-5a33-4da0-a97e-5ce74e827122",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "r, g, b = (0, 0, 0)\n",
+ "setPixel(0, 0, (r, g, b), px2)\n",
+ "assert getPixel(0, 0, px2) == (r, g, b)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a46817a7-f6be-4f1b-b79f-0347669844cc",
+ "metadata": {},
+ "source": [
+ "**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`)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "1583490b-8d8a-4dab-94df-05281ebc668c",
+ "metadata": {
+ "deletable": false,
+ "nbgrader": {
+ "cell_type": "code",
+ "checksum": "48417c6001845feccd44c50c46c20bca",
+ "grade": false,
+ "grade_id": "cell-f7def1afc171201e",
+ "locked": false,
+ "schema_version": 3,
+ "solution": true,
+ "task": false
+ },
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "def moyenne(corner_x, corner_y, region_w, region_h, px) -> tuple: \n",
+ " # YOUR CODE HERE\n",
+ " raise NotImplementedError()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "913c742d-04ba-4220-adce-861bf39d999d",
+ "metadata": {},
+ "source": [
+ "Dans la fonction de dessin de région `setRegion`la variable `color` contient le triplet de couleurs à utiliser."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a7ba398a-bf70-4c70-83d2-28c55bdf2762",
+ "metadata": {
+ "deletable": false,
+ "nbgrader": {
+ "cell_type": "code",
+ "checksum": "6eb254f46f4157537e2ccb9bd822bc50",
+ "grade": false,
+ "grade_id": "cell-d04057cb7104c7e7",
+ "locked": false,
+ "schema_version": 3,
+ "solution": true,
+ "task": false
+ },
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "def setRegion(x, y, w, h, color, px) -> None:\n",
+ " # YOUR CODE HERE\n",
+ " raise NotImplementedError()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "02374e5a-e9d5-4689-88dd-b2d53738c13d",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "assert moyenne(0, 0, 1, 1, px2) == (0.0, 0.0, 0.0) # région noire"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6e7ce82a-7fd9-4c4d-b76d-17f96da87cd5",
+ "metadata": {},
+ "source": [
+ "Le code ci-dessous doit dessiner un rectangle blanc au milieu d'une image noire."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6b9fbf24-ac6a-4b08-a633-fd9a6bc4708f",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "im2 = Image.new('RGB', (im.width, im.height)) \n",
+ "px2 = im2.load()\n",
+ "W, H = im.size\n",
+ "setRegion(W//3, H//3, W//3, H//3, (255, 255, 255), px2)\n",
+ "display(im2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "38f3a987-f93a-4119-a1fa-d87eaf55f9d1",
+ "metadata": {},
+ "source": [
+ "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)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "daa5c6f4-eabc-4f00-8d32-86d5695af06b",
+ "metadata": {},
+ "source": [
+ "**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 :\n",
+ "\n",
+ "$d_{\\text{euclidienne}} = \\sqrt{(R_2 - R_1)^2 + (G_2 - G_1)^2 + (B_2 - B_1)^2}$\n",
+ "\n",
+ "Attention il s'agit de distances _entre_ les couleurs à comparer et non pas la distance entre les positions des pixels. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9be2d008-74fd-4f97-bdaf-d88525142f95",
+ "metadata": {
+ "deletable": false,
+ "nbgrader": {
+ "cell_type": "code",
+ "checksum": "6496e3ce4dce17684ee4fd197b232c8c",
+ "grade": false,
+ "grade_id": "cell-ee98beb234607988",
+ "locked": false,
+ "schema_version": 3,
+ "solution": true,
+ "task": false
+ },
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "def distance(c1: tuple, c2: tuple) -> float: \n",
+ " # YOUR CODE HERE\n",
+ " raise NotImplementedError()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f673184f-81f9-4172-ac4f-58e6cccceffc",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "assert distance((0, 0, 0), (0, 0, 0)) == 0.0"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3e09490e-9955-4639-b149-53c16855e8df",
+ "metadata": {},
+ "source": [
+ "**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 :\n",
+ "\n",
+ "1. Charger une image et initialiser deux listes vides : une liste de pixels à visiter et une liste de pixels déjà visités\n",
+ "2. Définir un pixel de départ $p_{(x, y)}$ et le rajouter dans la liste de pixels à visiter\n",
+ "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 \n",
+ "4. Tant que la liste de pixels homogènes n'est pas vide, extraire un pixel de cette liste :\n",
+ " \n",
+ " - Colorier le pixel avec la couleur $c_{(i, j)}$ et le rajouter dans la liste des pixels visités\n",
+ " - Explorer les 4 voisins autour du pixel (haut, bas, gauche, droite) et pour chaque voisin :\n",
+ " - 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\n",
+ " - Sinon rajouter le pixel dans la liste de pixels à visiter\n",
+ " - Répéter cela tant que la liste de pixels homogènes n'est pas vide\n",
+ "\n",
+ "5. Répéter cela tant que la liste des pixels non visités n'est pas vide\n",
+ "\n",
+ "Le résultat attendu est une image remplie coloriée avec un nombre de couleur inférieur au nombre initial de couleurs."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7dfc1c84-e0ca-49d1-b089-8a23175f715f",
+ "metadata": {
+ "deletable": false,
+ "nbgrader": {
+ "cell_type": "code",
+ "checksum": "9310ca392be9f496e8e6178ffe540e5e",
+ "grade": false,
+ "grade_id": "cell-d91af81641547e03",
+ "locked": false,
+ "schema_version": 3,
+ "solution": true,
+ "task": false
+ },
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "def floodFill(w: int, h: int, start_x: int, start_y: int, c: tuple, s, px, px2) -> tuple:\n",
+ " # YOUR CODE HERE\n",
+ " raise NotImplementedError()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1a50b940-d3b5-4dd5-9b9f-cd4977c9bc24",
+ "metadata": {},
+ "source": [
+ "Le code ci-dessous va tester votre solution avec une image fournie et générer quelques statistiques liés au nombre de couleurs utilisées."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "102f2245-a8ce-41d6-9250-e163c96bb952",
+ "metadata": {
+ "deletable": false,
+ "nbgrader": {
+ "cell_type": "code",
+ "checksum": "3187f59d155b1700ea7421e782c4add3",
+ "grade": false,
+ "grade_id": "cell-32e6741733c43cfb",
+ "locked": false,
+ "schema_version": 3,
+ "solution": true,
+ "task": false
+ },
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "# YOUR CODE HERE\n",
+ "raise NotImplementedError()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e2eb0bd7-ef80-41fd-8aba-2460de5b6ad4",
+ "metadata": {},
+ "source": [
+ "## Pour aller plus loin\n",
+ "\n",
+ "- Tester le remplissage dans 8 directions (en prenant en compte les diagonales) au moyen dans la fonction d'exploration de voisinage des pixels."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0e3f9555-c2fe-4c68-b4cd-b659b928755e",
+ "metadata": {},
+ "source": [
+ "## Exercice 2 : Traitement d'image par filtre\n",
+ "\n",
+ "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).\n",
+ "\n",
+ "La plupart de ces méthodes étant couteuses en temps, nous travaillerons sur une version en niveau de gris."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "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",
+ "\n",
+ "$ C_{gray} = (0.3 \\times R) + (0.59 \\times G) + (0.11 \\times B)$"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "cee93e0f-a63b-4a19-87e7-00c736191465",
+ "metadata": {
+ "deletable": false,
+ "nbgrader": {
+ "cell_type": "code",
+ "checksum": "d3e4d4870ab66142ecb8014b95f6a112",
+ "grade": false,
+ "grade_id": "cell-c87026ba248b1c44",
+ "locked": false,
+ "schema_version": 3,
+ "solution": true,
+ "task": false
+ },
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "def conversion_gris(px, W: int, H: int) -> None:\n",
+ " # YOUR CODE HERE\n",
+ " raise NotImplementedError()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4828de37-3b06-48f6-b32a-6d6e53285787",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "im = Image.open(\"lyon.png\")\n",
+ "px = im.load()\n",
+ "W, H = im.size\n",
+ "conversion_gris(px, W, H)\n",
+ "display(im)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1f8656cb-ec1f-4ce3-a837-2b938e36f1e5",
+ "metadata": {},
+ "source": [
+ "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$) :\n",
+ "\n",
+ "$G(x) = \\frac{1}{\\sqrt[]{2 \\pi } \\sigma} e^{- \\frac{x^{2}}{2 \\sigma ^{2}}}$"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9faad901-6b61-4011-be8e-55d85d3b7ded",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "gauss3 = [[1,2,1],\n",
+ " [2,4,2],\n",
+ " [1,2,1]]\n",
+ "\n",
+ "gauss7 = [[1,1,2,2,2,1,1],\n",
+ " [1,2,2,4,2,2,1],\n",
+ " [2,2,4,8,4,2,2],\n",
+ " [2,4,8,16,8,4,2],\n",
+ " [2,2,4,8,4,2,2],\n",
+ " [1,2,2,4,2,2,1],\n",
+ " [1,1,2,2,2,1,1]]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d90ad339-06fc-4423-a302-034c1d872301",
+ "metadata": {},
+ "source": [
+ "**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.\n",
+ "\n",
+ "Commencez tout d'abord par définir une fonction qui calcul la somme des valeurs d'une matrice (de type `gauss3`)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "06cd5d47-9fde-4b0f-a833-b7ce415e6349",
+ "metadata": {
+ "deletable": false,
+ "nbgrader": {
+ "cell_type": "code",
+ "checksum": "0e68fa31a225405b072b56d4c7d89ff2",
+ "grade": false,
+ "grade_id": "cell-b981c9962ee28826",
+ "locked": false,
+ "schema_version": 3,
+ "solution": true,
+ "task": false
+ },
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "def somme_matrice(m: list = []) -> list:\n",
+ " # YOUR CODE HERE\n",
+ " raise NotImplementedError()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f02e6ba8-d870-40e0-8ed9-67b35ef12e57",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "assert somme_matrice(gauss3) == 16"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c0030b8b-159b-463d-a830-d6d554e6382b",
+ "metadata": {
+ "tags": []
+ },
+ "source": [
+ "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."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "0c295c65-4e2c-4751-91a8-cb8108e18ba2",
+ "metadata": {
+ "deletable": false,
+ "nbgrader": {
+ "cell_type": "code",
+ "checksum": "5d4784796f5d6b78482313918a6ae340",
+ "grade": false,
+ "grade_id": "cell-df57a2a4e3cc7c55",
+ "locked": false,
+ "schema_version": 3,
+ "solution": true,
+ "task": false
+ },
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "def convolution(px, W: int, H: int, m: list) -> None:\n",
+ " # YOUR CODE HERE\n",
+ " raise NotImplementedError()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "726a449a-e975-4647-9f57-e31f3581124d",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "im = Image.open(\"lyon.png\")\n",
+ "px = im.load()\n",
+ "W, H = im.size\n",
+ "conversion_gris(px, W, H)\n",
+ "convolution(px, W, H, gauss3)\n",
+ "display(im)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "746bd3e7-f8fc-4ed2-a89b-2b4e52d6ace1",
+ "metadata": {},
+ "source": [
+ "Vous pouvez comparer votre floutage avec celui de PIL :"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "513a179c-89bc-43e6-87e2-ca033ffee304",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "from PIL import Image, ImageFile, ImageDraw, ImageChops, ImageFilter\n",
+ "_im = im.filter(ImageFilter.GaussianBlur)\n",
+ "display(_im)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7bb648b1-450b-4bd9-b52a-c798107d6079",
+ "metadata": {},
+ "source": [
+ "**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))."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f213b45e-768f-4d89-b456-f12050a3217c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sobely3 = [[-1, 0, 1],\n",
+ " [-2, 0, 2],\n",
+ " [-1, 0, 1]]\n",
+ "\n",
+ "sobelx3 = [[-1, -2, -1],\n",
+ " [0, 0, 0],\n",
+ " [1, 2, 1]]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "760d4ca7-5f31-457f-8b09-6e0dfc12c7a8",
+ "metadata": {
+ "deletable": false,
+ "nbgrader": {
+ "cell_type": "code",
+ "checksum": "fcf17710112f87fbf19504dc787bdf6c",
+ "grade": false,
+ "grade_id": "cell-998bb8c6562b7351",
+ "locked": false,
+ "schema_version": 3,
+ "solution": true,
+ "task": false
+ },
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "def convolution_sobel(px, W: int, H: int, m: list, f=1) -> None:\n",
+ "# YOUR CODE HERE\n",
+ "raise NotImplementedError()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "42dfddf2-9bc0-4922-9747-527cf07af6e7",
+ "metadata": {},
+ "source": [
+ "## Pour aller plus loin\n",
+ "\n",
+ "- Comparez vos méthodes avec les modules [OpenCV](https://docs.opencv.org/4.x/) ou [NumPy](https://numpy.org/).\n",
+ "- Implémentez une fonction de calcul de distance entre la couleur choisie et la couleur initiale."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6ba4c207-a3a1-48d0-9031-9a247b4663c7",
+ "metadata": {
+ "deletable": false,
+ "nbgrader": {
+ "cell_type": "code",
+ "checksum": "5bc1ac1225a7da71dbfe12f84d418fcd",
+ "grade": false,
+ "grade_id": "cell-54b9917c32dd200a",
+ "locked": false,
+ "schema_version": 3,
+ "solution": true,
+ "task": false
+ },
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "def difference(px, px2):\n",
+ " # YOUR CODE HERE\n",
+ " raise NotImplementedError()"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.10.9"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/TD04/lyon.png b/TD04/lyon.png
new file mode 100755
index 0000000000000000000000000000000000000000..25d0c6fc917a70d814c2796af1d3756ed24681a8
Binary files /dev/null and b/TD04/lyon.png differ
diff --git a/TD05/INF-TC1-td05.ipynb b/TD05/INF-TC1-td05.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..5c2fdff50f0a5282cbc825da65df0bf771044840
--- /dev/null
+++ b/TD05/INF-TC1-td05.ipynb
@@ -0,0 +1,221 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "5454a371",
+ "metadata": {},
+ "source": [
+ "NAME:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b97bad7e-82ff-44a7-9779-13c139085623",
+ "metadata": {},
+ "source": [
+ "# INF TC1 - TD5 (2h) - Devoir à rendre #1"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1bb26026-8560-4a3c-90e6-2cfd7a49320a",
+ "metadata": {},
+ "source": [
+ "---"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "dd8d4905-55f9-4957-8008-a963cc6de061",
+ "metadata": {},
+ "source": [
+ "Vous serez évalué sur le rendu de ce TD qui sera à déposer sur Moodle **deux (2) semaines** après les séances d'autonomie et de TD. Le rendu sera à réaliser sous forme de **notebook** qui contient votre code et images."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "99ee8fad-7f32-4fe2-85d3-3b8da49f317f",
+ "metadata": {},
+ "source": [
+ "<details style=\"border: 1px\">\n",
+ "<summary> MODALITES DE RENDU</summary>\n",
+ "\n",
+ "### Comment rendre son devoir ?\n",
+ "\n",
+ "Vous serez évalué sur le rendu de ce TD qui sera à déposer sur Moodle **deux (2) semaines** après les séances d'autonomie et de TD. Vous devrez créer une archive (zip, rar, etc.) nomée `nom1-nom2-inf-tc1-td5.zip` qui contiendra tous les éléments de votre rendu (rapport en notebook, code, images de test). Vous pouvez rendre ce rapport seul ou en binôme. Le rendu du TD doit contenir a minima :\n",
+ "\n",
+ "1. Toutes les étapes jusqu'à la 6ème doivent avoir été abordées\n",
+ "2. Justifications, illustrations et tests sur plusieurs images\n",
+ "\n",
+ "**A garder en tête :**\n",
+ "\n",
+ "- Un code fonctionnel et les tests appropriés devront être fournis dans l'archive qui doit être autonome (le correcteur ne doit pas avoir à rajouter d'image ou de fichier supplémentaire)\n",
+ "\n",
+ "- Vous fournirez les images de test et leurs résultats; évitez cependant de prendre des tailles d'images trop importantes.\n",
+ "\n",
+ "- Le rapport **devra être au format Notebook Jupyter** et comprendre :\n",
+ "\n",
+ " - Le détail des étapes que vous avez suivies\n",
+ "\n",
+ " - La description de parties de code difficiles\n",
+ "\n",
+ " - Tout souci ou point bloquant dans votre code\n",
+ "\n",
+ " - Les graphiques et diagrammes nécessaires\n",
+ "\n",
+ " - Des analyses et discussions en lien avec votre approche\n",
+ "\n",
+ " - Des exemples simples mais aussi difficiles\n",
+ "\n",
+ "**Tout travail supplémentaire (méthode originale, optimisation poussée) fera l'objet de points en bonus.**\n",
+ "\n",
+ " \n",
+ " \n",
+ "*Voici une suggestion afin de se faire un ordre d'idée*\n",
+ "\n",
+ "En dessous de 10 :\n",
+ "\n",
+ "- Les étapes suivies\n",
+ "- Un code fonctionnel et les méthodes basiques\n",
+ "- Un rapport de quelques pages\n",
+ "- Un code certes fonctionnel mais peu commenté\n",
+ "- Les exemples d'images fournies\n",
+ "\n",
+ "Un groupe avec une note entre 10 et 12 :\n",
+ "\n",
+ "- Les étapes suivies\n",
+ "- Un code fonctionnel et les méthodes basiques\n",
+ "- Un rapport de quelques pages\n",
+ "- Un code certes fonctionnel mais peu commenté\n",
+ "- Les exemples d'images fournies\n",
+ "\n",
+ "Un groupe entre 12 et 14 a en plus proposé :\n",
+ "\n",
+ "- Des structures de données avancées (Set, Files, etc)\n",
+ "- Une justification de chaque étape\n",
+ "- Une méthode un petit peu plus poussée\n",
+ "\n",
+ "Un groupe entre 14 et 16 a en plus proposé :\n",
+ "\n",
+ "- Une méthode originale (K-Means, etc)\n",
+ "- Une démarche expérimentale très détaillée sur les optimisations\n",
+ "- Des tests plutôt originaux\n",
+ "\n",
+ "Un groupe au-dessus de 16 comporte une ou plusieurs parties exceptionnelles :\n",
+ "\n",
+ "- Rapport très détaillé et exemplaire sur le fond comme sur la forme\n",
+ "- Une démarche expérimentale très détaillée sur les optimisations\n",
+ "- Code et tests\n",
+ "\n",
+ "\n",
+ "\n",
+ "</details>"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d48155b2-8db8-4557-a66b-363351712560",
+ "metadata": {},
+ "source": [
+ "## Objectif du devoir\n",
+ "\n",
+ "Le but de ce devoir est de **déterminer automatiquement une palette de couleurs optimale** pour une image donnée. Cette palette devra valider les contraintes suivantes : \n",
+ "\n",
+ "1. de taille réduite par rapport au nombre initial de couleurs\n",
+ "2. la plus représentative possible des couleurs initiales. \n",
+ "\n",
+ "En effet une image affichée sur un ordinateur peut être encodée sur 8 bits par composantes rouge, verte et bleue (soit 256 valeurs possibles par composante) ainsi potentiellement utiliser $256 \\times 256 \\times 256 = 16 777 216$ couleurs. En réalité, beaucoup moins sont utilisées et surtout perceptibles par l'humain. Réduire le nombre de couleur ou réaliser une \"_quantification de couleurs_\" est une tâche fréquente et c'est une fonctionnalité classique des outils éditeurs d'images (Photoshop, Gimp, etc.) implémentée aussi dans le module Pillow de Python. A noter que cette réduction s'effectue avec perte de couleurs et doit être réalisée avec les bons paramètres (nombre et choix des couleurs) ce qui est votre objectif. \n",
+ "\n",
+ "La figure ci-dessous illustre le problème à résoudre : étant donnée une image en entrée, proposer une liste de couleurs (que l'on appellera la palette), afin de re-colorier une image en sortie.\n",
+ "\n",
+ "<div style=\"text-align:center;\">\n",
+ "<table>\n",
+ " <tr>\n",
+ " <td>\n",
+ " <img src=\"figures/color-rainbow.png\" alt=\"Image originale\" style=\"height:5cm;\">\n",
+ " <p>Image originale</p>\n",
+ " </td>\n",
+ " <td>\n",
+ " <img src=\"figures/rainbow-palette-8.png\" alt=\"Palette de 8 couleurs représentatives\" style=\"height:5cm;\">\n",
+ " <p>Palette de 8 couleurs représentatives</p>\n",
+ " </td>\n",
+ " <td>\n",
+ " <img src=\"figures/rainbow-recoloriee.png\" alt=\"Image originale recoloriée avec la palette\" style=\"height:5cm;\">\n",
+ " <p>Image originale recoloriée avec la palette</p>\n",
+ " </td>\n",
+ " </tr>\n",
+ "</table>\n",
+ "</div>\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fd464e65-adfe-4e11-bf87-f12c513fbaea",
+ "metadata": {},
+ "source": [
+ "## Étapes de travail\n",
+ "\n",
+ "Voici des étapes de travail suggérées :\n",
+ "\n",
+ "1. Prendre en main une image de votre choix (pas trop grande) en la chargeant avec PIL. Lister les couleurs présentes, identifier celles qui sont uniques et leur fréquence. Vous pouvez pour cela utiliser [Matplotlib](https://matplotlib.org/stable/gallery/index.html).\n",
+ "\n",
+ "2. Proposer une méthode (naïve pour commencer) de choix d'une palette de $k$ couleurs. Affichez là sous forme d'image (exemple de d'image au milieu de la figure du dessus) avec une nouvelle image PIL. Utilisez également des images simples où le résultat attendu est connu comme mour les images ci-dessous :\n",
+ "\n",
+ " <div style=\"text-align:center;\">\n",
+ " <table>\n",
+ " <tr>\n",
+ " <td>\n",
+ " <img src=\"figures/1-color-back.png\" alt=\"1 couleur noir\" style=\"width:3cm;\">\n",
+ " <p>1 couleur noir</p>\n",
+ " </td>\n",
+ " <td>\n",
+ " <img src=\"figures/4-color.png\" alt=\"4 couleurs\" style=\"width:3cm;\">\n",
+ " <p>4 couleurs</p>\n",
+ " </td>\n",
+ " </tr>\n",
+ " </table>\n",
+ " </div>\n",
+ " \n",
+ "3. Re-colorier une image avec une palette de $k$ couleurs, et afficher le résultat sous forme d'image PIL. Pour re-colorier chaque pixel, prendre la couleur la plus proche dans la palette en utilisant une fonction de distance (Euclidienne par exemple).\n",
+ "\n",
+ "4. Proposer une méthode de validation de votre approche. Par exemple afficher la différence entre l'image originale et celle re-coloriée. Calculer un score global d'erreur.\n",
+ "\n",
+ "5. Améliorer le choix des $k$ couleurs afin de minimiser l'erreur entre l'image originale et re-coloriée. Une piste possible est de trier les couleurs dans une liste, diviser cette liste en $k$ intervals de couleurs et prendre la couleur du milieu de chaque interval. D'autres méthodes plus avancées peuvent être explorées !\n",
+ "\n",
+ "6. Tester sur plusieurs images de votre choix ou générées automatiquement avec un nombre et une distribution connue de couleurs. Comparer les performances de vos techniques avec d'autres méthodes (cette fois vous pouvez utiliser un éditeur de texte ou la fonction _quantize_ de PIL [(doc)](https://pillow.readthedocs.io/en/stable/reference/Image.html).\n",
+ "\n",
+ "7. Utiliser un pré-traitement des images (flou gaussien, etc) afin de lisser les couleurs est une piste afin de choisir de meilleurs couleurs représentatives. Proposez une quantification de cette amélioration (ou de déterioration éventuelle).\n",
+ "\n",
+ "7. Proposer une méthode d'amélioration de calcul de la distance entre deux couleurs, vous pouvez vous baser sur d'autres espaces de couleur [(doc)](https://fr.wikipedia.org/wiki/Espace_de_couleur). Cette partie est difficile, les espaces de couleurs possibles sont complexes à comprendre.\n",
+ "\n",
+ "8. Optimiser les étapes précédentes (complexité, espace nécessaire, structures de données, etc.).\n",
+ "\n",
+ "\n",
+ "### Bonus\n",
+ "\n",
+ "10. Créer une palette représentative à partir de plusieurs images."
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.10.9"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}