Fiche de révision : Manipulation et Visualisation d'Images en Python

📋 Plan du Cours

1. Manipulation d'images Python
2. Importation d'images matplotlib
3. Conversion en tableau numpy
4. Structure du tableau Mim
5. Signification des triplets RGB
6. Fonction triplet_zero
7. Négatif d'image
8. Conversion niveaux de gris 1
9. Conversion niveaux de gris 2
10. Redimensionnement interpolation
11. Réduction par moyenne locale
12. Histogramme 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 comme 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.

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 : 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, codée sur 8 bits (0-255).

📝 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 pixel étant un triplet [R, V, B].
• La visualisation d’une image à partir d’un tableau s’effectue 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. Importation d'images matplotlib

🔑 Notions clés & Définitions

• Conversion en tableau de nombres (imread) : Utilisation de la fonction imread du module matplotlib.image pour charger une image depuis un fichier, produisant une matrice numpy (Mim) représentant l’image sous forme matricielle tridimensionnelle.
• Manipulation de matrices numpy : Opérations sur la matrice Mim, notamment pour connaître ses dimensions avec la fonction shape. La matrice Mim est une matrice tridimensionnelle (hauteur, largeur, 3) où chaque pixel est un triplet [R, V, B].
• Utilisation de shape : Méthode permettant d’obtenir la taille (dimensions) d’une matrice numpy. Par exemple, Mim.shape retourne un tuple (Ni, Nj, 3), indiquant le nombre de lignes, colonnes et composantes couleur.
• Visualisation d'une image à partir d'un tableau avec plt.imshow() : Fonction du module matplotlib.pyplot qui affiche graphiquement une image à partir d’une matrice de données. La visualisation peut être en couleur ou en niveaux de gris (avec l’option cmap='gray').

📝 Points essentiels

• La fonction imread() permet d’importer une image en tableau numpy, généralement stocké dans une variable comme Mim.
• La structure du tableau Mim est une matrice tridimensionnelle de dimensions (hauteur, largeur, 3), chaque pixel étant représenté par un triplet [R, V, B].
• La commande Mim.shape retourne ces dimensions, essentielles pour manipuler ou analyser l’image.
• La visualisation d’un tableau 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.
• La compréhension de cette structure permet de manipuler chaque pixel ou groupe de pixels individuellement ou en blocs.

💡 À retenir

L’importation d’une image en Python se fait via imread, qui convertit l’image en un tableau numpy tridimensionnel. La visualisation avec plt.imshow() permet d’afficher cette matrice, en utilisant la propriété shape pour connaître ses dimensions et manipuler ses pixels.

📖 3. Conversion en tableau numpy

🔑 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, en utilisant notamment plt.imshow().

• Visualisation en niveaux de gris avec plt.imshow et cmap='gray' : Technique pour représenter une matrice 2D où chaque élément correspond à un niveau de gris (intensité lumineuse). La commande plt.imshow(M, cmap='gray') indique que la colormap doit représenter des nuances de gris, facilitant l’analyse des intensités lumineuses.

📝 Points essentiels

• La fonction imshow sert à afficher une image à partir d’une matrice numérique. Elle doit être suivie de plt.show() pour rendre l’image visible.
• Pour visualiser une image en niveaux de gris, la matrice doit être en 2D, avec des valeurs comprises entre 0 et 255.
• La commande plt.imshow(M, cmap='gray') permet de représenter cette matrice en nuances de gris.
• La visualisation en niveaux de gris est essentielle pour analyser la répartition des intensités lumineuses dans une image.

💡 À retenir

L’affichage d’une image en niveaux de gris avec plt.imshow et cmap='gray' est une étape clé pour visualiser et analyser les matrices représentant des images en nuances 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 [R, V, B] codant la couleur d’un pixel. Chaque composante représente respectivement la quantité de rouge (R), vert (V) et bleu (B). La valeur de chaque composante est comprise entre 0 et 255, permettant de définir une couleur précise dans l’espace RGB.

📝 Points essentiels

• Chaque pixel d’une image en couleur est représenté par un triplet [R, V, B].
• La structure du tableau est en trois dimensions : deux pour la position du pixel (i, j) et une pour les composantes de couleur.
• La valeur de chaque composante indique l’intensité de la couleur correspondante, avec 0 correspondant à l’absence de cette couleur et 255 à son intensité maximale.
• La compréhension de cette codification 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é comprises entre 0 et 255, permettant de représenter une large gamme de couleurs dans une image numérique.

