Hoja de repaso: Manipulation et conversion d'images en Python

📋 Plan du Cours

1. Manipulation d'images Python
2. Conversion en tableau de nombres
3. Affichage d'images
4. Structure du tableau Mim
5. Signification des triplets RGB
6. Fonction triplet_zero
7. Négatif d'une image
8. Conversion en niveaux de gris 1
9. Conversion en niveaux de gris 2
10. Redimensionnement par interpolation
11. Réduction par moyenne locale
12. Histogramme des niveaux de gris

📖 1. Manipulation d'images Python

🔑 Notions clés & Définitions

Manipulation d'images en Python : Processus d'importation, affichage, modification et conversion d'images à l'aide de packages Python tels que matplotlib.pyplot, matplotlib.image, et numpy.

Importation d'images avec matplotlib : Utilisation de la fonction imread du module matplotlib.image pour charger une image depuis un fichier en un tableau de nombres (Mim), représentant l'image sous forme matricielle.

Conversion d'une image en tableau de nombres : Transformation de l'image importée en une matrice tridimensionnelle (Nx, Ny, 3) où chaque triplet [R, V, B] correspond aux composantes rouge, vert, bleu du pixel.

Affichage d'une image à partir d'un tableau : Utilisation de plt.imshow() pour représenter graphiquement le tableau de nombres, permettant de visualiser l'image modifiée ou créée.

Structure du tableau Mim (dimensions et format) : La matrice Mim possède 3 dimensions, généralement (hauteur, largeur, 3). La dernière dimension contient les triplets RGB codés sur 8 bits (valeurs entre 0 et 255).

Signification des triplets RGB (couleurs) : Chaque triplet [R, V, B] représente la couleur du pixel, avec R pour rouge, V pour vert, B pour bleu. La valeur de chaque composante indique l'intensité de la couleur correspondante.

📝 Points essentiels

• La conversion d'une image en tableau se fait via img.imread(), produisant une matrice 3D.
• La structure du tableau Mim est (hauteur, largeur, 3), chaque triplet étant [R, V, B].
• La visualisation d'une image à partir d'un tableau se réalise avec plt.imshow().
• La signification des triplets RGB est fondamentale pour manipuler la couleur : R, V, B sont codés sur 8 bits, variant entre 0 et 255.
• La compréhension de la structure du tableau permet de manipuler chaque pixel individuellement ou en blocs.

💡 À retenir

La manipulation d'images en Python repose sur la conversion d'images en tableaux de nombres, leur visualisation et leur modification via des opérations sur les triplets RGB, en utilisant principalement matplotlib et numpy.

📖 2. Conversion en tableau de nombres

🔑 Notions clés & Définitions

Conversion en tableau de nombres (imread) :
Utilisation de la fonction imread du package matplotlib.image pour transformer une image en un tableau numpy. La variable obtenue, par exemple Mim, est une matrice tridimensionnelle où chaque élément représente un pixel avec ses composantes RGB.

Manipulation de matrices numpy :
Opération sur la matrice obtenue, notamment pour connaître ses dimensions avec la fonction shape. La matrice Mim possède 3 dimensions, correspondant à la hauteur, la largeur, et les composantes de couleur.

Fonction shape :
Méthode permettant d’obtenir la taille (dimensions) d’une matrice numpy. Par exemple, Mim.shape retourne (236, 420, 3), indiquant 236 lignes, 420 colonnes, et 3 composantes de couleur.

Utilisation de plt.imshow :
Fonction du package matplotlib.pyplot pour afficher une image à partir d’un tableau de nombres. La visualisation peut se faire en couleur ou en niveaux de gris (avec l’option cmap='gray').

📝 Points essentiels

• La conversion d’une image en tableau de nombres se fait via img.imread('nom_image.png').
• La matrice Mim est généralement de taille (hauteur, largeur, 3) pour une image couleur.
• La commande Mim.shape permet de connaître ses dimensions.
• La structure du tableau Mim est une matrice tridimensionnelle, chaque pixel étant un triplet [R, V, B].
• La visualisation d’un tableau de nombres en image s’effectue avec plt.imshow(Mim) pour une image couleur, ou plt.imshow(Mim, cmap='gray') pour une image en niveaux de gris.

