Photographie numérique - Exercices¶

Exercice 1 - Définitions¶

a. Qu'est-ce qu'un pixel ?

Solution

Un pixel (picture element) est le plus petit élément d'une image numérique. C'est un petit carré de couleur uniforme. L'image entière est une grille rectangulaire composée de millions de pixels.

b. Qu'est-ce que la résolution d'une image ?

Solution

La résolution (ou définition) d'une image est le nombre de pixels qu'elle contient, exprimé en largeur × hauteur. Par exemple, une image de 1920 × 1080 contient environ 2,1 millions de pixels (mégapixels).

c. Expliquer le principe du codage RVB.

Solution

Le codage RVB (Rouge, Vert, Bleu) représente chaque pixel par trois composantes de couleur, chacune codée sur 1 octet (valeurs de 0 à 255). En mélangeant ces trois couleurs lumineuses à différentes intensités (synthèse additive), on peut reconstituer toutes les couleurs visibles, soit environ 16,7 millions de combinaisons.

d. Quelle est la différence entre une compression avec perte et sans perte ?

Solution

La compression sans perte (ex : PNG) réduit la taille du fichier sans perdre aucune information : l'image reconstruite est strictement identique à l'originale. La compression avec perte (ex : JPEG) supprime des détails peu visibles à l'œil pour obtenir des fichiers plus légers, mais l'image reconstruite diffère légèrement de l'originale.

Exercice 2 - Couleurs en RVB¶

1. Donner les composantes RVB des couleurs suivantes : noir, blanc, rouge pur, vert pur, bleu pur.

2. Quelle couleur obtient-on avec les composantes (255, 255, 0) ? Et avec (0, 255, 255) ?

3. Déterminer la couleur approximative des composantes suivantes :

a) (255, 128, 0)
b) (128, 128, 128)
c) (100, 0, 100)

4. Comment obtenir du gris clair en RVB ? Et du gris foncé ?

Solution

1.

Noir : (0, 0, 0)
Blanc : (255, 255, 255)
Rouge pur : (255, 0, 0)
Vert pur : (0, 255, 0)
Bleu pur : (0, 0, 255)

2. (255, 255, 0) = jaune (rouge + vert). (0, 255, 255) = cyan (vert + bleu).

3.

a) (255, 128, 0) = orange (rouge à fond + un peu de vert)
b) (128, 128, 128) = gris moyen (trois composantes égales, à mi-chemin entre noir et blanc)
c) (100, 0, 100) = violet foncé (rouge + bleu, intensité modeste)

4. Gris clair : les trois composantes égales et proches de 255, par exemple (200, 200, 200). Gris foncé : les trois composantes égales et proches de 0, par exemple (50, 50, 50).

Exercice 3 - Code hexadécimal¶

1. Convertir les couleurs RVB suivantes en code hexadécimal :

a) (255, 0, 0)
b) (0, 128, 255)
c) (255, 255, 255)

2. Convertir les codes hexadécimaux suivants en RVB :

a) #00FF00
b) #FF8000
c) #404040

Solution

1.

a) R=255=FF, V=0=00, B=0=00 -> #FF0000 (rouge)
b) R=0=00, V=128=80, B=255=FF -> #0080FF (bleu clair)
c) R=255=FF, V=255=FF, B=255=FF -> #FFFFFF (blanc)

2.

a) R=00=0, V=FF=255, B=00=0 -> (0, 255, 0) = vert pur
b) R=FF=255, V=80=128, B=00=0 -> (255, 128, 0) = orange
c) R=40=64, V=40=64, B=40=64 -> (64, 64, 64) = gris foncé

Exercice 4 - Taille d'une image¶

1. Calculer la taille en octets d'une image non compressée de 1920 x 1080 pixels en RVB.

2. Convertir ce résultat en mégaoctets (Mo).

3. Une carte mémoire de 8 Go peut stocker combien d'images de cette taille (non compressées) ?

4. La même image compressée en JPEG (qualité moyenne) occupe environ 500 ko. Quel est le taux de compression ?

