Aller au contenu

Exercices#

La photographie numérique

Mode d’emploi

  • Niveau : ★ échauffement, ★★ classique (niveau bac), ★★★ défi ; les coups de pouce et les corrigés se déplient sous chaque exercice.

  • sur papier signale les exercices à faire sur papier ; ▶ ceux où l’on écrit et teste un vrai programme (Spyder ou Basthon, avec la bibliothèque PIL).

  • Rappel utile : une couleur \(=\) trois nombres RVB entre \(0\) et \(255\) ; le pixel \((0,0)\) est en haut à gauche.

  • Usage de l’IA, indiqué sur chaque exercice : aucune ; en appui (déboguer, reformuler, vérifier ; la réponse finale est écrite et comprise par vous) ; l’exercice s’appuie sur une réponse d’IA. Voir la charte d’usage de l’IA.

Le capteur et la formation de l’image#

★ Exercice 1 — Vrai ou faux #

• essentiel

sur papier Répondre par vrai ou faux, et corriger les phrases fausses.

  1. Un photosite mesure une couleur et la transforme directement en trois nombres.

  2. Il y a autant de filtres rouges que de filtres verts sur un capteur.

  3. Sans filtre de couleur, un capteur donnerait une image en niveaux de gris.

  4. Plus un photosite reçoit de lumière, plus le nombre qu’il produit est grand.

Coup de pouce

Relisez la partie du cours sur le capteur et le schéma du filtre de Bayer : que mesure un photosite à lui seul ? Comptez les filtres de chaque couleur dans un groupe de quatre.

Corrigé

Réponses aux questions fermées ; pour les questions ouvertes, des pistes attendues (d’autres formulations sont possibles).

Activité 1 — Expliquer le capteur

Production personnelle. Éléments attendus : le capteur est un quadrillage de millions de photosites ; chacun reçoit de la lumière à travers un petit filtre rouge, vert ou bleu (le filtre de Bayer, avec deux fois plus de filtres verts) et la transforme en un nombre, d’autant plus grand que la lumière est intense ; l’appareil combine ensuite les mesures voisines pour obtenir les trois valeurs R, V, B de chaque pixel.

Activité 2 — Jouer avec les couleurs

  1. \(256 \times 256 \times 256 = 256^3 = \mathbf{16\,777\,216}\) couleurs (environ \(16{,}8\) millions).

  2. Noir \((0,0,0)\) ; blanc \((255,255,255)\) ; jaune \((255,255,0)\) ; violet \((255,0,255)\).

  3. \((125,125,125)\) : un gris moyen (trois canaux égaux) ; \((30,30,30)\) : un gris très foncé, presque noir.

Activité 3 — Calculer sur les images

  1. \(20\) cm \(= 20 \div 2{,}54 \approx 7{,}87\) pouces, et \(1200 \div 7{,}87 \approx \mathbf{152}\) ppp (même résultat en hauteur : \(15\) cm \(\approx 5{,}91\) pouces et \(900 \div 5{,}91 \approx 152\)).

  2. \(15\) cm \(\approx 5{,}91\) pouces, soit \(5{,}91 \times 300 \approx 1772\) pixels ; \(10\) cm \(\approx 3{,}94\) pouces, soit \(3{,}94 \times 300 \approx 1181\) pixels. Il faut une définition d’au moins \(\mathbf{1772 \times 1181}\) environ (de l’ordre de \(2\) mégapixels).

  3. \(4000 \times 3000 \times 3 = 36\,000\,000\) octets, soit \(\mathbf{36}\) Mo.

Activité 4 — Ses premières retouches

  1. On remplace les coordonnées dans la ligne de lecture : r, v, b = img.getpixel((250, 300)).

  2. Chaque pixel prend pour rouge son ancien vert, pour vert son ancien bleu et pour bleu son ancien rouge : les couleurs sont permutées (ce qui était bleu devient vert, le rouge devient bleu, le vert devient rouge).

  3. Négatif : dans le programme à deux boucles du cours, on remplace la ligne putpixel par img.putpixel((x, y), (255 - r, 255 - v, 255 - b)) (l’exercice « Le négatif » applique la même ligne à la moitié gauche de l’image seulement).

  4. Niveaux de gris : dans les deux boucles, on calcule gris = (r + v + b) // 3, puis on écrit le pixel (gris, gris, gris) (l’exercice « Niveaux de gris » utilise une autre formule, qui tient compte de la sensibilité de l’œil).