💡 À retenir

La conversion d’une image en tableau de nombres permet de manipuler ses pixels directement, en utilisant la fonction imread pour importer et shape pour connaître ses dimensions, puis plt.imshow pour l’afficher.

📖 3. Affichage d'images

🔑 Notions clés & Définitions

• Fonction imshow : Fonction permettant d'afficher une image à partir d'une matrice de données. Elle crée une figure sur laquelle l'image est visualisée.
• Affichage d'une image en niveaux de gris : Visualisation d'une matrice où chaque élément représente un niveau de gris (intensité lumineuse) compris entre 0 et 255. Pour cela, on utilise la commande plt.imshow(M, cmap='gray').
• Utilisation de cmap='gray' : Paramètre de la fonction imshow qui indique que la colormap doit représenter des niveaux de gris, permettant une visualisation en nuances de gris.

📝 Points essentiels

• La fonction imshow est utilisée pour afficher une image à partir d'une matrice numérique.
• Pour représenter une image en niveaux de gris, il faut que la matrice soit une matrice 2D où chaque élément est un entier entre 0 et 255.
• La commande plt.imshow(M, cmap='gray') permet de visualiser cette matrice en niveaux de gris.
• La visualisation en niveaux de gris est essentielle pour analyser la répartition des intensités lumineuses dans une image.
• La commande plt.show() doit être utilisée après imshow pour afficher réellement l'image.

💡 À retenir

L'affichage d'une image en niveaux de gris avec imshow et cmap='gray' est une étape fondamentale pour visualiser et analyser des matrices représentant des images en niveaux de gris dans un environnement Python.

📖 4. Structure du tableau Mim

🔑 Notions clés & Définitions

Structure du tableau Mim : La structure du tableau Mim désigne ses dimensions et son format. Selon le contenu source, Mim est une matrice tridimensionnelle obtenue par la conversion d'une image en tableau de nombres, où chaque élément est un triplet [R, V, B] représentant les composantes rouge, vert et bleu. La commande Mim.shape retourne un tuple (Ni, Nj, 3), où Ni et Nj sont respectivement le nombre de lignes et de colonnes de l'image, et 3 correspond au nombre de composantes couleur.

Manipulation de matrices numpy : La manipulation de matrices numpy consiste à utiliser des opérations et méthodes spécifiques pour traiter ces tableaux, notamment la copie (avec .copy()), l'accès aux dimensions via shape, et la modification des éléments.

Fonction shape pour connaître les dimensions : La fonction shape appliquée à un tableau numpy retourne un tuple indiquant ses dimensions. Pour Mim, Mim.shape donne (Ni, Nj, 3), où Ni et Nj sont les dimensions spatiales, et 3 le nombre de composantes couleur.

📝 Points essentiels

• La commande Mim.shape permet d'obtenir les dimensions du tableau Mim, qui est une matrice 3D.
• Mim est une "matrice de triplets" où chaque pixel est représenté par un triplet [R, V, B].
• La dimension 3 du tableau indique que chaque pixel possède trois composantes, correspondant aux couleurs rouge, vert et bleu.
• La manipulation de Mim doit se faire sur une copie pour éviter de modifier l'original, en utilisant par exemple N = M.copy().
• La structure du tableau est essentielle pour accéder aux éléments individuels, par exemple Mim[i][j] correspond à un triplet [R, V, B].

💡 À retenir

La structure du tableau Mim est une matrice tridimensionnelle de dimensions (Ni, Nj, 3), où chaque élément représente un pixel par un triplet de composantes couleur. La commande shape permet d’accéder à ces dimensions, indispensables pour la manipulation et l’analyse de l’image sous forme de tableau.

📖 5. Signification des triplets RGB

🔑 Notions clés & Définitions