Solution

1. Taille = 1920 × 1080 × 3 = 6 220 800 octets

2. 6 220 800 / 1 048 576 ≈ 5,93 Mo (1 Mo = 1024 × 1024 = 1 048 576 octets)

3. 8 Go = 8 × 1024 = 8 192 Mo. Nombre d'images = 8 192 / 5,93 ≈ 1 381 images.

4. Taux de compression = taille originale / taille compressée = 5,93 Mo / 0,5 Mo ≈ 11,9. L'image est environ 12 fois plus petite en JPEG. On peut aussi dire que la compression a réduit la taille de 91,6 %.

Exercice 5 - Filtres d'image¶

1. Un pixel a les composantes (200, 100, 50). Calculer sa valeur après application des filtres suivants :

a) Niveaux de gris (moyenne des trois composantes)
b) Négatif (255 − chaque composante)
c) Composante rouge seule (V et B mises à 0)

2. Un pixel gris moyen (128, 128, 128) change-t-il après application du filtre négatif ? Justifier.

3. Que se passe-t-il si on applique deux fois le filtre négatif à un pixel ?

Solution

1.

a) Gris = (200 + 100 + 50) / 3 = 116,7 ≈ 117. Le pixel devient (117, 117, 117).
b) Négatif : R = 255−200 = 55, V = 255−100 = 155, B = 255−50 = 205. Le pixel devient (55, 155, 205).
c) Rouge seul : (200, 0, 0).

2. Négatif de (128, 128, 128) = (255−128, 255−128, 255−128) = (127, 127, 127). Le pixel change légèrement (de gris moyen à gris légèrement plus foncé). Seul un pixel parfaitement à (127,5 ; 127,5 ; 127,5) ne changerait pas, mais comme les valeurs sont entières, il y a toujours un léger changement.

3. Le double négatif redonne l'image originale : 255 − (255 − x) = x. Le filtre négatif est son propre inverse.

Exercice 6 - Métadonnées EXIF¶

1. Citer au moins six métadonnées EXIF que l'on peut trouver dans une photo numérique.

2. Un journaliste reçoit une photo par email. Comment peut-il vérifier la date et le lieu de la prise de vue ?

3. Pourquoi est-il recommandé de supprimer les métadonnées EXIF avant de publier une photo sur Internet ?

Solution

1. Six métadonnées : date et heure de la prise de vue, modèle d'appareil photo, résolution de l'image, coordonnées GPS, ouverture du diaphragme, temps d'exposition, sensibilité ISO, orientation (portrait/paysage).

2. Le journaliste peut consulter les métadonnées EXIF de la photo. Sur un ordinateur : clic droit > Propriétés > Détails (Windows). Il y trouvera la date enregistrée par l'appareil et les coordonnées GPS s'il y en a. Attention : ces données peuvent être modifiées, donc elles ne constituent pas une preuve absolue.

3. Les métadonnées EXIF contiennent potentiellement des informations sensibles : la localisation GPS précise du lieu de prise de vue (qui peut révéler l'adresse du domicile), le modèle de l'appareil, et parfois le nom du propriétaire. Supprimer ces données avant publication protège la vie privée.

Exercice 7 - QCM¶

1. Un pixel est codé en RVB sur :

a) 1 octet
b) 2 octets
c) 3 octets
d) 4 octets

2. Combien de couleurs différentes peut-on représenter en RVB 24 bits ?

a) 256
b) 65 536
c) environ 16,7 millions
d) 1 milliard

3. Le format JPEG utilise une compression :

a) sans perte
b) avec perte
c) sans aucune compression
d) réversible

4. La couleur (0, 0, 0) en RVB correspond à :

a) blanc
b) noir
c) rouge
d) gris

5. Les métadonnées EXIF d'une photo peuvent contenir :

a) la position GPS
b) la date de prise de vue
c) le modèle de l'appareil
d) toutes les réponses précédentes

Solution