📖 6. Fonction triplet_zero

🔑 Notions clés & Définitions

• triplet_zero(M, k) : 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'image

🔑 Notions clés & Définitions

• Transformation négative d'une image : Opération consistant à inverser chaque composante de couleur d’un pixel en soustrayant sa valeur de 255, afin d’obtenir une version inversée ou négative de l’image. Pour chaque pixel, chaque valeur [R, V, B] devient [255 - R, 255 - V, 255 - B].

• Manipulation pixel par pixel : Processus de traitement où chaque pixel de l’image est parcouru individuellement pour appliquer la transformation négative, en utilisant des opérations sur chaque composante RGB.

📝 Points essentiels

• La transformation du négatif consiste à remplacer chaque valeur de composante couleur par son complément par rapport à 255.
• La fonction négatif(M) commence par créer une copie de la matrice M pour préserver 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, produisant ainsi l’image négative.
• La visualisation du négatif se réalise avec plt.imshow(Neg), où Neg est la matrice transformée.

💡 À retenir

La création du négatif d’une image repose sur l’inversion de chaque composante de couleur par rapport à 255, permettant d’obtenir une version inversée utile pour diverses analyses ou corrections d’image.

📖 8. Conversion 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, selon la formule :

  $\text{Niveau de gris} = \frac{R + V + B}{3}$

• Création d'une matrice 2D représentant l’image en niveaux de gris : Résultat de la conversion, cette matrice contient une seule valeur par pixel, correspondant à son niveau de gris, et possède deux dimensions (hauteur, largeur).

• 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.