Triplet RGB : Ensemble de trois valeurs entières codant la couleur d’un pixel, représentant respectivement la quantité de rouge (R), vert (V) et bleu (B). Chaque valeur est comprise entre 0 et 255, permettant de définir une couleur précise dans l’espace RGB.

📝 Points essentiels

• Un tableau de nombres représentant une image en couleurs est constitué de triplets RGB, où chaque triplet correspond à un pixel.
• La structure du tableau est en trois dimensions : deux pour la position du pixel (i, j) et une pour les composantes de couleur (R, V, B).
• La signification de chaque élément du triplet est :
  • R : intensité de la couleur rouge
  • V : intensité de la couleur verte
  • B : intensité de la couleur bleue
• La valeur de chaque composante est codée sur 8 bits, donc comprise entre 0 et 255.
• La compréhension de la structure RGB est essentielle pour manipuler, convertir ou analyser des images couleur.

💡 À retenir

Les triplets RGB codent la couleur de chaque pixel par trois valeurs d’intensité, permettant de représenter une large gamme de couleurs dans une image numérique.

📖 6. Fonction triplet_zero

🔑 Notions clés & Définitions

fonction triplet_zero(M, k) :
Une fonction qui prend en argument une matrice M composée de triplets [R, V, B] (couleurs rouge, vert, bleu) et un entier k ∈ [[0, 2]]. Elle renvoie une nouvelle matrice où, pour chaque triplet, tous les éléments sauf celui d’indice k sont fixés à 0. La copie de la matrice M est utilisée pour ne pas modifier l’originale, via la commande N = M.copy().

Manipulation de matrices numpy :
Utilisation de la méthode .shape pour connaître les dimensions de la matrice, et de la copie .copy() pour créer une nouvelle matrice indépendante. La boucle imbriquée parcourt chaque pixel pour appliquer la modification.

📝 Points essentiels

• La fonction commence par récupérer les dimensions de la matrice M (Ni, Nj, Nk = M.shape).
• La copie N = M.copy() permet de préserver la matrice initiale.
• La liste v = [0, 1, 2] représente les indices des éléments du triplet.
• La méthode v.pop(k) supprime l’indice k de la liste, laissant les deux autres.
• La boucle double (i, j) parcourt tous les pixels de la matrice.
• Pour chaque pixel, la boucle sur l’indice v met à zéro tous les éléments du triplet sauf celui d’indice k.
• La fonction retourne la matrice modifiée N.

💡 À retenir

La fonction triplet_zero permet d’isoler un composant de couleur dans une matrice de triplets RGB en mettant à zéro les autres composants, facilitant ainsi l’analyse ou la visualisation de chaque couleur individuellement.

📖 7. Négatif d'une image

🔑 Notions clés & Définitions

Fonction negatif(M) :
Fonction qui prend en argument une matrice M représentant une image en couleurs, et qui retourne la matrice correspondant à l’image négative. La transformation consiste à remplacer chaque valeur de pixel par sa valeur complémentaire par rapport à 255, c’est-à-dire que pour chaque composante [R, V, B], on calcule 255 - valeur.

Transformation complémentaire des couleurs :
Opération consistant à inverser chaque composante de couleur d’un pixel en soustrayant sa valeur de 255, afin d’obtenir la couleur complémentaire ou négative de l’image.

Manipulation de matrices numpy :
Utilisation de la copie de matrices pour éviter de modifier l’image originale, et parcours de matrices à l’aide de boucles pour appliquer la transformation pixel par pixel.

📝 Points essentiels

• La fonction negatif(M) crée une copie de la matrice M pour ne pas altérer l’original.
• Elle parcourt chaque pixel (i, j) et chaque composante (k) du pixel, puis calcule 255 - M[i][j][k].
• La transformation s’applique à tous les pixels et toutes les composantes, ce qui donne l’image négative.
• La visualisation du négatif se fait en utilisant plt.imshow(Neg), où Neg est la matrice retournée par la fonction.

💡 À retenir

La transformation du négatif d’une image consiste à inverser chaque composante de couleur par rapport à 255, permettant d’obtenir une version inversée et souvent utile pour la détection de contours ou la correction d’image.