1. c) 3 octets (1 octet par composante R, V, B)

2. c) environ 16.7 millions (256 x 256 x 256 = 16 777 216)

3. b) avec perte

4. b) noir (aucune lumière)

5. d) toutes les réponses précédentes

Exercice 8 - Manipuler des pixels en Python¶

1. Écrire un programme Python qui crée une image de 200 × 200 pixels avec un dégradé horizontal allant du noir (à gauche) au rouge (à droite).

2. Modifier le programme pour créer un dégradé allant du bleu (en haut) au rouge (en bas).

Solution

from PIL import Image

# 1. Dégradé horizontal noir -> rouge
img1 = Image.new("RGB", (200, 200))
for x in range(200):
    for y in range(200):
        r = int(x * 255 / 199)
        img1.putpixel((x, y), (r, 0, 0))
img1.save("degrade_horizontal.png")

# 2. Dégradé vertical bleu -> rouge
img2 = Image.new("RGB", (200, 200))
for x in range(200):
    for y in range(200):
        r = int(y * 255 / 199)
        b = int((199 - y) * 255 / 199)
        img2.putpixel((x, y), (r, 0, b))
img2.save("degrade_vertical.png")

Exercice 9 - Appliquer un filtre en Python¶

Écrire un programme Python qui :

1. Ouvre une image existante.

2. Applique un filtre négatif (inverse chaque composante RVB).

3. Sauvegarde le résultat.

4. Modifier le programme pour appliquer un filtre qui ne garde que la composante verte (R et B mises à 0).

Solution

from PIL import Image

img = Image.open("photo.jpg")
largeur, hauteur = img.size

# Filtre négatif
img_neg = img.copy()
for x in range(largeur):
    for y in range(hauteur):
        r, g, b = img.getpixel((x, y))
        img_neg.putpixel((x, y), (255 - r, 255 - g, 255 - b))
img_neg.save("photo_negatif.jpg")

# Filtre vert seul
img_vert = img.copy()
for x in range(largeur):
    for y in range(hauteur):
        r, g, b = img.getpixel((x, y))
        img_vert.putpixel((x, y), (0, g, 0))
img_vert.save("photo_vert.jpg")

print("Filtres appliqués avec succès !")

Exercice 10 - Calculer la taille d'images (Python)¶

Écrire un programme Python qui demande à l'utilisateur la largeur et la hauteur d'une image en pixels, puis calcule et affiche :

La définition (nombre total de pixels)
La taille non compressée en octets, ko et Mo
La taille estimée en JPEG (supposer un taux de compression de 10)

Solution

largeur = int(input("Largeur en pixels : "))
hauteur = int(input("Hauteur en pixels : "))

# Définition
nb_pixels = largeur * hauteur
megapixels = nb_pixels / 1_000_000

# Taille non compressée (3 octets par pixel en RVB)
taille_octets = nb_pixels * 3
taille_ko = taille_octets / 1024
taille_mo = taille_ko / 1024

# Taille estimée en JPEG (compression ×10)
taille_jpeg_ko = taille_ko / 10

print(f"\nDéfinition : {largeur} × {hauteur} = {nb_pixels} pixels "
      f"({megapixels:.1f} mégapixels)")
print(f"Taille non compressée : {taille_octets} octets "
      f"({taille_ko:.1f} ko, {taille_mo:.2f} Mo)")
print(f"Taille estimée JPEG : {taille_jpeg_ko:.1f} ko "
      f"({taille_jpeg_ko/1024:.2f} Mo)")

Activités¶

🧪 Activité 1 - Décoder une image pixel par pixel (activité débranchée)¶

Objectif

Comprendre comment une image numérique est stockée en coloriant une grille à partir de valeurs RVB.

Matériel¶

Une grille quadrillée (8 × 8 cases minimum)
Des crayons de couleur

Déroulement¶

1. Voici les valeurs RVB de chaque pixel d'une image 4 × 4 :

	Col 1	Col 2	Col 3	Col 4