Activité 5 — Enquêter sur une photo

  1. Les valeurs dépendent de la photo fournie : la date se lit sur la ligne DateTime, le fabricant sur la ligne Make (et le modèle sur Model), la définition sur la ligne definition affichée en premier (largeur, hauteur).

  2. Les coordonnées GPS permettent de situer la prise de vue sur une carte : en publiant la photo, on peut révéler sans le vouloir son domicile, son école ou ses habitudes (et, avec la date, quand on y était).

a. Faux. Un photosite ne mesure qu’une seule composante (une quantité de lumière derrière un filtre rouge, vert ou bleu) ; les trois nombres RVB d’un pixel sont reconstitués ensuite à partir des photosites voisins (dématriçage).
b. Faux. Dans le filtre de Bayer, il y a deux fois plus de filtres verts que de rouges ou de bleus (l’œil humain est plus sensible au vert).
c. Vrai. Sans filtre coloré, chaque photosite ne mesurerait qu’une intensité lumineuse : on obtiendrait une image en niveaux de gris.
d. Vrai. Plus un photosite reçoit de lumière, plus la valeur numérique produite est grande (proche de \(255\)).

Le pixel et le codage RVB#

★ Exercice 2 — Nommer la couleur #

• essentiel

sur papier Donner la couleur obtenue par chacun des codes RVB suivants :

\((255,0,0)\) \((0,0,0)\) \((255,255,255)\) \((0,255,0)\) \((255,255,0)\) \((40,40,40)\).

Coup de pouce

Pour chaque code, repérez les canaux « allumés » (proches de \(255\)) et les canaux « éteints » (\(0\)), puis aidez-vous du schéma de la synthèse additive du cours.

Corrigé

\((255,0,0)\) : rouge ; \((0,0,0)\) : noir ; \((255,255,255)\) : blanc ; \((0,255,0)\) : vert ; \((255,255,0)\) : jaune (rouge \(+\) vert) ; \((40,40,40)\) : un gris foncé (les trois canaux égaux et faibles).

★ Exercice 3 — Coder une couleur #

sur papier Donner un code RVB plausible pour : un gris clair, du cyan (vert + bleu), un bleu très sombre, un vert moyen (le vert seul, à moitié de sa force), de l’orange (beaucoup de rouge, un peu moins de vert), un rose pâle (du rouge éclairci par du blanc).

Coup de pouce

Partez des couleurs de l’exemple du cours et du schéma de la synthèse additive. Pour un gris, que doivent avoir en commun les trois nombres ? Pour une couleur sombre, les nombres sont-ils petits ou grands ? Pour éclaircir une couleur, on lui « ajoute du blanc » : que deviennent les canaux qui valaient \(0\) ?

Corrigé

Exemples plausibles. Gris clair \((200,200,200)\) (trois canaux égaux et assez grands) ; cyan \((0,255,255)\) (vert \(+\) bleu) ; bleu très sombre \((0,0,60)\) ; vert moyen \((0,128,0)\) ; orange \((255,140,0)\) ; rose pâle \((255,200,200)\) : le rouge reste au maximum, et le vert et le bleu, égaux, sont montés pour « blanchir » la couleur (avec \(255\) partout, on obtiendrait du blanc).

★★ Exercice 4 — Combien de couleurs ? #

• essentiel

sur papier Un ancien format d’image codait chaque canal (R, V, B) par une valeur entière de \(0\) à \(15\) seulement, soit \(16\) possibilités.

  1. Combien de couleurs différentes peut-on coder en tout ? Donner le calcul.

  2. Combien de nuances de gris peut-on coder (les trois canaux égaux) ?

Coup de pouce