📖 8. Conversion en niveaux de gris 1

🔑 Notions clés & Définitions

Conversion en niveaux de gris par moyenne simple : Technique consistant à calculer le niveau de gris d’un pixel en faisant la moyenne arithmétique des trois composantes de couleur (rouge, vert, bleu) du pixel. La formule est :
$\text{Niveau de gris} = \frac{R + V + B}{3}$

Fonction N_et_B_1 : Fonction qui, à partir d’une matrice M représentant une image en couleurs, calcule une image en niveaux de gris en utilisant la moyenne simple. Elle renvoie une matrice 2D de taille $N_x \times N_y$, où chaque élément est le niveau de gris du pixel correspondant, obtenu en faisant la moyenne des composantes R, V, B.

Visualisation en niveaux de gris avec plt.imshow : Utilisation de la commande plt.imshow(M, cmap='gray') pour afficher une image en niveaux de gris à partir d’une matrice 2D. La couleur 'gray' indique que l’échelle de couleurs doit représenter des niveaux de gris.

📝 Points essentiels

• La conversion par moyenne simple consiste à sommer les trois composantes R, V, B pour chaque pixel, puis à diviser par 3.
• La matrice M en couleur est de dimension $N_x \times N_y \times 3$, où chaque triplet représente [R, V, B].
• La fonction N_et_B_1(M) crée une nouvelle matrice N de taille $N_x \times N_y$, initialisée à zéro avec np.zeros, puis remplit chaque élément par la moyenne des trois composantes du pixel correspondant.
• La division par 3 doit être effectuée en utilisant des opérations entières pour éviter les erreurs de type, en utilisant par exemple //3.
• L’affichage d’une image en niveaux de gris se fait avec plt.imshow(M, cmap='gray').

💡 À retenir

La conversion en niveaux de gris par moyenne simple consiste à prendre la moyenne arithmétique des trois composantes de couleur pour chaque pixel, permettant d’obtenir une image en niveaux de gris simple et efficace pour diverses opérations de traitement d’image.

📖 9. Conversion en niveaux de gris 2

🔑 Notions clés & Définitions

• Poids pour une conversion en niveaux de gris (0.3, 0.59, 0.11) : Ce sont des coefficients appliqués respectivement aux composantes rouge, vert et bleu d’un pixel pour obtenir une perception visuelle améliorée lors de la conversion couleur vers niveaux de gris. Ces poids reflètent la sensibilité de l’œil humain à chaque couleur, avec le vert étant le plus perceptible, puis le rouge, puis le bleu.

• Fonction N_et_B_2 : Fonction qui convertit une image couleur en une image en niveaux de gris en utilisant une moyenne pondérée des composantes R, V, B avec les poids 0.3, 0.59, 0.11. Elle calcule pour chaque pixel :
  $\text{Niveau de gris} = 0.3 \times R + 0.59 \times V + 0.11 \times B$
  permettant une meilleure perception visuelle.

• Amélioration de la perception visuelle en niveaux de gris : Technique consistant à appliquer des poids spécifiques aux composantes couleur pour que l’image en niveaux de gris reflète mieux la sensibilité humaine, contrairement à une simple moyenne arithmétique.

📝 Points essentiels

• La conversion pondérée en niveaux de gris utilise les poids 0.3, 0.59, 0.11 pour R, V, B respectivement, afin d’obtenir une image en niveaux de gris plus fidèle à la perception humaine.
• La fonction N_et_B_2 applique ces poids en multipliant chaque composante par le poids correspondant, puis en sommant le résultat pour chaque pixel.
• La formule de conversion pondérée est préférée à la moyenne simple car elle donne une meilleure perception des détails dans l’image en niveaux de gris.
• La matrice résultante est une matrice 2D de taille $N_x \times N_y$, contenant des niveaux de gris codés sur 8 bits (0-255).

💡 À retenir

La conversion en niveaux de gris utilisant des poids (0.3, 0.59, 0.11) permet d’obtenir une image plus fidèle à la perception humaine, en valorisant la composante verte. La fonction N_et_B_2 implémente cette méthode pour améliorer la perception visuelle dans les images en niveaux de gris.