Ligne 1	(255,0,0)	(255,0,0)	(255,255,255)	(255,255,255)
Ligne 2	(255,0,0)	(255,0,0)	(255,255,255)	(255,255,255)
Ligne 3	(0,0,255)	(0,0,255)	(0,0,255)	(0,0,255)
Ligne 4	(0,0,255)	(0,0,255)	(0,0,255)	(0,0,255)

Coloriez chaque case de la grille avec la couleur correspondante. Quel drapeau obtenez-vous ?

2. Inventez votre propre image 4 × 4 (motif simple : lettre, smiley, forme géométrique). Écrivez le tableau RVB correspondant et échangez-le avec votre voisin(e) pour qu'il/elle la reconstitue.

3. Combien d'octets faut-il pour stocker cette image 4 × 4 sans compression ?

Correction

1. Les deux premières lignes sont rouges (255,0,0) à gauche et blanches (255,255,255) à droite. Les deux dernières lignes sont entièrement bleues (0,0,255). On obtient une version simplifiée du drapeau français (rouge, blanc, bleu en colonnes).

3. 4 × 4 = 16 pixels, chacun codé sur 3 octets (RVB) = 48 octets.

🧪 Activité 2 - Comparer les formats d'image¶

Objectif

Constater expérimentalement les différences entre les formats BMP, PNG et JPEG en termes de taille et de qualité.

Déroulement¶

1. Prenez une photo avec votre smartphone ou utilisez une image fournie par le professeur.

2. Ouvrez-la dans un logiciel de retouche (GIMP, Photopea, Paint) et enregistrez-la en trois formats :

photo.bmp (bitmap, sans compression)
photo.png (compression sans perte)
photo.jpg à qualité 90 %
photo_basse.jpg à qualité 20 %

3. Comparez les tailles des fichiers obtenus et complétez le tableau :

Format	Taille du fichier	Qualité visuelle
BMP
PNG
JPEG 90 %
JPEG 20 %

4. Calculez le taux de compression pour chaque format par rapport au BMP.

5. Zoomez sur un détail de l'image dans chaque version. Observez-vous des différences ? Lesquelles ?

Correction

Le BMP est le plus volumineux (aucune compression). Le PNG est plus léger mais reste fidèle (compression sans perte). Le JPEG 90 % est nettement plus petit avec une qualité visuellement identique. Le JPEG 20 % est très petit mais présente des artefacts de compression visibles au zoom : blocs carrés, contours flous, couleurs dégradées. C'est le compromis taille/qualité du JPEG.

🧪 Activité 3 - Enquête sur les métadonnées EXIF¶

Objectif

Prendre conscience des informations personnelles contenues dans les métadonnées d'une photo.

Déroulement¶

1. Prenez une photo avec votre smartphone (en activant la géolocalisation si possible).

2. Transférez-la sur l'ordinateur et consultez ses métadonnées EXIF :

Windows : clic droit > Propriétés > Détails
En ligne : utilisez exif.tools ou un outil équivalent
Python : utilisez la bibliothèque PIL (voir ci-dessous)

3. Relevez au moins 8 métadonnées différentes dans un tableau :

Métadonnée	Valeur
Date
Heure
Modèle d'appareil
Résolution
GPS - Latitude
GPS - Longitude
...

4. Localisez les coordonnées GPS sur une carte (Google Maps, Géoportail). Le lieu est-il correct ?

5. Supprimez les métadonnées de la photo (clic droit > Propriétés > Détails > « Supprimer les propriétés et informations personnelles »). Vérifiez qu'elles ont bien été supprimées.

6. Expliquez en 3-4 phrases pourquoi il est important de supprimer les métadonnées avant de publier une photo en ligne.

Correction

from PIL import Image
from PIL.ExifTags import TAGS

img = Image.open("photo.jpg")
exif = img._getexif()

if exif:
    for tag_id, valeur in exif.items():
        tag = TAGS.get(tag_id, tag_id)
        print(f"{tag} : {valeur}")