📝 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$, chaque triplet représentant [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, 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, par exemple //3.
• La visualisation 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 à calculer 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 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 (AUTEUR (date) : concept).
• 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 × 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 interpolation

🔑 Notions clés & Définitions

• Conversion en tableau de nombres (imread) : Transformation d'une image importée en un tableau numpy tridimensionnel, représentant l'image sous forme matricielle. La fonction imread du package matplotlib.image est utilisée pour charger l'image en un tableau Mim.
• Manipulation de matrices numpy : Opérations sur la matrice Mim, notamment pour connaître ses dimensions avec shape, et pour créer des copies afin de préserver l'original.
• Utilisation de shape pour connaître les dimensions : La méthode shape retourne un tuple (Ni, Nj, 3), où Ni et Nj sont la hauteur et la largeur de l'image, et 3 correspond au nombre de composantes RGB.
• Visualisation d'une image à partir d'un tableau avec plt.imshow : Fonction qui affiche graphiquement le tableau Mim, en couleur ou en niveaux de gris (avec cmap='gray').

📝 Points essentiels

• Le redimensionnement par interpolation au plus proche voisin consiste à réduire la taille de l'image en segmentant celle-ci en blocs p×p, puis en sélectionnant le pixel le plus proche dans chaque bloc pour former la nouvelle image.
• La fonction Redim(M,p) parcourt la matrice M en sautant p pixels dans les directions i et j, sans effectuer de calculs de moyenne ou de pondération, mais en sélectionnant directement un pixel représentatif.
• L'interpolation au plus proche voisin est simple et rapide, mais peut entraîner une pixellisation visible.
• La taille de l'image réduite n'est pas forcément divisible par p, ce qui nécessite une gestion des cas où la segmentation ne tombe pas sur un nombre entier de blocs.

💡 À retenir

Le redimensionnement par interpolation au plus proche voisin réduit la taille d'une image en sélectionnant directement un pixel représentatif dans chaque sous-bloc, ce qui permet une réduction rapide mais au prix d'une qualité d'image pouvant être dégradée. La fonction Redim(M,p) réalise cette opération en parcourant la matrice par pas de p pixels.

📖 11. Réduction par moyenne locale

🔑 Notions clés & Définitions

• Fonction imshow : Fonction permettant d'afficher graphiquement une image à partir d'une matrice de données. Elle crée une figure où l’image est visualisée, en utilisant notamment plt.imshow().

• Visualisation en niveaux de gris avec plt.imshow et cmap='gray' : Technique pour représenter une matrice 2D où chaque élément correspond à un niveau de gris, compris entre 0 et 255. La commande plt.imshow(M, cmap='gray') permet d’afficher cette matrice en nuances de gris.

📝 Points essentiels

• La fonction imshow sert à représenter graphiquement une image à partir d’un tableau de nombres.
• Pour une image en niveaux de gris, la matrice doit être en 2D avec des valeurs entre 0 et 255.
• La visualisation en niveaux de gris s’effectue avec plt.imshow(M, cmap='gray'), ce qui indique que la colormap doit représenter des nuances de gris.
• Après imshow, il est souvent nécessaire d’utiliser plt.show() pour afficher l’image.
• La visualisation en niveaux de gris facilite l’analyse de la répartition des intensités lumineuses dans l’image.

💡 À retenir

La fonction imshow combinée avec cmap='gray' permet de visualiser efficacement une image en niveaux de gris à partir d’une matrice 2D, ce qui est essentiel pour l’analyse et le traitement d’images en niveaux de gris.

📖 12. Histogramme niveaux de gris

🔑 Notions clés & Définitions

• Histogramme : Représentation graphique de la répartition des pixels d'une image selon leur niveau de gris. Il montre le nombre de pixels pour chaque valeur de 0 à 255.
• Fonction histogramme : Fonction qui, pour une image en niveaux de gris, calcule la fréquence de chaque niveau de gris en comptant le nombre de pixels correspondant.
• Visualisation de la répartition : Représentation graphique (courbe ou 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, utile pour le seuillage ou l'amélioration du contraste.
• La fonction histogramme(M) parcourt chaque pixel de la matrice en niveaux de gris M.
• Elle incrémente dans une liste h de 256 éléments le compteur correspondant à la valeur de chaque pixel.
• La visualisation se fait avec plt.plot(h), représentant la fréquence de chaque niveau de gris.
• La liste h contient le nombre de pixels pour chaque valeur de gris (0 à 255).

💡 À retenir

L'histogramme est un outil essentiel pour analyser la distribution des niveaux de gris dans une image, facilitant le traitement et l'amélioration de l'image. La fonction histogramme(M) calcule cette répartition en comptant la fréquence de chaque niveau.

📊 Tableaux de Synthèse

⚠️ Pièges & Confusions Fréquentes

1. Confondre la structure (hauteur, largeur, 3) avec (largeur, hauteur, 3) lors de l’accès aux pixels.
2. Oublier que chaque composante RGB est codée sur 8 bits (0-255), ce qui peut entraîner des erreurs d’interprétation.
3. Utiliser imshow() sans préciser cmap='gray' pour une image en niveaux de gris, ce qui affiche une image couleur par défaut.
4. Modifier directement le tableau original Mim sans faire de copie, risquant de corrompre l’image source.
5. Confondre la visualisation d’une image couleur et en niveaux de gris, notamment en ne respectant pas la dimension 2 ou 3 du tableau.
6. Ne pas utiliser shape pour vérifier les dimensions du tableau avant manipulation.
7. Oublier que la fonction imread() retourne une matrice avec des valeurs entre 0 et 255, ce qui doit être pris en compte pour certains traitements.

✅ Checklist Examen

1. Connaître la fonction imread() du module matplotlib.image pour importer une image en tableau numpy.
2. Savoir que la structure du tableau Mim est (hauteur, largeur, 3) avec chaque pixel [R, V, B].
3. Comprendre la signification des triplets RGB, avec chaque composante codée sur 8 bits (0-255).
4. Savoir utiliser plt.imshow() pour afficher une image à partir d’un tableau numpy.
5. Maîtriser la visualisation en niveaux de gris avec plt.imshow(M, cmap='gray').
6. Connaître la méthode shape pour obtenir les dimensions du tableau Mim.
7. Savoir que la conversion d’une image en tableau permet de manipuler chaque pixel individuellement ou en blocs.
8. Connaître la différence entre image couleur et niveaux de gris dans la manipulation de tableaux.
9. Être capable de faire une copie du tableau Mim pour éviter de modifier l’original (M.copy()).
10. Comprendre que chaque pixel est représenté par un triplet [R, V, B] dans le tableau.
11. Connaître la fonction plt.show() pour rendre visible l’image affichée.
12. Savoir que la visualisation en niveaux de gris nécessite une matrice 2D, avec des valeurs entre 0 et 255.