Pour chaque valeur du rouge, on peut choisir n’importe quelle valeur du vert, puis n’importe quelle valeur du bleu : les possibilités se multiplient. Pour un gris, une fois le rouge choisi, reste-t-il un choix pour le vert et le bleu ?

Corrigé

1. Chaque canal a \(16\) valeurs, et il y a trois canaux indépendants : $\(16 \times 16 \times 16 = 16^3 = \mathbf{4\,096} \text{ couleurs},\)$ bien moins que les \(256^3 = 16\,777\,216\) couleurs du codage de \(0\) à \(255\) (activité 2 du cours) : \(4\,096\) fois moins.
2. Un gris a ses trois canaux égaux : il y a donc autant de gris que de valeurs communes possibles, soit 16 nuances (du noir au blanc).

▷ Erreur fréquente. Additionner au lieu de multiplier : \(16 + 16 + 16 = 48\). Or chaque valeur du rouge peut s’associer à chacune des \(16\) valeurs du vert, et chaque couple à chacune des \(16\) valeurs du bleu : les possibilités se multiplient.

Définition, résolution et poids#

★★ Exercice 5 — Compter les pixels #

• essentiel

sur papier Une image a pour définition \(1920 \times 1080\).

  1. Combien de pixels contient-elle ? Donner un ordre de grandeur en millions.

  2. Calculer son poids brut (3 octets par pixel), en méga-octets (\(1\) Mo \(\approx 10^6\) octets).

Coup de pouce

Nombre de pixels \(=\) largeur \(\times\) hauteur. Poids brut \(=\) nombre de pixels \(\times 3\) octets ; divisez ensuite par \(10^6\) pour obtenir des Mo.

Corrigé

1. \(1920 \times 1080 = \mathbf{2\,073\,600}\) pixels, soit environ 2 millions (2 mégapixels).
2. Poids brut \(= 3 \text{ octets} \times 2\,073\,600 = 6\,220\,800\) octets \(\approx \mathbf{6{,}2}\) Mo.

★★ Exercice 6 — Doubler la définition #

sur papier L’image A a pour définition \(800 \times 600\) ; l’image B, la même scène photographiée en « double définition », mesure \(1600 \times 1200\).

  1. Combien de pixels contient chaque image ?

  2. Combien de fois plus de pixels l’image B contient-elle ? Est-ce « deux fois plus » ?

  3. Calculer le poids brut de l’image B en Mo (\(3\) octets par pixel).

Coup de pouce

Calculez le nombre de pixels de chaque image (largeur \(\times\) hauteur) avant de comparer : la largeur double, mais la hauteur aussi.

Corrigé

1. Image A : \(800 \times 600 = \mathbf{480\,000}\) pixels. Image B : \(1600 \times 1200 = \mathbf{1\,920\,000}\) pixels.
2. \(1\,920\,000 \div 480\,000 = \mathbf{4}\) : B contient quatre fois plus de pixels, et non deux. La largeur et la hauteur ont doublé : \(2 \times 2 = 4\).
3. Poids brut de B \(= 1\,920\,000 \times 3 = 5\,760\,000\) octets \(\approx \mathbf{5{,}8}\) Mo (quatre fois le poids brut de A, \(1{,}44\) Mo).

▷ Erreur fréquente. Répondre « deux fois plus de pixels » parce que la définition « double » : la largeur double et la hauteur double, donc le nombre de pixels est multiplié par \(2 \times 2 = 4\).

★★ Exercice 7 — Résolution d’une impression #

• essentiel

sur papier On imprime une photo de définition \(1500 \times 1000\) sur du papier de \(12{,}7 \times 8{,}47\) cm.

  1. Convertir la largeur en pouces (\(1\) pouce \(=2{,}54\) cm).

  2. En déduire la résolution de l’impression en ppp. Le résultat convient-il pour une « belle » impression (environ \(300\) ppp) ?

Coup de pouce

Largeur en pouces \(=\) largeur en cm divisée par \(2{,}54\). La résolution est un nombre de pixels par pouce : divisez le nombre de pixels de la largeur par la largeur en pouces.

Corrigé