📖 10. Redimensionnement par interpolation

🔑 Notions clés & Définitions

• Réduction de la taille d'une image par sous-échantillonnage : Technique consistant à diminuer la dimension d'une image en sélectionnant certains pixels selon un critère précis, sans interpolation ni calculs complexes. Elle consiste à prendre un pixel représentatif dans chaque sous-ensemble de pixels de l'image originale.

• Interpolation au plus proche voisin : Méthode d'interpolation utilisée lors du redimensionnement d'une image. Elle consiste à associer à un pixel de l'image réduite la valeur du pixel le plus proche dans l'image originale, sans calculs de moyenne ou de pondération. Elle est simple et rapide mais peut produire des images avec des effets de pixellisation.

• Fonction Redim : Fonction qui réalise la réduction d'une image en niveaux de gris en utilisant la stratégie de sous-échantillonnage par interpolation au plus proche voisin. Elle segment l'image en sous-images de taille p×p et sélectionne le pixel avec l’indice le plus faible dans chaque sous-image pour constituer l’image réduite.

📝 Points essentiels

• La réduction par sous-échantillonnage consiste à diviser l’image en blocs de taille p×p, puis à choisir un pixel représentatif dans chaque bloc, généralement celui avec les indices i et j les plus faibles (interpolation au plus proche voisin).

• La fonction Redim(M,p) parcourt la matrice M en sautant p pixels à chaque étape dans les directions i et j, pour construire une nouvelle matrice de taille réduite. Elle ne calcule pas de moyenne, mais sélectionne directement un pixel de l’image originale.

• La stratégie d’interpolation au plus proche voisin est simple à implémenter et rapide, mais peut produire une image de qualité inférieure avec des effets de pixellisation, notamment lors de grossissements ou de réductions importantes.

• La taille de l’image réduite n’est pas forcément divisible par p, il faut gérer les cas où la segmentation ne tombe pas sur un nombre entier de blocs.

💡 À retenir

La réduction d’image par sous-échantillonnage utilisant l’interpolation au plus proche voisin consiste à sélectionner un pixel représentatif dans chaque sous-ensemble de l’image originale, permettant une diminution rapide de la taille de l’image, au prix d’une qualité d’image parfois dégradée. La fonction Redim(M,p) implémente cette stratégie en parcourant la matrice par pas de p pixels.

📖 11. Réduction par moyenne locale

🔑 Notions clés & Définitions

Réduction par moyenne locale : Technique consistant à segmenter une image en sous-images de taille p×p, puis à calculer la moyenne des pixels de chaque sous-image pour obtenir une image réduite. Cette méthode permet de diminuer la taille de l’image tout en conservant une représentation fidèle de ses zones de luminosité.

Fonction Redim2 : Fonction qui, à partir d’une image en niveaux de gris M et d’un facteur p, calcule une image réduite en remplaçant chaque sous-image p×p par la moyenne de ses pixels. La moyenne est calculée en sommant les pixels de la sous-image et en divisant par p², puis en affectant cette valeur à la pixel correspondant dans l’image réduite.

📝 Points essentiels

• La segmentation en sous-images p×p permet de traiter localement chaque zone de l’image.
• La réduction par moyenne locale est plus fidèle visuellement que la simple interpolation au plus proche voisin, car elle conserve la luminosité moyenne de chaque sous-zone.
• La fonction Redim2 parcourt l’image en blocs p×p, calcule la moyenne de chaque bloc, et construit une nouvelle matrice de taille réduite.
• La taille de l’image réduite est déterminée par le quotient de la division des dimensions originales par p, en ignorant les pixels en excès si les dimensions ne sont pas divisibles par p.

💡 À retenir

La réduction par moyenne locale consiste à segmenter l’image en sous-ensembles de pixels, puis à remplacer chaque sous-ensemble par sa moyenne, permettant une réduction efficace et visuellement cohérente de la taille de l’image. La fonction Redim2 implémente cette stratégie en calculant la moyenne de chaque sous-image p×p et en construisant une image de taille réduite.