6. Les métadonnées EXIF contiennent des informations sensibles : les coordonnées GPS révèlent le lieu exact de la prise de vue (domicile, lieu de travail), le modèle d'appareil peut servir à identifier le propriétaire, et la date/heure renseignent sur les habitudes. Publier une photo avec ces données expose à des risques pour la vie privée. Il est recommandé de les supprimer systématiquement avant tout partage en ligne.

🎯 Projet final - Créer un filtre photo en Python¶

Objectif

Programmer un outil de traitement d'image qui applique plusieurs filtres au choix sur une photo.

Consignes¶

Écrire un programme Python qui :

1. Ouvre une image choisie par l'utilisateur.

2. Propose un menu avec au moins 4 filtres parmi :

Niveaux de gris
Négatif
Composante rouge / verte / bleue seule
Augmenter la luminosité
Réduire la taille (redimensionner)
Effet miroir (horizontal ou vertical)
Effet pixelisé (mosaïque)

3. Applique le filtre choisi et sauvegarde le résultat.

4. Affiche les métadonnées EXIF de l'image originale.

Barème indicatif¶

Critère	Points
Ouverture correcte de l'image	/2
Menu fonctionnel avec au moins 4 filtres	/8
Filtres correctement implémentés (pixel par pixel)	/4
Sauvegarde du résultat	/2
Affichage des métadonnées EXIF	/2
Qualité du code (noms de variables, fonctions)	/2
Total	/20

Correction

from PIL import Image
from PIL.ExifTags import TAGS

def niveaux_de_gris(img):
    resultat = img.copy()
    largeur, hauteur = resultat.size
    for x in range(largeur):
        for y in range(hauteur):
            r, g, b = resultat.getpixel((x, y))
            gris = (r + g + b) // 3
            resultat.putpixel((x, y), (gris, gris, gris))
    return resultat

def negatif(img):
    resultat = img.copy()
    largeur, hauteur = resultat.size
    for x in range(largeur):
        for y in range(hauteur):
            r, g, b = resultat.getpixel((x, y))
            resultat.putpixel((x, y), (255 - r, 255 - g, 255 - b))
    return resultat

def composante_seule(img, composante):
    resultat = img.copy()
    largeur, hauteur = resultat.size
    for x in range(largeur):
        for y in range(hauteur):
            r, g, b = resultat.getpixel((x, y))
            if composante == "r":
                resultat.putpixel((x, y), (r, 0, 0))
            elif composante == "g":
                resultat.putpixel((x, y), (0, g, 0))
            else:
                resultat.putpixel((x, y), (0, 0, b))
    return resultat

def miroir_horizontal(img):
    resultat = img.copy()
    largeur, hauteur = resultat.size
    for x in range(largeur):
        for y in range(hauteur):
            pixel = img.getpixel((largeur - 1 - x, y))
            resultat.putpixel((x, y), pixel)
    return resultat

def afficher_exif(img):
    exif = img._getexif()
    if exif:
        print("\nMetadonnees EXIF :")
        for tag_id, valeur in exif.items():
            tag = TAGS.get(tag_id, tag_id)
            print(f"  {tag} : {valeur}")
    else:
        print("\nAucune metadonnee EXIF trouvee.")

# Programme principal
chemin = input("Chemin de l'image : ")
img = Image.open(chemin)
afficher_exif(img)

print("\nFiltres disponibles :")
print("  1 - Niveaux de gris")
print("  2 - Negatif")
print("  3 - Composante rouge seule")
print("  4 - Miroir horizontal")

choix = input("\nVotre choix (1-4) : ")

if choix == "1":
    resultat = niveaux_de_gris(img)
elif choix == "2":
    resultat = negatif(img)
elif choix == "3":
    resultat = composante_seule(img, "r")
elif choix == "4":
    resultat = miroir_horizontal(img)
else:
    print("Choix invalide.")
    exit()

nom_sortie = "resultat_filtre.png"
resultat.save(nom_sortie)
print(f"Image sauvegardee : {nom_sortie}")