U.A.8 : UTILISATION DE FICHIERS IMAGES

## Objectifs et prérequis **Objectifs** : À la fin de ce chapitre, l’élève sera capable de : - Définir les notions de pixel, résolution, profondeur de couleur et formats d’image courants. - Expliquer le principe du traitement d’image numérique et les opérations de base (lecture, affichage, conversion). - Manipuler des images à l’aide d’un logiciel de traitement d’image (ex. GIMP, Photoshop ou une bibliothèque Python comme Pillow) : redimensionnement, rotation, recadrage, ajustement de luminosité/contraste, application de filtres simples. - Réaliser des exercices type baccalauréat camerounais sur la manipulation d’images et justifier chaque étape. **Prérequis** : - Notions de base en informatique (système d’exploitation, gestion de fichiers). - Connaissances élémentaires en algèbre linéaire (vecteurs, matrices) utiles pour comprendre les transformations géométriques. - Familiarité avec l’usage d’un tableur ou d’un langage de script (ex. Python) pour exécuter des commandes simples. --- ## Introduction contextualisée Dans le monde contemporain, les images numériques sont omniprésentes : réseaux sociaux, télémédecine, télédétection, jeux vidéo, impression, etc. Le traitement d’image consiste à modifier, analyser ou extraire de l’information contenue dans une représentation numérique d’une scène. Au Cameroun, l’enseignement des TIC en série AVC et SH prépare les élèves à maîtriser ces outils, indispensables aussi bien pour des poursuites d’études scientifiques que pour des métiers du numérique (graphisme, communication, télédétection agricole, etc.). Ce chapitre s’inscrit dans la logique du **programme officiel MINESEC/IGE** (approche par compétences) : il ne se limite pas à la description théorique des formats, mais met l’accent sur la **manipulation concrète** d’images à l’aide de logiciels libres ou de bibliothèques de programmation, afin que l’élève puisse produire un résultat attendu et justifier chaque opération. --- ## I. Leçon 21 : Introduction au traitement d’images ### 1. Définitions de base > **Pixel** : élément minimal d’une image numérique, représenté par un triplet de valeurs (R, G, B) pour une image couleur en espace RGB, ou par une seule intensité pour une image en niveaux de gris. > **Résolution spatiale** : nombre de pixels par unité de longueur (ex. pixels/pouce, ppp). Elle détermine le niveau de détail visible. > **Profondeur de couleur** : nombre de bits utilisés pour coder la couleur d’un pixel. Une profondeur de 8 bits par canal (24 bits au total) permet $2^{8}=256$ niveaux par couleur, soit $256^{3}\approx 16,7$ millions de couleurs. > **Format d’image** : façon dont les données pixel sont stockées et compressées. Les formats les plus courants sont : - **BMP** (Bitmap) : sans compression, taille importante. - **JPEG** : compression avec perte, adapté aux photographies. - **PNG** : compression sans perte, supporte la transparence. - **GIF** : limité à 256 couleurs, utilisé pour les animations simples. ### 2. Modèle de couleur RGB et espaces de couleur Dans le modèle **RGB**, chaque couleur est un vecteur $\mathbf{c} = (R, G, B)^T$ avec $0\le R,G,B\le 255$ (pour 8 bits). La conversion vers les niveaux de gris se fait par la formule pondérée : $$ I = 0.299R + 0.587G + 0.114B $$ *Démonstration* : ces coefficients proviennent de la sensibilité relative de l’œil humain aux trois couleurs primaires (plus sensible au vert, moins au bleu). **Exemple 1** : Pixel $(R,G,B) = (120, 200, 50)$. Calcul du gris : $$ I = 0.299\times120 + 0.587\times200 + 0.114\times50 = 35.88 + 117.4 + 5.7 = 158.98 \approx 159 $$ Le pixel devient $(159,159,159)$ en niveaux de gris. **Exemple 2** : Conversion d’une image entière. Supposons une image de $2\times2$ pixels : $$ \begin{bmatrix} (255,0,0) & (0,255,0)\\ (0,0,255) & (255,255,0) \end{bmatrix} $$ Application de la formule donne : $$ \begin{bmatrix} 0.299\cdot255 & 0.587\cdot255\\ 0.114\cdot255 & 0.299\cdot255+0.587\cdot255 \end{bmatrix} = \begin{bmatrix} 76.2 & 149.7\\ 29.0 & 225.9 \end{bmatrix} \approx \begin{bmatrix} 76 & 150\\ 29 & 226 \end{bmatrix} $$ ### 3. Opérations de base sur les images | Opération | Description | Effet sur les pixels | |-----------|-------------|----------------------| | **Lecture** | Chargement du fichier image en mémoire | Aucun changement | | **Affichage** | Rendu à l’écran | Aucun changement | | **Conversion de format** | Re‑encodage (ex. PNG → JPEG) | Peut introduire des artefacts de compression | | **Redimensionnement** | Changement de la taille (largeur × hauteur) | Interpolation (voisin le plus proche, bilinéaire, bicubique) | | **Rotation** | Transformation géométrique autour d’un centre | Nouvelle matrice de coordonnées | | **Recadrage (crop)** | Extraction d’une sous‑région | Suppression de pixels hors zone | | **Ajustement de luminosité/contraste** | Transformation linéaire $I' = aI + b$ | $a$ contrôle le contraste, $b$ la luminosité | | **Filtrage** | Convolution avec un noyau (ex. flou, netteté) | Modification locale des valeurs | > **Règle de convolution discrète** : pour une image $I$ et un noyau $K$ de taille $m\times n$, le pixel résultant en position $(x,y)$ est > $$ > (I * K)(x,y)=\sum_{i=-\lfloor m/2\rfloor}^{\lfloor m/2\rfloor}\sum_{j=-\lfloor n/2\rfloor}^{\lfloor n/2\rfloor} I(x+i,y+j)\,K(i,j) > $$ **Exemple 3** : Flou moyen 3×3 (noyau $K=\frac{1}{9}\begin{bmatrix}1&1&1\\1&1&1\\1&1&1\end{bmatrix}$) appliqué au pixel central de l’image suivante (niveaux de gris) : $$ I= \begin{bmatrix} 50 & 60 & 70\\ 80 & 90 & 100\\ 110 & 120 & 130 \end{bmatrix} $$ Calcul du pixel central $(x=2,y=2)$ (en indexant à partir de 1) : $$ \frac{1}{9}(50+60+70+80+90+100+110+120+130)=\frac{1}{9}\times 810 = 90 $$ Le pixel reste 90 (car l’image présente un gradient linéaire). **Exemple 4** : Filtre de netteté (noyau $K=\begin{bmatrix}0&-1&0\\-1&5&-1\\0&-1&0\end{bmatrix}$) sur le même pixel central : $$ (0\cdot50)+(-1\cdot60)+(0\cdot70)+(-1\cdot80)+(5\cdot90)+(-1\cdot100)+(0\cdot110)+(-1\cdot120)+(0\cdot130)= -60-80+450-100-120 = 90 $$ Résultat identique ici, mais sur une zone à contraste élevé le filtre accentuerait les différences. --- ## II. Leçon 22 : Manipulation des images Cette leçon met en pratique les notions précédentes à l’aide d’un logiciel de traitement d’image (GIMP) et/ou d’une bibliothèque Python (Pillow). Nous détaillons les étapes classiques d’un projet de manipulation : importation, transformation, exportation. ### 1. Utilisation de GIMP (interface graphique) > **Étape 1 – Ouverture** : `Fichier → Ouvrir` → sélectionner le fichier (ex. `photo.jpg`). > **Étape 2 – Vérification des propriétés** : `Image → Propriétés de l’image` affiche largeur, hauteur, résolution (ppp) et profondeur. > **Étape 3 – Redimensionnement** : `Image → Échelle et taille de l’image` → saisir nouvelle largeur (ex. 800 px) → hauteur s’ajuste automatiquement si le lien est activé → choisir méthode d’interpolation (Cubique pour meilleure qualité) → `Échelle`. > **Étape 4 – Rotation** : `Outils → Transformation → Rotation` → définir angle (ex. 15°) → centre par défaut (centre de l’image) → `Rotation`. > **Étape 5 – Recadrage** : `Outils → Transformation → Recadrage` → tracer rectangle → valider. > **Étape 6 – Ajustement luminosité/contraste** : `Couleurs → Luminosité-Contraste` → régler les curseurs → aperçu en temps réel → `OK`. > **Étape 7 – Application d’un filtre** : `Filtres → Flou → Flou gaussien` → rayon 2 px → `OK`. > **Étape 8 – Export** : `Fichier → Exporter sous` → choisir format (PNG pour sans perte, JPEG avec qualité 85) → nommer fichier → `Exporter`. > **Astuce** : Toujours travailler sur une copie du fichier original (`Fichier → Ouvrir en tant que calques` ou `Dupliquer l’image`) afin de préserver la source. ### 2. Manipulation programmée avec Python‑Pillow Nous présentons un script complet, commenté, qui réalise les mêmes opérations que précédemment. ```python # manipulation_image.py from PIL import Image, ImageEnhance, ImageFilter # 1. Ouverture de l'image img = Image.open("photo.jpg") # supporte JPEG, PNG, BMP, GIF print(f"Taille originale : {img.size}") # (largeur, hauteur) # 2. Redimensionnement à 800 px de largeur tout en conservant le ratio base_width = 800 w_percent = (base_width / float(img.size[0])) h_size = int((float(img.size[1]) * float(w_percent))) img_resized = img.resize((base_width, h_size), Image.LANCZOS) # Lanczos = bonne qualité img_resized.save("photo_redim.jpg") # 3. Rotation de 15° dans le sens anti‑horaire img_rotated = img_resized.rotate(15, expand=True) # expand=True évite le rognage img_rotated.save("photo_rot.jpg") # 4. Recadrage : on garde une zone centrale de 600x400 px left = (img_rotated.width - 600) // 2 top = (img_rotated.height - 400) // 2 right = left + 600 bottom = top + 400 img_cropped = img_rotated.crop((left, top, right, bottom)) img_cropped.save("photo_crop.jpg") # 5. Ajustement luminosité (+20) et contraste (+15%) enhancer_bright = ImageEnhance.Brightness(img_cropped) img_bright = enhancer_bright.enhance(1.2) # facteur 1.0 = original enhancer_contr = ImageEnhance.Contrast(img_bright) img_final = enhancer_contr.enhance(1.15) img_final.save("photo_adjust.jpg") # 6. Application d'un filtre de netteté img_sharp = img_final.filter(ImageFilter.SHARPEN) img_sharp.save("photo_sharp.jpg") print("Traitement terminé.") ``` **Explication ligne par ligne** (à retenir) : > `Image.open()` charge le fichier et renvoie un objet `Image`. > `resize()` prend un tuple `(largeur, hauteur)` et un filtre d’interpolation (`LANCZOS` recommandé pour réduction). > `rotate(angle, expand=True)` effectue une rotation ; `expand=True` agrandit le canevas pour contenir l’image entière. > `crop((left, top, right, bottom))` extrait le rectangle défini par les coordonnées du coin supérieur‑gauche et inférieur‑droit. > `ImageEnhance.Brightness` et `ImageEnhance.Contrast` appliquent un facteur multiplicateur (1.0 = aucune modification). > `filter(ImageFilter.SHARPEN)` applique un noyau de netteté prédéfinis. ### 3. Exemples d’application complète **Exemple 5** : Partir d’une image `satellite.png` de taille 4000×3000 px, produire une vignette de 200×150 px en niveaux de gris, avec un léger flou gaussien (rayon 1) et sauvegarder au format PNG. **Étapes** (script) : ```python from PIL import Image, ImageFilter img = Image.open("satellite.png") img_gray = img.convert("L") # conversion niveaux de gris img_small = img_gray.resize((200,150), Image.LANCZOS) img_blur = img_small.filter(ImageFilter.GaussianBlur(radius=1)) img_blur.save("vignette.png") ``` > **Conversion niveaux de gris** : `convert("L")` applique la formule pondérée vue précédemment. **Exemple 6** : Créer une image synthétique de 500×500 px, remplie d’un dégradé horizontal du noir au blanc, puis superposer un cercle rouge de rayon 50 px au centre. ```python from PIL import Image, ImageDraw # Création du dégradé width, height = 500, 500 img = Image.new("RGB", (width, height)) draw = ImageDraw.Draw(img) for x in range(width): intensity = int(255 * x / (width-1)) # 0 à 255 draw.line([(x,0),(x,height)], fill=(intensity, intensity, intensity)) # Cercle rouge center = (width//2, height//2) radius = 50 draw.ellipse( [(center[0]-radius, center[1]-radius), (center[0]+radius, center[1]+radius)], fill=(255,0,0) ) img.save("degrade_cercle.png") ``` > **Image.new()** crée une toile vierge. > **ImageDraw.Draw()** fournit des primitives de dessin (ligne, ellipse, rectangle, texte). > La boucle sur `x` construit le dégradé ligne par ligne. --- ## Synthèse du chapitre - **Pixel** : unité de base d’une image numérique. - **Résolution** : densité de pixels (ppp). - **Profondeur de couleur** : bits par canal (8 bits → 256 niveaux). - **Formats** : BMP (sans perte), JPEG (avec perte), PNG (sans perte + transparence), GIF (256 couleurs). - **Modèle RGB** : $\mathbf{c}=(R,G,B)^T$, conversion en gris $I=0.299R+0.587G+0.114B$. - **Opérations géométriques** : redimensionnement (interpolation), rotation, recadrage. - **Opérations de point** : luminosité $I' = aI + b$, contraste (facteur multiplicatif). - **Filtrage** : convolution $I*K$ avec noyau (flou moyen, gaussien, netteté). - **Workflow GIMP** : ouverture → propriétés → échelle → rotation → recadrage → luminosité/contraste → filtre → export. - **Workflow Pillow** : `Image.open()` → transformations (`resize`, `rotate`, `crop`, `convert`, `filter`, `ImageEnhance`) → `save()`. - **Bonnes pratiques** : travailler sur une copie, choisir l’interpolation adaptée, vérifier la résolution avant export, privilégier PNG pour les étapes intermédiaires, JPEG uniquement pour la diffusion finale avec qualité ≥80. --- ## Glossaire | Terme | Définition | |-------|------------| | Pixel | Élément minimal d’une image numérique, porteur d’une valeur de couleur ou de niveau de gris. | | Résolution spatiale | Nombre de pixels par unité de longueur (ex. ppp). | | Profondeur de couleur | Nombre de bits utilisés pour coder la couleur d’un canal (ex. 8 bits → 256 niveaux). | | RGB | Modèle additif où une couleur est définie par ses composantes Rouge, Vert, Bleu. | | Niveaux de gris | Image où chaque pixel possède une seule intensité représentant la luminance. | | Compression avec perte | Réduction de taille qui élimine certaines informations (ex. JPEG). | | Compression sans perte | Réduction de taille qui préserve exactement les données originales (ex. PNG). | | Interpolation | Méthode d’estimation de nouvelles valeurs de pixels lors d’un redimensionnement (voisin le plus proche, bilinéaire, bicubique, Lanczos). | | Noyau de convolution | Petite matrice utilisée pour appliquer un filtre (flou, netteté, détection de contours). | | Filtre gaussien | Convolution avec une fonction gaussienne, produit un flou doux qui préserve les contours. | | Histogramme | Répartition du nombre de pixels selon leur intensité de couleur ou de gris. | | Luminosité | Ajout constant à toutes les valeurs de pixel ($I' = I + b$). | | Contraste | Multiplication des écarts autour d’une valeur moyenne ($I' = a(I - I_{moy}) + I_{moy}$). | | Canal alpha | Composante supplémentaire d’une image représentant la transparence (0 = totalement transparent, 255 = opaque). | | Métadonnées EXIF | Informations embarquées dans un fichier image (date, paramètres de l’appareil, GPS, etc.). | --- ## Exercices d'application corrigés ### Exercice 1 – Conversion niveaux de gris **Énoncé** : Une image couleur possède le pixel suivant en RGB : $(R,G,B) = (80, 180, 60)$. Calculer sa valeur en niveaux de gris selon la formule pondérée. **Corrigé** : $$ I = 0.299\times80 + 0.587\times180 + 0.114\times60 = 23.92 + 105.66 + 6.84 = 136.42 \approx 136 $$ Le pixel devient $(136,136,136)$. --- ### Exercice 2 – Redimensionnement avec maintien du ratio **Énoncé** : Une photo de dimensions $3456\times2304$ px doit être redimensionnée à une largeur de $800$ px tout en conservant le rapport hauteur/largeur. Quelle sera la nouvelle hauteur ? **Corrigé** : Facteur d’échelle $k = \dfrac{800}{3456} \approx 0.23148$. Nouvelle hauteur $= 2304 \times k \approx 2304 \times 0.23148 = 533.33 \approx 533$ px (on arrête à l’entier inférieur). Résultat : $800\times533$ px. --- ### Exercice 3 – Rotation et dimensions du canevas **Énoncé** : On tourne une image de $600\times400$ px de $30^\circ$ autour de son centre, avec l’option `expand=True`. Quelles sont les dimensions approximatives du nouveau canevas ? **Corrigé** : Lors d’une rotation, les nouvelles dimensions sont données par : $$ \begin{aligned} w' &= w\cdot|\cos\theta| + h\cdot|\sin\theta|\\ h' &= w\cdot|\sin\theta| + h\cdot|\cos\theta| \end{aligned} $$ Avec $w=600$, $h=400$, $\theta=30^\circ$, $\cos30^\circ=\sqrt{3}/2\approx0.8660$, $\sin30^\circ=0.5$. $$ \begin{aligned} w' &= 600\times0.8660 + 400\times0.5 = 519.6 + 200 = 719.6 \approx 720\text{ px}\\ h' &= 600\times0.5 + 400\times0.8660 = 300 + 346.4 = 646.4 \approx 646\text{ px} \end{aligned} $$ Le canevas devient environ $720\times646$ px. --- ### Exercice 4 – Application d’un filtre de flou gaussien **Énoncé** : On applique un flou gaussien de rayon $\sigma = 2$ à une image où un pixel central vaut $100$ et ses huit voisins immédiats valent tous $50$. Quelle est la valeur approximative du pixel central après le filtre ? (On considère le noyau discret approximatif : poids central $≈0.25$, poids des quatre voisins orthogonaux $≈0.125$, poids des quatre voisins diagonaux $≈0.0625$ – somme = 1). **Corrigé** : Valeur après convolution : $$ \begin{aligned} I' &= 0.25\times100 \\ &\quad + 4\times0.125\times50 \\ &\quad + 4\times0.0625\times50 \\ &= 25 + (4\times0.125\times50)=4\times6.25=25 \\ &\quad + (4\times0.0625\times50)=4\times3.125=12.5 \\ &= 25 + 25 + 12.5 = 62.5 \end{aligned} $$ Résultat ≈ $63$ (on arrondit à l’entier le plus proche). --- ### Exercice 5 – Workflow complet avec Pillow **Énoncé** : Écrire un script Python qui : 1. Ouvre l’image `original.png` (1024×768 px). 2. La convertit en niveaux de gris. 3. La redimensionne à une largeur de 512 px (ratio conservé). 4. Applique un filtre de netteté (`SHARPEN`). 5. Augmente la luminosité de 15 % et le contraste de 10 %. 6. Sauvegarde le résultat sous `resultat.png`. **Corrigé** : ```python from PIL import Image, ImageEnhance, ImageFilter # 1. Ouverture img = Image.open("original.png") print("Taille d'origine :", img.size) # 2. Conversion niveaux de gris img_gray = img.convert("L") # 3. Redimensionnement largeur 512 px w_target = 512 w_percent = (w_target / float(img_gray.size[0])) h_target = int(float(img_gray.size[1]) * w_percent) img_resized = img_gray.resize((w_target, h_target), Image.LANCZOS) # 4. Filtre de netteté img_sharp = img_resized.filter(ImageFilter.SHARPEN) # 5. Ajustement luminosité (+15%) et contraste (+10%) img_bright = ImageEnhance.Brightness(img_sharp).enhance(1.15) img_final = ImageEnhance.Contrast(img_bright).enhance(1.10) # 6. Sauvegarde img_final.save("resultat.png") print("Image traitée enregistrée sous resultat.png") ``` **Justification** : chaque ligne correspond à une étape demandée ; les facteurs d’enhancement sont supérieurs à 1 pour augmenter la propriété. --- ### Exercice 6 – Création d’une image synthétique (dégradé + forme) **Énoncé** : Créer une image de $400\times300$ px comportant un dégradé vertical du bleu foncé $(0,0,100)$ au bleu clair $(100,100,255)$ et un rectangle jaune $(255,255,0)$ de taille $100\times60$ px centré dans l’image. **Corrigé** : ```python from PIL import Image, ImageDraw width, height = 400, 300 img = Image.new("RGB", (width, height)) draw = ImageDraw.Draw(img) # Dégradé vertical : pour chaque ligne y, calculer l'interpolation entre les deux bleus for y in range(height): # t varie de 0 (haut) à 1 (bas) t = y / (height - 1) r = int(0 + (100 - 0) * t) # 0 → 100 g = int(0 + (100 - 0) * t) # 0 → 100 b = int(100 + (255 - 100) * t) # 100 → 255 draw.line([(0, y), (width, y)], fill=(r, g, b)) # Rectangle jaune centré rect_w, rect_h = 100, 60 x0 = (width - rect_w) // 2 y0 = (height - rect_h) // 2 x1 = x0 + rect_w y1 = y0 + rect_h draw.rectangle([x0, y0, x1, y1], fill=(255, 255, 0)) img.save("degrade_rectangle.png") ``` **Explication** : la boucle sur `y` crée un dégradé linéaire entre les deux couleurs spécifiées. Le rectangle est placé en calculant ses coins à partir du centre. --- ## Erreurs fréquentes | # | Erreur | Pourquoi elle se produit | Comment l’éviter | |---|--------|--------------------------|------------------| | 1 | **Confondre résolution (ppp) et nombre de pixels** | L’élève pense que changer la résolution modifie le nombre de pixels, alors que cela n’affecte que l’échelle d’impression. | Toujours distinguer : nombre de pixels = taille de l’image en pixels ; résolution = densité d’impression (ppp). Utiliser `Image.size` pour le nombre de pixels. | | 2 | **Appliquer un filtre de netteté sur une image déjà très bruitée** | Le filtre amplifie le bruit, rendant l’image moins lisible. | Réduire d’abord le bruit (flou gaussien ou médian) avant d’appliquer un netteté, ou utiliser un filtre de netteté adaptatif (ex. Unsharp Mask avec seuil). | | 3 | **Oublier de convertir en niveaux de gris avant d’appliquer un seuil** | Le seuil sur une image couleur travaille sur chaque canal séparément, produisant des résultats inattendus. | Effectuer `img.convert("L")` avant toute opération basée sur l’intensité (seuil, histogramme, binarisation). | | 4 | **Utiliser une interpolation inadaptée lors d’un agrandissement important** | L’interpolation du voisin le plus proche crée un effet d’escalier très visible. | Pour les agrandissements, privilégier `BICUBIC` ou `LANCZOS` ; pour les réductions, `LANCZOS` reste bon. | | 5 | **Ne pas travailler sur une copie de l’image originale** | Toute modification écrasera le fichier source, rendant impossible de revenir en arrière. | Toujours dupliquer l’image (`img.copy()`) ou sauvegarder sous un nouveau nom avant de appliquer des transformations irréversibles. | | 6 | **Ignorer le profil couleur lors de l’export JPEG** | Les couleurs peuvent paraître différentes sur d’autres appareils si le profil sRGB n’est pas embarqué. | Lors de l’export, choisir l’option “Convertir en sRGB” ou “Inclure le profil ICC” dans le logiciel (GIMP : `Fichier → Exporter sous → Options avancées → Profil couleur`). | --- *Fin du cours.*