1. \(12{,}7~\text{cm} \div 2{,}54 = \mathbf{5}\) pouces.
2. Résolution \(= \dfrac{1500 \text{ pixels}}{5 \text{ pouces}} = \mathbf{300}\) ppp. C’est exactement la valeur visée pour une « belle » impression : le résultat convient. (En hauteur : \(8{,}47~\text{cm} \approx 3{,}33\) pouces, et \(1000 / 3{,}33 \approx 300\) ppp également.)

▷ Erreur fréquente. Diviser les pixels par la largeur en centimètres : \(1500 \div 12{,}7 \approx 118\). On obtient des pixels par centimètre, pas des pixels par pouce ; il faut d’abord convertir en pouces.

★★★ Exercice 8 — Imprimer en grand #

≈ 15 min

sur papier Un appareil photo donne des images de \(4000 \times 3000\) pixels.

  1. Quelle est la plus grande taille d’impression (en cm) possible pour une « belle » impression à \(300\) ppp ?

  2. On veut en faire une affiche de \(60\) cm de large. Quelle sera la résolution de l’impression ? Est-ce une « belle » impression ? Pourquoi est-ce malgré tout acceptable pour une affiche ?

Coup de pouce

À \(300\) ppp, chaque pouce imprimé utilise \(300\) pixels : combien de pouces peut-on remplir avec les \(4000\) pixels de la largeur ?

Coup de pouce 2 (début de solution)

Largeur : \(4000 / 300 \approx 13{,}3\) pouces, à convertir en cm (multiplier par \(2{,}54\)). Faites de même pour la hauteur. Pour l’affiche, convertissez d’abord \(60\) cm en pouces.

Corrigé

1. À \(300\) ppp, chaque pouce imprimé utilise \(300\) pixels. Largeur : \(4000 \div 300 \approx 13{,}3\) pouces, soit \(13{,}3 \times 2{,}54 \approx \mathbf{34}\) cm. Hauteur : \(3000 \div 300 = 10\) pouces, soit \(\mathbf{25{,}4}\) cm. La plus grande « belle » impression mesure donc environ \(\mathbf{34 \times 25}\) cm.
2. \(60\) cm \(= 60 \div 2{,}54 \approx 23{,}6\) pouces, et \(4000 \div 23{,}6 \approx \mathbf{170}\) ppp. C’est nettement moins que \(300\) ppp : ce n’est pas une « belle » impression au sens strict. Mais une affiche se regarde de loin : à quelques mètres, l’œil ne distingue plus les pixels, et \(170\) ppp suffisent largement.

★★ Exercice 9 — Compression #

sur papier Une photo \(4000 \times 3000\) pèse, en réalité, \(4\) Mo sur la carte mémoire, alors que son poids « brut » est bien plus grand. Calculer le poids brut, puis expliquer d’où vient la différence.

Coup de pouce

Calculez le poids brut comme à l’exercice « Compter les pixels », puis comparez-le aux \(4\) Mo. Quel traitement le format JPEG fait-il subir à l’image ?

Corrigé

Poids brut \(= 4000 \times 3000 \times 3 = 36\,000\,000\) octets \(= \mathbf{36}\) Mo. Sur la carte, la photo ne pèse que \(4\) Mo, soit 9 fois moins : c’est l’effet de la compression (format JPEG). Elle supprime des détails peu perceptibles par l’œil (compression avec pertes) pour réduire fortement la taille du fichier.

Modifier une image par programme (PIL)#

★★ Exercice 10 — Lire un pixel #

▶ À l’aide de l’image terre.jpg du cours (« The Blue Marble »), écrire un programme qui affiche les trois canaux R, V, B du pixel de coordonnées \((120, 200)\).

Coup de pouce

Repartez du premier programme du cours : Image.open, puis getpixel((x, y)), qui renvoie les trois canaux du pixel.

Corrigé 
from PIL import Image
img = Image.open("terre.jpg").convert("RGB")
r, v, b = img.getpixel((120, 200))
print("Rouge :", r, " Vert :", v, " Bleu :", b)

getpixel((x, y)) renvoie le triplet RVB du pixel ; on l’affiche.

★★ Exercice 11 — Que fait ce programme ? #