📖 12. Histogramme des niveaux de gris

🔑 Notions clés & Définitions

Histogramme (voir section 8) : Représentation graphique de la répartition des pixels d'une image en fonction de leur niveau de gris. Il indique le nombre de pixels pour chaque valeur possible (de 0 à 255).

Fonction histogramme (voir section 8) : Fonction qui, pour une image donnée, calcule la fréquence de chaque niveau de gris en comptant le nombre de pixels correspondant à chaque valeur.

Visualisation de la répartition des pixels (voir section 8) : Représentation graphique (souvent sous forme de courbe ou de barres) de l'histogramme, permettant d'analyser la distribution des niveaux de gris dans l'image.

📝 Points essentiels

• L'histogramme permet d'observer la répartition des niveaux de gris dans une image, ce qui est utile pour le traitement d'images, notamment pour le seuillage ou la correction de contraste.
• La fonction histogramme(M) parcourt chaque pixel de la matrice en niveaux de gris M, et pour chaque valeur de pixel k, incrémente le compteur correspondant dans la liste h.
• La liste h contient 256 éléments, chaque élément représentant le nombre de pixels ayant la valeur de niveau de gris correspondant à son indice.
• La visualisation de l'histogramme se fait en traçant la liste h avec plt.plot(hist).

💡 À retenir

L'histogramme est un outil essentiel pour analyser la répartition des niveaux de gris dans une image, facilitant ainsi la sélection de seuils ou l'amélioration du contraste. La fonction histogramme(M) permet de calculer cette répartition en comptant le nombre de pixels pour chaque niveau.

📊 Tableaux de Synthèse

Aspect	Description	Auteur / Référence
Conversion d'image en tableau	Utilisation de imread pour importer une image en tableau numpy (Mim).	-
Structure du tableau Mim	Tableau 3D (hauteur, largeur, 3), chaque pixel [R, V, B], valeurs 0-255.	-
Affichage d'une image	plt.imshow() pour visualiser, avec option cmap='gray' pour niveaux de gris.	-
Signification RGB	Triplet [R, V, B], chaque composante codée sur 8 bits, représentant la couleur.	-
Manipulation de Mim	Accès via shape, copie avec .copy(), modification pixel par pixel.	-

⚠️ Pièges & Confusions Fréquentes

1. Confondre la dimension du tableau (hauteur, largeur, 3) avec une image en niveaux de gris (2D).
2. Oublier d'utiliser plt.show() après imshow() pour afficher l'image.
3. Interpréter incorrectement la signification des triplets RGB, notamment leur plage de valeurs (0-255).
4. Modifier directement le tableau original sans faire de copie, risquant de perdre l’image initiale.
5. Confondre la visualisation en couleur (cmap='gray') avec la visualisation en niveaux de gris.
6. Ne pas vérifier la dimension du tableau avec .shape avant manipulation.
7. Oublier que chaque pixel est représenté par un triplet, et non par une seule valeur.

✅ Checklist Examen

• Connaître la fonction imread du package matplotlib.image pour importer une image en tableau numpy.
• Savoir que la structure du tableau Mim est (hauteur, largeur, 3) et que chaque pixel est un triplet [R, V, B].
• Comprendre la signification des triplets RGB, avec leurs valeurs entre 0 et 255.
• Être capable d’afficher une image avec plt.imshow(), en précisant cmap='gray' pour niveaux de gris.
• Maîtriser l’utilisation de shape pour connaître les dimensions du tableau Mim.
• Savoir faire une copie du tableau avec .copy() avant modification.
• Connaître la différence entre une image en couleur et en niveaux de gris.
• Savoir que plt.show() doit être appelé pour afficher l’image.
• Comprendre la structure du tableau Mim pour manipuler chaque pixel ou groupe de pixels.
• Connaître la signification des triplets RGB pour la couleur.
• Maîtriser la conversion d’une image en tableau de nombres et la visualisation.
• Connaître la fonction plt.imshow() et ses paramètres pour l’affichage.