sur papier On considère le programme suivant, appliqué à une image de \(500 \times 500\) :

from PIL import Image
img = Image.open("terre.jpg")
for y in range(500):
    for x in range(500):
        r, v, b = img.getpixel((x, y))
        img.putpixel((x, y), (0, v, b))
img.show()

  1. Que fait ce programme pour chaque pixel ?

  2. Quel sera l’effet visible sur l’image ? Justifier.

Coup de pouce

Comparez le triplet lu, (r, v, b), et le triplet écrit : quel canal a changé, et quelle valeur prend-il ?

Corrigé

1. Pour chaque pixel, il lit ses valeurs \((r, v, b)\) puis les réécrit en mettant le rouge à \(0\) : \((0, v, b)\). Il supprime la composante rouge de toute l’image.
2. L’image perd tout son rouge : elle tire vers le cyan (bleu-vert). Sur terre.jpg, les tons chauds disparaissent et l’image paraît plus froide et bleutée.

★★ Exercice 12 — Le négatif #

• essentiel

▶ Écrire un programme qui transforme en négatif (chaque canal \(c\) est remplacé par \(255-c\)) seulement la moitié gauche de terre.jpg ; la moitié droite reste intacte. Tester, puis afficher le résultat.

Coup de pouce

Reprenez le programme à deux boucles du cours (celui qui décale les canaux). Deux changements : la ligne putpixel, et les valeurs que prend x (jusqu’où aller pour rester dans la moitié gauche ?).

Corrigé

On remplace chaque canal \(c\) par \(255 - c\), mais seulement pour les colonnes de la moitié gauche : x ne prend que les valeurs de \(0\) à largeur // 2 - 1.

from PIL import Image
img = Image.open("terre.jpg").convert("RGB")
largeur, hauteur = img.size
for y in range(hauteur):
    for x in range(largeur // 2):     # moitie gauche seulement
        r, v, b = img.getpixel((x, y))
        img.putpixel((x, y), (255 - r, 255 - v, 255 - b))
img.show()

Autre solution : garder range(largeur) et ne modifier le pixel que if x < largeur // 2:. Sur terre.jpg (\(500 \times 500\)), l’espace noir devient blanc à gauche et reste noir à droite : par exemple, le pixel \((10, 250)\), qui valait \((3, 1, 4)\), devient \((252, 254, 251)\).

▷ Erreur fréquente. Écrire range(largeur / 2) : la division / donne un nombre à virgule (250.0), que range refuse (TypeError). Il faut la division entière //.

★★ Exercice 13 — Éclaircir l’image #

▶ Écrire un programme qui éclaircit terre.jpg en ajoutant \(60\) à chacun des trois canaux de chaque pixel. Attention, un canal ne peut pas dépasser \(255\) : on écrira par exemple min(255, r + 60), qui vaut le plus petit des deux nombres. Que deviennent les zones déjà très claires ?

Coup de pouce

Même structure que le négatif : seul le calcul de la nouvelle couleur change, canal par canal.

Corrigé

On ajoute \(60\) à chaque canal, sans dépasser \(255\) grâce à min.

from PIL import Image
img = Image.open("terre.jpg").convert("RGB")
largeur, hauteur = img.size
for y in range(hauteur):
    for x in range(largeur):
        r, v, b = img.getpixel((x, y))
        img.putpixel((x, y), (min(255, r + 60), min(255, v + 60), min(255, b + 60)))
img.show()

Les zones déjà très claires (canaux proches de \(255\)) sont bloquées à \(255\) : elles deviennent blanches et leurs détails disparaissent (on dit que l’image est « brûlée »). Le fond noir de l’espace, lui, devient gris foncé (par exemple \((5, 3, 6)\) devient \((65, 63, 66)\)).

★★★ Exercice 14 — Niveaux de gris #

≈ 15 min

▶ Notre œil est plus sensible au vert (c’est pourquoi le filtre de Bayer compte deux fois plus de filtres verts). Écrire un programme qui rend l’image grise en en tenant compte : remplacer R, V et B par \(m = (3r + 6v + b)\ //\ 10\). Vérifier qu’une image grise a bien ses trois canaux égaux. Calculer enfin à la main \(m\) pour le pixel \((100, 200, 50)\), et le comparer à la simple moyenne \((r+v+b)\ //\ 3\) vue dans le cours.

Coup de pouce

Deux boucles, comme pour le négatif. Dans la boucle, calculez d’abord m, puis écrivez un pixel dont les trois canaux valent m.

Coup de pouce 2 (début de solution)

Dans les deux boucles :
r, v, b = img.getpixel((x, y))
m = (3 * r + 6 * v + b) // 10
(il reste à écrire le pixel gris avec putpixel.)

Corrigé

On remplace R, V, B par la valeur \(m\) ; les trois canaux deviennent égaux, donc le pixel est gris.

from PIL import Image
img = Image.open("terre.jpg").convert("RGB")
largeur, hauteur = img.size
for y in range(hauteur):
    for x in range(largeur):
        r, v, b = img.getpixel((x, y))
        m = (3 * r + 6 * v + b) // 10
        img.putpixel((x, y), (m, m, m))
img.show()

Vérification : après ce traitement, tout pixel vaut \((m, m, m)\) — ses trois canaux sont bien égaux, ce qui caractérise un gris. Pour le pixel \((100, 200, 50)\) : \(m = (300 + 1200 + 50) // 10 = 1550 // 10 = \mathbf{155}\), alors que la simple moyenne donne \(350 // 3 = \mathbf{116}\). Ce pixel, surtout vert, paraît clair à l’œil : la formule pondérée le rend plus fidèlement. Les coefficients \(3 + 6 + 1\) font \(10\) : un pixel déjà gris \((g, g, g)\) garde la valeur \(g\).

▷ Erreur fréquente. Oublier les parenthèses : m = 3 * r + 6 * v + b // 10 ne divise que b par \(10\) (la division passe avant l’addition). Un test sur un pixel connu, par exemple \((90, 90, 90)\), montre l’erreur : on trouve \(819\) au lieu de \(90\), une valeur impossible pour un canal, qui ne dépasse jamais \(255\).

★★★ Exercice 15 — Le miroir #

≈ 20 min

▶ Écrire un programme qui retourne terre.jpg comme dans un miroir : la colonne de gauche passe à droite, et inversement. On ne crée pas de nouvelle image : on échange les pixels deux à deux.

Coup de pouce

Le pixel de la colonne x échange sa place avec celui de la colonne largeur - 1 - x, sur la même ligne. Ne parcourez que la moitié gauche de l’image, sinon chaque échange serait aussitôt défait.

Coup de pouce 2 (début de solution)

for y in range(hauteur):
for x in range(largeur // 2):
gauche = img.getpixel((x, y))
droite = img.getpixel((largeur - 1 - x, y))

Corrigé

Sur chaque ligne, le pixel de la colonne x échange sa place avec celui de la colonne symétrique largeur - 1 - x (la colonne \(0\) avec la dernière, la colonne \(1\) avec l’avant-dernière, etc.). On ne parcourt que la moitié gauche : si l’on allait jusqu’au bout, chaque paire serait échangée deux fois et l’image reviendrait à l’identique.

from PIL import Image
img = Image.open("terre.jpg").convert("RGB")
largeur, hauteur = img.size
for y in range(hauteur):
    for x in range(largeur // 2):
        gauche = img.getpixel((x, y))
        droite = img.getpixel((largeur - 1 - x, y))
        img.putpixel((x, y), droite)                  # on echange
        img.putpixel((largeur - 1 - x, y), gauche)    # les deux pixels
img.show()

Les deux valeurs sont lues avant d’écrire : si l’on écrivait d’abord à gauche, la couleur d’origine de ce pixel serait perdue.

Métadonnées et vie privée#

★ Exercice 16 — Les données cachées #

• essentiel

sur papier

  1. Qu’appelle-t-on les métadonnées EXIF d’une photo ? Citer trois informations qu’elles peuvent contenir.

  2. En quoi la présence de coordonnées GPS dans une photo publiée peut-elle poser un problème de vie privée ?

  3. Proposer une précaution simple avant de partager une photo prise au smartphone.

Coup de pouce

Relisez dans le cours la définition des métadonnées EXIF, le tableau d’exemple et la règle qui le suit.

Corrigé

1. Les métadonnées EXIF sont des informations enregistrées automatiquement dans le fichier photo, en plus des pixels. Exemples : date et heure de la prise, modèle d’appareil (ou de smartphone), réglages (ouverture, temps de pose, ISO), et souvent les coordonnées GPS.
2. Si une photo publiée contient les coordonnées GPS, n’importe qui peut savoir où (et quand) elle a été prise : domicile, école, lieux fréquentés. C’est une atteinte à la vie privée et à la sécurité.
3. Précaution : désactiver la géolocalisation de l’appareil photo, ou supprimer les métadonnées (EXIF) de la photo avant de la partager.

★ Exercice 17 — Une photo est-elle une preuve ? #

sur papier « Puisque c’est une photo, c’est forcément vrai. » Discuter cette affirmation en une ou deux phrases (on pourra parler de retouche, de filtres et d’images générées par IA).

Coup de pouce

Pensez à tout ce qui peut modifier une image entre la prise de vue et sa publication, et à la partie du cours sur les images calculées par les smartphones.

Corrigé

Non, pas à elle seule. Une image peut être retouchée, passée par des filtres, sortie de son contexte, ou entièrement générée par une IA. Une photo est un indice, pas une preuve absolue : il faut la recouper avec d’autres sources.

Critiquer une réponse d’IA#

★★ Exercice 18 — Poids et résolution selon un assistant #

sur papier Un élève a demandé à un assistant d’IA : « Mon téléphone prend des photos de \(6000 \times 4000\) pixels. Combien pèsent-elles, et puis-je les imprimer en \(30 \times 20\) cm ? » Voici la réponse obtenue :

Votre photo contient \(6000 \times 4000 = 24\,000\,000\) pixels, soit 24 mégapixels. Chaque pixel est codé par trois nombres (rouge, vert, bleu) sur un octet chacun, donc 3 octets par pixel : le poids brut est \(24\,000\,000 \times 3 = 72\,000\,000\) octets, soit 72 Mo. En pratique, le fichier JPEG est compressé et pèse plutôt 5 à 10 Mo. Pour l’impression, aucune inquiétude : sur une largeur de 30 cm, la résolution de votre photo est de 6000 ppp, bien au-dessus des 300 ppp recommandés.

  1. La réponse est-elle correcte ? Refaire chaque calcul (rappel : \(1\) pouce \(=2{,}54\) cm).

  2. Localiser l’erreur, nommer la notion confondue et donner la valeur juste.

    Coup de pouce

    Relisez la définition de la résolution dans le cours : en quelle unité s’exprime-t-elle ? Convertissez \(30\) cm en pouces.

  3. Quelle vérification simple, faite avant de faire confiance à cette réponse, aurait suffi à détecter l’erreur ?

Corrigé

1. Le début est juste : \(6000 \times 4000 = 24\,000\,000\) pixels (24 Mpx), \(3\) octets par pixel, donc \(72\,000\,000\) octets \(\approx 72\) Mo brut, réduits par la compression JPEG. En revanche, \(30\) cm \(= 30 / 2{,}54 \approx 11{,}8\) pouces, et \(6000 / 11{,}8 \approx \mathbf{508}\) ppp, pas \(6000\).
2. L’assistant a confondu la définition (le nombre de pixels : \(6000\) en largeur) et la résolution (le nombre de pixels par pouce) ; le cours précise : « la résolution est le nombre de pixels par unité de longueur ». La valeur juste est environ \(508\) ppp — la conclusion (impression de bonne qualité) reste vraie, mais le nombre est faux.
3. Un ordre de grandeur suffisait : \(6000\) ppp sur \(11{,}8\) pouces exigerait \(6000 \times 11{,}8 \approx 71\,000\) pixels de large, près de douze fois plus que la photo n’en possède (\(71\,000 / 6000 \approx 11{,}8\)). Dès qu’une réponse annonce une résolution, vérifier l’unité (pixels par pouce) et refaire la division.