Ci-dessus quelques repères historiques de la photo numérique présentés sous la forme d'une frise :

histoire_photographie


Au cours de ce thème vous aurez à utilisez le logiciel GIMP, logiciel libre et gratuit qui vous permettra de visualiser des images et surtout de les retoucher. Pour l'installer, il vous suffit de suivre le tutoriel présent dans le document téléchargeable ici.

La version de GIMP la plus récente est la 2.10.22 et non plus celle du tutoriel mais la démarche à suivre reste strictement la même.

Partie 1 : L'oeil et le capteur numérique

L'oeil et le capteur photographique

1.1.1 La vision humaine

Les rayons lumineux provenant d'un objet sont projetés au fond de l'oeil sur la rétine.
Celle-ci comprend des cellules sensibles à la lumière : les cônes. certains cônes perçoivent la couleur rouge, d'autres la couleur verte et d'autres la couleur bleue. Les cônes sensibles au vert sont les plus présents chez l'être humain. Ils transforment l'énergie lumineuse en impulsion électrique. Cette impulsion est transmise au cerveau par l'intermédiaire du nerf optique. La couleur est ensuite reconstituée par le cerveau par addition du rouge, du vert et du bleu.

pixels

1.1.2 L'appareil photo numérique

Les rayons lumineux provenant d'un objet sont projetés dans l'appareil photo sur le capteur photographique. Celui-ci est constitué de cellules sensibles à la lumière. La mesure de l'intensité lumineuse est transformée en données numériques puis stockée dans la mémoire de l'appareil.

pixels

1.1.3 Le fonctionnement du capteur photographique

Les capteurs photographiques sont des éléments électroniques sensibles à la lumière, qui produisent des électrons (de l'électricité) lorsqu'ils reçoivent des photons (de la lumière). Un capteur d'appareil photo numérique est composé de cellules photosensibles : les photosites. Pour que ceux-ci distinguent les couleurs, chacun est placé derrière un filtre qui ne laisse passer que les rayons d'une seul couleur : rouge, vert ou bleu (2 verts, 1 rouge et un bleu par carré). Les photosites mesurent ainsi l'intensité lumineuse des rayons rouges (R), des rayons verts (V) et des rayons bleus (B). La tension électrique produite est ensuite convertie en nombre et envoyée au processeur de l'appareil photo. La définition d'un capteur est le nombre total de ses photosites.

pixels
Source des images : SNT 2de, Sciences numériques et Technologie, pages 106-107, édition Delagrave, Paris 2019.

  1. En comparant les images schématisant la vision humaine et l'appareil photo numérique, quel est l'équivalent au niveau de l'appareil numérique :

    1. du cristallin de l'oeil humain ?

    2. de la rétine de l'oeil ?

    3. du cerveau humain ?

    4. d'un cône ?

  2. Où se situe le capteur d'un appareil photo ?

  3. Pourquoi mettre sur un capteur photographique deux fois plus de photosites sensibles à la couleur verte qu'aux deux autres couleurs ?

  4. Que représente la définition d'un capteur photo ?

  5. Quels sont les principaux éléments d'un appareils photos ? Résumer son principe de fonctionnement.

Code de déblocage de la correction :

Notion d'image numérique

Une image numérique est constituée d’un ensemble de pixels, c’est-à-dire de petits carrés colorés disposés les uns à côté des autres sous la forme d'un tableau à deux dimensions, le pixel représente ainsi le plus petit élément constitutif d'une image numérique.
Chaque pixel est caractérisé par sa position sur l’image (sous forme de coordonnées), et sa couleur.

pixels

Définition d'une image

La définition d’une image numérique est le nombre de pixels qui la composent.

si par exemple les dimensions de l’image sont 300 pixels en largeur et 200 pixels en hauteur, sa définition sera de 60 000 pixels ($60 000 = 200\times 300$).

On parle aussi de définition lorsqu’on veut exprimer la qualité d’un appareil photographique : si un fabricant annonce que son appareil a 18 mégapixels (soit 18 millions de pixels), cela signifie qu’il prend des photographies dont les dimensions sont $5184 \times 3456$ pixels.
Cependant en pratique, il est bien difficile de distinguer une photo à 18 mégapixels d’une autre à 12 mégapixels.

Question :
On considère une photographie ayant 500 pixels en longueur et 400 pixels en largeur ; sa définition sera de :
Réponses :
900 pixels.
20 000 pixels.
200 000 pixels.
2 mégapixels.

Résolution d'une image

La résolution d’une image est exprimée par un nombre de pixels par unité de longueur (souvent le pouce, soit 2,54 centimètres).

Il est utile de l’évoquer lorsqu’on affiche une image sur un écran ou qu’on l’imprime sur papier : habituellement, les écrans d’ordinateurs ont une résolution de 72 pixels/pouce (soit environ 28 pixels/centimètre), alors que les impressions sur papier requièrent une résolution de 300 pixels/pouce.

  1. On dispose d’une image de dimensions 75×50 pixels, et on l’imprime sur une feuille de dimensions 15×10 centimètres. Quelle sera la taille de chaque pixel imprimé ? Que peut-on craindre du résultat ?
  2. Quelles devraient être les dimensions de la feuille si on souhaite réaliser une impression avec une résolution de 100 pixels/pouce?
  3. On souhaite imprimer une image sur une feuille de dimensions 15×10 centimètres. Quelles devraient être les dimensions de l’image (en pixels) si on souhaite obtenir une résolution de 300 pixels par pouce ?

Code de déblocage de la correction :

Profondeur de couleur

La profondeur de couleurs, dont l'unité est le "bits par pixel" (bpp), correspond au nombre de bits (c'est-à-dire de 0 et de 1) nécessaire pour stocker en mémoire la couleur d'un pixel.
Plus la profondeur de couleurs est grande plus l'échelle de nuances des couleurs est grande et plus la qualité de l'image est meilleure.

Voici la même photographie a été stockée en tant que trois images ayant une profondeur de couleurs différents :

Image 1 :

Image 2 :

Image 3 :

Associer à chacune des images ci-dessus sa profondeur.

Vous pouvez regarder entre autre le centre de l'allée pour différencier certains cas.

Code de déblocage de la correction :

Le poids d'une image

Le poids d'une image est la mémoire nécessaire à son enregistrement, il est mesuré en kilooctets, notés Ko, ou en mégaoctets, notés Mo.

  1. Dans un appareil photo numérique, quel réglage permet d'obtenir des photos de meilleure qualité ?

  2. Que représentent la définition du capteur et la définition d'une photo ? Le nombre de pixels de la photo est-il nécessairement égal au nombre de photosites du capteur ?

  3. Comment évolue le poids d'une image si :

    1. la définition de l'image augmente ?

    2. la résolution de l'image augmente ?

    3. la profondeur des couleurs de l'image augmente ?

Code de déblocage de la correction :

Les métadonnées EXIF

Dans les appareils numériques, les métadonnées sont automatiquement inscrites et enregistrées dans le fichier image. L'ensemble de ces informations est appelé métadonnées EXIF, EXIF pour Exchangeable Image File Format (signification en français : "format d'échange de données pour les fichiers images" ).

Il est possible d’obtenir simplement les caractéristiques d’une image. Dans l’explorateur Windows, un clic droit sur le fichier image permet d’accéder à ses propriétés. Dans l’onglet Général, on trouve entre autres :

Dans l’onglet Détails, on trouve aussi :

JPEG

    Dans le dossier "SNT_2020-21", créer un dossier nommé "Photographie" que nous allons utiliser pour le thème photographie. Dans le dossier "Photographie" créer un dossier et appeler le "Activite1"

  1. Ouvrir cette image en cliquant ici puis faire un clic droit et enregistrer la dans le dossier "Activite1"
  2. Afficher les métadonnées EXIF de cette image en utilisant l'explorateur Windows.
  3. Quelle est la définition de cette image ?
  4. Quel est son poids ?
  5. Quelles devraient être les dimensions de la feuille d'impression de cette image si on souhaite l'imprimer avec une résolution de 300 pixels/pouce ?
  6. Quelle est la valeur de la profondeur en couleur de cette image ? Que signifie cette valeur ?
  7. Déterminer les données permettant de déterminer la position du lieu où a été prise cette image.
  8. A l'aide de ces données, déterminer le lieu où a été prise l'image.

    Faire une recherche sur Qwant pour trouver un site qui permet de localiser un lieu à partir de ses coordonnées GPS.

Un internaute vient de publier sur une page Web deux photos :

trou où le trésor est caché trésor à trouver

Le but est de localiser le trésor !

  1. Télécharger les deux images ci-dessous à l'aide d'un clic droit pour les mettre dans le même répertoire que celui de l'exercice précédent.

  2. Etudier les métadonnées Exif disponibles sur la première photo. Quelles informations obtient-on sur l'image ?

  3. Etudier les métadonnées Exif disponibles sur la seconde photo. Quelle information obtient-on sur le lieu où a été pris la photo ?

  4. Outre les données directement accessibles depuis les propriétés du fichier image, d’autres métadonnées sont disponibles. Certains sites (ou logiciels) permettent d’extraire d’un fichier les métadonnées qu’il contient.
    Par exemple, utiliser le site https://www.get-metadata.com/ pour extraire de nouvelles informations sur la localisation du trésor.

  5. Localiser le lieu où le trésor est caché.

Pour protéger vos données personnelles, vous devez les supprimer avant de les envoyer ou de les publier sur un réseau social.

  1. Pour chacune des images téléchargées de l'exercice précédent, ouvrir les propriétés de l'image et supprimer les propriétés et les informations personnelles par un clic judicieux.

  2. Peut-on encore localiser le trésor à partir des données restantes ?

Pour effacer les métadonnées EXIF sur un smartphone, vous pouvez suivre les procédures proposées à cette adresse.

Les images proposées ci-dessus sont « libres de droits ».

Rechercher la signification de cette expression.

Si une image n’est pas « libre de droit », que peut-elle être ?

Si vous avez apprécié le fait d'essayer de localiser une photographie, sachez qu'il existe un collectif sur twitter qui propose d'apprendre aux utilisateurs de nouvelles techniques de vérification des images en ligne. Il suffit que les joueurs retrouvent l'endroit où a été pris la photo à partir d’indices présents dans la photo.
Attention ! Il ne suffit pas de se contenter de trouver des métadonnées dans ce jeu mais de repérer des indices visuels et d'effectuer des recherches sur Internet.

Chaque participant explique la démarche qui lui a permis de localiser la photo du jour : ainsi, au fil des résolutions, on apprend à trouver des indices et à les utiliser de manière performante !

Si vous voulez devenir des Sherlock Holmes du XXIè siècle, n'hésitez pas !

Comme de plus, de nombreux posts sont en anglais, vous vous améliorerez aussi dans la langue de Sherlock Holmes !

Voici une page web contenant une vidéo qui présente le jeu et explicite une résolution particulière. (vous y apprendrez en particulier comment faire pour retrouver une photo en taille originale pour pouvoir y trouver des indices.

Voici le lien pour accéder au collectif quiztime sur Twitter.

Partie 2 : Formats des images

Introduction

Pour un ordinateur, une image est un ensemble de pixels arrangés sous la forme d'un tableau à deux dimensions.

Une image dite en noir et blanc est composée de pixels noirs ou blancs : les deux valeurs possibles des pixels sont 0 pour le noir et 1 pour le blanc.

Une image en niveaux de gris est composée de pixels de valeurs numériques représentant l'intensité de la luminosité, généralement les valeurs sont entières entre 0 (pour le noir) et 255 (pour le blanc).

Une image en couleurs est composée de pixels représentés par trois valeurs : celle représentant l'intensité du rouge (R), celle représentant l'intensité du vert (V) et celle représentant l'intensité du bleu (B). Chaque valeur est comprise entre 0 et 255.

Les formats sans compression

Formats portables

Les formats de fichiers d’images PBM (portable bitmap), PGM (portable grayscalemap) et PPM (portable pixmap), offrent une solution simple à tout programmeur confronté au problème de la manipulation de fichiers d’images.

Ces formats n’effectuent pas de compression, c’est-à-dire que tous les pixels sont présents dans l’image. L’avantage de ces formats est la qualité des images car sans compression il n’y a pas de perte de qualité. En revanche cela donne des fichiers très volumineux car les pixels sont représentés par des caractères ASCII qui occupent 1 octet chacun.

Ces fichiers, avec les trois formats, sont construits sur la même base :

Une vidéo pour vous aider à démarrer ce type d'exercice :

Voici un exemple de fichier en format PBM

pixels
  1. En utilisant un logiciel d'éditeur de textes (Visual Studio Code ou Notepad++ ou Bloc-notes), ouvrir le fichier "SNT.pbm" .

  2. Quelle est la définition de ce fichier image ?
  3. Calculer le poids de ce fichier sachant qu'un espace est un caractère, un retour à la ligne est représenté par deux caractères "/n" et chaque caractère quelle que soit sa nature occupe un octet.
  4. En utilisant l'explorateur Windows, vérifier si votre calcul du poids de ce fichier est exact.
  5. A partir de ce fichier deviner ce que cette image représente.
  6. Ouvrir ce fichier à l'aide du logiciel GIMP. Zoomer pour visualiser convenablement cette nouvelle image (Avec GIMP, on utilise la touche plus "+" pour agrandir et moins "-" pour réduire).
  7. Vérifier les caractéristiques dimensionnelles de cette image.
  8. Ouvrir le bloc-notes de Windows, et saisir les deux premières lignes suivantes :
    pixels
  9. Compléter alors ce fichier, puis l’enregistrer au format PBM, de sorte qu’en l’ouvrant avec GIMP, on obtienne les images suivantes :
    Image 1         Image 2
    pixels         pixels

Voici un exemple de fichier en format PGM

pixels

    En utilisant un logiciel d'éditeur de textes (Visual Studio Code ou Notepad++ ou Bloc-notes), ouvrir le fichier "SNT.pgm".

  1. Quelle est la définition de ce fichier image ?
  2. Que représente la valeur de la 4 ligne ? Deviner ce que cette image représente.
  3. Calculer le poids de ce fichier.
  4. En utilisant l'explorateur Windows, vérifier si votre calcul du poids de ce fichier est exact.
  5. Ouvrir ce fichier à l'aide du logiciel GIMP. Zoomer pour visualiser convenablement cette nouvelle image (Avec GIMP, on utilise la touche plus "+" pour agrandir et moins "-" pour réduire).
  6. Vérifier les caractéristiques dimensionnelles de cette image.
  7. On présente ci-dessous des images de dimensions 4×4 pixels :
    pixels

    On considère les tableaux de nombres suivants :

    pixels
    Associer à chaque image le tableau qui lui correspond.

Voici un exemple de fichier en format PPM

pixels
  1. En utilisant un logiciel d'éditeur de textes (Visuel Studio Code ou Notepad++ ou Bloc-notes), ouvrir le fichier nommé "SNT.ppm" .
  2. Quelle est la définition de ce fichier image ?
  3. Que représente la valeur de la 4 ligne ?
  4. Calculer le poids de ce fichier.
  5. En utilisant l'explorateur Windows, vérifier si votre calcul du poids de ce fichier est exact.
  6. A partir de ce fichier deviner ce que cette image représente.
  7. Ouvrir ce fichier à l'aide du logiciel GIMP. Zoomer pour visualiser convenablement cette nouvelle image (Avec GIMP, on utilise la touche plus "+" pour agrandir et moins "-" pour réduire).
  8. Vérifier les caractéristiques dimensionnelles de cette image.
    1. Combien de nuances de chaque composante peut-on obtenir ?
    2. Combien de couleurs différentes peut-on obtenir ?
    3. Reproduire et compléter le tableau ci-dessous :
    Couleur du pixel Rouge Vert Bleu Blanc Noir Jaune Cyan Magenta Violet
    Composante rouge
    Composante vert
    Composante bleu

    On trouve sur ce site ou sur le site un nuancier de couleurs RVB qui pourra être utile.

D'autres formats

Lors de la capture par l'appareil photo, un fichier au format Raw est produit. Il s'agit des données brutes issues du capteur. Ce format est donc brut et non compressé. En général, il est immédiatement modifié et enregistré dans un autre format. Il existe un autre non compressé, le format Tiff qui est adapté à l'impression.

Rechercher les caractéristiques de ces deux formats de fichiers images sans compression en complétant le tableau suivant :

Format Qualité Poids
Raw
Tiff

Les formats d’image représentant l’ensemble des pixels sont très volumineux. Il existe plusieurs mécanismes de compression de données qui réduisent la taille des fichiers.

Formats avec compression

Il y a deux grandes familles : les méthodes de compression d’image sans perte et celles avec perte.

Formats sans perte

L'une des méthodes les plus importantes de compression d’image sans perte est la méthode du codage des répétitions (comme LRE "run-length encoding")

Cet encodage consiste, pour chaque suite de pixels de la même couleur, à coder uniquement le nombre de pixels puis la couleur de la séquence. Ainsi sur l’image noir et blanc représentée par la suite de pixels blancs (W) ou noirs (B) suivante :

WWWWWWWBWWWWWWWWWWWBBBBWWWWWWWWWWWWWWWWWWWWBWWWWWWWWW le codage est : 7W1B11W4B20W1B9W

En général le codage comporte moins de caractères (il y a bien compression). Mais ce n’est pas toujours le cas comme le montre l’image :

WBWBWBWBWB qui se code par 1W1B1W1B1W1B11W1B1W1B

Formats avec perte

Il existe de nombreuses techniques de compression avec perte. Certains algorithmes de compression utilisent le fait que l’oeil humain est assez sensible à la luminance (la luminosité) mais peu à la chrominance (la teinte) d’une image. Ainsi les pixels ayant des teintes proches sont uniformisés. Les couleurs sont donc modifiées afin d’être uniformes dans les zones ayant des teintes proches (ce que l’oeil humain a du mal à distinguer). Le processus de compression est irréversible, puisqu’il y a perte de données.

Rechercher les caractéristiques des principaux formats de fichiers images avec compression.

Préciser pour chaque format s'il peut être compresser avec ou sans perte des données, présenter ces résultats sous la forme d'un tableau.

Format Qualité Poids Compression Transparence Utilisable en web
... ... ... ... ... ...
... ... ... ... ... ...

Partie 3 : Traitement d'images

Structures de base

Dans les travaux sur les images, on utilisera la bibliothèque PIL du langage de programmation Python.

Pour créer une nouvelle image qu'on utilise comme un fond de couleur noire, on doit importer d'abord le module Image de la bibliothèque PIL et utiliser la fonction Image.new("RGB", (L , H), (R, V, B)).

Pour afficher une image, on utilise la fonction show()


			from PIL import Image
			couleur=(255,255,0)                          # couleur jaune en code couleur RVB : ici R=255, V=255 et B=0
			fond=Image.new('RGB',(600,400),couleur)		 # création d'une image de de largeur 600 pixels et de hauteur 400 pixels, jaune
			fond.show()
		
  1. Dans le dossier "Photographie" créer un dossier et appeler le "partie3", ensuite créer, sous EduPython, un fichier nommé fond.py et l’enregistrer dans ce dossier

  2. Dans ce fichier, recopier le script donné ci-dessus et l’exécuter. Vérifier les commentaires du code.

  3. Modifier ce programme de sorte que le fond affiché soit de couleur vert pistache.

    On trouve sur le site un nuancier de couleurs RVB qui pourra être utile.

  4. Modifier ce programme de sorte que l'image soit désormais de 850 pixels de largeur et 560 en hauteurs et de couleur au choix.

    On trouve sur ce site les plus de 16 millions possibles en code couleur RVB, faites-vous plaisir.

Extraction du code couleur sur une image

La pipette d'un logiciel de retouche de photo permet de récupérer le code RVB d'un pixel.

Ci-dessous, on a prélevé la couleur d'un même pixel sur une image en couleur, puis sur cette image après passage en niveaux gris.

pixels pixels
Source des images : SNT 2de, Sciences numériques et Technologie, page 109, édition Delagrave, Paris 2019.

Pour chaque pixel, on calcule d’abord la valeur nommée $g$ en niveau de gris en fonction des trois valeurs de ses composantes $(r , v , b)$ en utilisant la formule suivante :

\[ g=0,11\times r+0,83\times v+0,06\times b\]

  1. Donner les trois composantes $(r , v , b)$ du pixel indiqué dans l'image en couleur ci-dessus.
  2. Que représentent les trois valeurs $7 %$, $62 %$ et $79 %$ ? Comment obtient-on ces valeurs ?
  3. Que représente la valeur $146$ indiquée sur l'image en niveau de gris ? Comment obtient-on cette valeur ?
  4. Que représente la valeur $57 %$ ? Comment obtient-on cette valeur ?

Transformation d'une image RVB en niveaux de gris

Lecture et écriture d’un pixel en langage Python

On a déjà vu que chaque pixel d’une image est repéré par ses coordonnées (x, y) et ses composantes (R,V,B).

Niveau de gris

Dans ce paragraphe, nous allons décrire comment transformer une image en couleurs en une image en niveaux de gris.

pixels

Pour cela, il est nécessaire d’agir sur tous les pixels, les uns après les autres : à l’aide de deux boucles for imbriquées, on devra donc parcourir l’image entière par lignes et par colonnes.


			for y in range (hauteur) :
				for x in range (largeur) :

Pour chaque pixel, on calcule d’abord la valeur en niveau de gris en fonction de ses trois composantes par la formule suivante :

\[ g=0,11\times r+0,83\times v+0,06\times b\]

On remplace ensuite, pour ce pixel, la couleur (r, v, b) par la couleur (g, g, g).

Voici un algorithme permettant de transformer une image en couleurs en une image en niveaux de gris :

Algorithme :

		Im ← ? # On charge une image en lui donnant le nom "Im" par exemple
		L, H ← Im.size  # On récupère les dimensions de l'image chargée
		NegIm ← ? # On crée une nouvelle image nommée "GrisIm" de dimensions LxH
		Pour y allant de 0 à H-1 : # On parcourt les pixels de l'image "Im" en hauteur
			Pour x allant de 0 à L-1 : # On parcourt les pixels de l'image "Im" en largeur
				r, v, b ← ? On récupère les composantes RVB du pixel de coordonnées (x ; y) de l'image "Im"
				on affecte à g la partie entière de (0.11*r+0.83*v+0.06*b)
				On affecte au pixel de l'image "GrisIm" de coordonnées (x ; y) les composantes (g, g, g)
			Fin Pour
		Fin Pour
		On sauvegarde la nouvelle image "GrisIm" dans le dossier qu'on veut en lui donnant un nom
		On affiche la nouvelle image "GrisIm"		
		

Le but est que vous mettiez en oeuvre l'algorithme précédent sur l'image suivante :

pixels

pour aboutir à celle-ci :

pixels

Pour cela, on vous propose plusieurs exercices de niveau différent selon vos connaissances dans le langage Python :

Cliquez sur le niveau d'exercice qui vous convient pour y accéder directement.

  1. Dans le dossier "Photographie", créer un dossier et l'appeler "partie3"

  2. Ouvrir l'image du perroquet en cliquant ici puis faire un clic droit et l'enregistrer dans le dossier "partie3".

  3. Utilisation du langage Python :

    1. Télécharger le fichier acccessible ici où une partie du programme en langage Python est déjà écrite et l'enregistrer dans le même dossier "partie3".

      Attention à bien enregistrer ce fichier dans le même répertoire que l'image du perroquet sinon le programme ne sera pas fonctionnel car la quatrième ligne du code devrait être modifiée.

    2. Pour chacune des questions suivantes, lire le commentaire précédent la ligne du code à modifier et cliquer sur le lien afin d'obtenir un exemple d'utilisation qu'il suffit d'adapter.

    3. Compléter la ligne 6 du programme en utilisant l'instruction size présentée ici afin de stocker dans les variables largeur et longueur les deux dimensions de l'image initiale du perroquet.

    4. Compléter la ligne 8 du programme en utilisant l'instruction new présentée ici afin de stocker dans la variable nommée imageBut une image nouvelle créée dont les dimensions sont celles de l'image initiale.

      Penser à utiliser des variables déjà créées dans ce programme.

    5. Compléter la ligne 13 du programme en utilisant l'instruction getpixel présentée ici afin de stocker dans les variables nommées r, v et b les composantes RVB du pixel de coordonnées (x,y) de l'image du perroquet initiale.

      Penser à utiliser la variable déjà créée dans ce programme qui stocke l'image initiale du perroquet.

    6. Compléter la ligne 15 du programme en utilisant la formule donnant le niveau de gris donnée ici afin de stocker dans la variable nommée g le niveau de gris calculé.

      l'instruction int permet de ne garder que la partie entière (c'est-à-dire celle devant la virgule) du résultat du calcul.

    7. Compléter la ligne 17 du programme en utilisant l'instruction putpixel présentée ici afin de mettre le pixel de coordonnées (x,y) de l'image nouvellement construite au niveau de gris calculé.

      Penser à utiliser une variable déjà créée dans ce programme.

  4. Vérifier que l'image obtenue est similaire celle attendue.

  1. Dans le dossier "Photographie", créer un dossier et l'appeler "partie3"

  2. Ouvrir l'image du perroquet en cliquant ici puis faire un clic droit et l'enregistrer dans le dossier "partie3".

  3. Utilisation du langage Python :

    1. Télécharger le fichier accessible ici où une partie du programme en langage Python est déjà écrite et l'enregistrer dans le même dossier "partie3".

      Attention à bien enregistrer ce fichier dans le même répertoire que l'image du perroquet sinon le programme ne sera pas fonctionnel car la quatrième ligne du code devrait être modifiée.

    2. Pour chacune des questions suivantes, lire le commentaire précédent la ligne du code à modifier et cliquer sur le lien afin d'obtenir un exemple d'utilisation qu'il suffit d'adapter.

      Penser à utiliser les différentes instructions présentées avec un exemple ici.

    3. Compléter la ligne 6 du programme en utilisant l'instruction size afin de stocker dans les variables imposées largeur et longueur les deux dimensions de l'image initiale du perroquet.

    4. Compléter la ligne 8 du programme en utilisant l'instruction new afin de stocker dans la variable nommée imageBut une image nouvelle créée dont les dimensions sont celles de l'image initiale.

    5. Compléter la ligne 13 du programme en utilisant l'instruction getpixel afin de stocker dans les variables nommées r, v et b les composantes RVB du pixel de coordonnées (x,y) de l'image du perroquet initiale.

    6. Compléter la ligne 15 du programme en utilisant la formule donnant le niveau de gris afin de stocker dans la variable nommée g le niveau de gris calculé.

      l'instruction int permet de ne garder que la partie entière (c'est-à-dire celle devant la virgule) du résultat d'un calcul.

      int(1.2+3.4)

      renvoie 4 qui est la partie entière de 4.6, résultat de l'addition 1.2+3.4.

    7. Compléter la ligne 17 du programme en utilisant l'instruction putpixel afin de mettre le pixel de coordonnées (x,y) de l'image nouvellement construite au niveau de gris calculé.

      Penser à utiliser la variable déjà créée dans ce programme stockant la nouvelle image.

  4. Vérifier que l'image obtenue est similaire celle attendue.

  1. Dans le dossier "Photographie", créer un dossier et l'appeler "partie3"

  2. Ouvrir cette image en cliquant ici puis faire un clic droit et enregistrer la dans le dossier "partie3".

  3. Traduire l'algorithme de niveau de gris en langage Python pour pouvoir charger une image en couleur et l'afficher en niveaux gris.

    Pour maîtriser les fonctions du module Image de la bibliothèque PIL, vous pouvez utiliser la documentation accessible ici

  4. Vérifier que l'image obtenue est similaire celle attendue.

Si vous êtes perdu, voici une aide en vidéo :

Le négatif d'une image

Le négatif d'une image est une image dont les couleurs sont inversées par rapport à l'originale c'est-à-dire :

1. Parmi les images ci-dessous, laquelle est le négatif de l'image ci-contre ?

Image 1     Image 2     Image 3
       


2. Parmi les images ci-dessous, laquelle est le négatif de l'image ci-contre ?

Image 1     Image 2     Image 3
       


3. Parmi les images ci-dessous, laquelle est le négatif de l'image ci-contre ?

Image 1     Image 2     Image 3
       
Algorithme :

Voici un algorithme permettant de passer au négatif d'une image :


		Im ← ? # On charge une image en lui donnant le nom "Im" par exemple
		L, H ← Im.size  # On récupère les dimensions de l'image chargée
		NegIm ← ? # On crée une nouvelle image nommée "NegIm" de dimensions LxH
		Pour y allant de 0 à H-1 : # On parcourt les pixels de l'image "Im" en hauteur
			Pour x allant de 0 à L-1 : # On parcourt les pixels de l'image "Im" en largeur
				r, v, b ← ? On récupère les composantes RVB du pixel de coordonnées (x ; y) de l'image "Im"
				On affecte au pixel de l'image "NegIm" de coordonnées (x ; y) les composantes (255-r, 255-v, 255-b)
			Fin Pour
		Fin Pour
		On sauvegarde la nouvelle image "NegIm" dans le dossier qu'on veut en lui donnant un nom
		On affiche la nouvelle image "NegIm"		
		

Le but est de vérifier les résultats de l'exercice précédent en appliquant l'algorithme ci-dessus aux trois images de l'exercice, images téléchargeables ci-dessous.

Ouvrir cette image en cliquant ici puis faire un clic droit et enregistrer la dans le dossier "partie3" sous le nom imposé loup.png (png étant le type de fichier, loup étant le nom du fichier)

Ouvrir cette image en cliquant ici puis faire un clic droit et enregistrer la dans le dossier "partie3" sous le nom imposé fleur.png.

Ouvrir cette image en cliquant ici puis faire un clic droit et enregistrer la dans le dossier "partie3" sous le nom imposé image.png.

Comme dans le précédent exercice de codage en langage Python, attention à enregistrer les images et le programme dans le même répertoire.

Là encore, on vous propose trois niveaux d'exercice pour mettre en oeuvre l'algorithme du négatif suivant votre maîtrise du langage Python :

Cliquez sur le niveau d'exercice qui vous convient pour y accéder directement.

    1. Dans un premier temps, on s'intéresse à compléter un script pour obtenir le négatif de l'image du loup.

    2. Télécharger le fichier acccessible ici où une partie du programme en langage Python est déjà écrite et l'enregistrer dans le même dossier "partie3" .

      Attention à bien enregistrer ce fichier dans le même répertoire que l'image du loup sinon le programme ne sera pas fonctionnel car la quatrième ligne du code devrait être modifiée.

    3. Pour chacune des questions suivantes, lire le commentaire précédent la ligne du code à modifier et cliquer sur le lien afin d'obtenir un exemple d'utilisation qu'il suffit d'adapter.
      De plus, s'aider du programme déjà réalisé sur le niveau de gris car les deux programmes sont proches.

    4. Compléter la ligne 6 du programme en utilisant l'instruction size présentée ici afin de stocker dans les variables largeur et longueur les deux dimensions de l'image initiale du perroquet.

    5. Compléter la ligne 8 du programme en utilisant l'instruction new présentée ici afin de stocker dans la variable nommée imageBut une image nouvelle créée dont les dimensions sont celles de l'image initiale.

      Penser à utiliser des variables déjà créées dans ce programme.

    6. Compléter la ligne 13 du programme en utilisant l'instruction getpixel présentée ici afin de stocker dans les variables nommées r, v et b les composantes RVB du pixel de coordonnées (x,y) de l'image du loup initiale.

      Penser à utiliser la variable déjà créée dans ce programme qui stocke l'image initiale du loup.

      Contrairement au programme mettant en niveau de gris l'image sur le perroquet, getpixel renvoie ici quatre valeurs car l'image du loup est une image multicouche d'où la création d'une nouvelle variable autre_info qui ne nous servira pas ici.

    7. Compléter la ligne 15 du programme en utilisant :

      Penser à utiliser des variables déjà créées dans ce programme.

    8. Vérifier que l'image obtenue comme image négative du loup est bien celle déterminée comme résultat de l'exercice précédent.

    9. Enregistrer le programme fini.

    1. Le but est désormais d'adapter le programme précédent pour obtenir l'image de la fleur.

    2. Enregistrer le programme prédécent sous un autre nom, nom dans lequel le mot "fleur" apparaît.

    3. À la ligne 4 du programme, modifier le nom du fichier ouvert afin que le fichier "fleur.png" soit désormais ouvert par le programme.

    4. Vérifier que l'image obtenue comme image négative de la fleur est bien celle déterminée comme résultat de l'exercice précédent.

    5. Enregistrer de nouveau le programme fini.

    1. Modifier le programme afin que ce soit le troisième image qui soit ouverte et que l'image créée ait un nom cohérent avec l'image initiale.

    2. Vérifier que l'image obtenue comme image négative est bien celle déterminée comme résultat de l'exercice précédent.

    1. Dans un premier temps, on s'intéresse à compléter un script pour obtenir le négatif de l'image du loup.

    2. Télécharger le fichier acccessible ici où une partie du programme en langage Python est déjà écrite et l'enregistrer dans le même dossier "partie3" .

      Attention à bien enregistrer ce fichier dans le même répertoire que l'image du loup sinon le programme ne sera pas fonctionnel car la quatrième ligne du code devrait être modifiée.

    3. Pour chacune des questions suivantes, lire le commentaire précédent la ligne du code à modifier et cliquer sur le lien afin d'obtenir un exemple d'utilisation qu'il suffit d'adapter.
      De plus, s'aider du programme déjà réalisé sur le niveau de gris car les deux programmes sont proches.

      Penser à utiliser les différentes instructions présentées avec un exemple ici.

      Contrairement au programme mettant en niveau de gris l'image sur le perroquet, getpixel renvoie ici quatre valeurs car l'image du loup est une image multicouche d'où la création d'une nouvelle variable autre_info qui ne nous servira pas ici.

    4. Compléter la ligne 6 du programme en utilisant l'instruction size afin de stocker dans les variables imposées largeur et longueur les deux dimensions de l'image initiale du perroquet.

    5. Compléter la ligne 8 du programme en utilisant l'instruction new afin de stocker dans la variable nommée imageBut une image nouvelle créée dont les dimensions sont celles de l'image initiale.

    6. Compléter la ligne 13 du programme en utilisant l'instruction getpixel afin de stocker dans les variables nommées r, v et b les composantes RVB du pixel de coordonnées (x,y) de l'image du perroquet initiale.

    7. Compléter la ligne 15 du programme en utilisant :

      • la formule donnant le négatif d'un pixel,

      • l'instruction putpixel afin de mettre le pixel de coordonnées (x,y) de l'image nouvellement construite à niveau de la couleur RVB correspondant au négatif.

    8. Vérifier que l'image obtenue comme image négative du loup est bien celle déterminée comme résultat de l'exercice précédent.

    1. Le but est désormais d'adapter le programme précédent pour obtenir l'image de la fleur.

    2. Modifier la ligne 4 du programme afin que le fichier nommé "fleur.png" soit désormais ouvert par le programme.

    3. Vérifier que l'image obtenue comme image négative de la fleur est bien celle déterminée comme résultat de l'exercice précédent.

    1. Modifier le programme afin que ce soit le troisième image qui soit ouverte et que l'image créée ait un nom cohérent avec l'image initiale.

    2. Vérifier que l'image obtenue comme image négative est bien celle déterminée comme résultat de l'exercice précédent.

Il est possible de s'aider du programme déjà réalisé sur le niveau de gris car les deux programmes sont proches.

  1. Écrire un script en Python permettant de traduire cet algorithme sur le négatif en sachant qu'il doit doit s'appliquer sur l'image du loup.

  2. Contrairement au programme mettant en niveau de gris l'image sur le perroquet, getpixel renverra ici quatre valeurs car l'image du loup est une image multicouche.

  3. Modifier le programme afin d'obtenir le négatif de l'image du fleur.

  4. Modifier le programme afin d'obtenir le négatif de la dernière image.

La contraste

Le contraste d'une image est la variation relative de l'éclairement d'une image. Il permet de quantifier la différence de luminosité entre les parties claires et sombres d'une image.

quand l'image originale est en RVB, si $(r , v , b)$ sont les trois composantes d'un pixel de l'image d'origine alors pour jouer sur le contraste de cette image, on modifie les composantes du pixel en utilisant la formule suivante : $\text{nouvelleValeur} =128+ (\text{ancienneValeur} -128)*coef$.

Algorithme :

Voici un algorithme permettant de modifier le contraste d'une image :


			Im ← ? # On charge une image en lui donnant le nom "Im" par exemple
			L, H ← Im.size  # On récupère les dimensions de l'image chargée
			Nim ← ? # On crée une nouvelle image nommée "Nim" de dimensions LxH
			coef ← ? # On saisit le coeffcient du contraste
			Pour y allant de 0 à H-1 : # On parcourt les pixels de l'image "Im" en hauteur
				Pour x allant de 0 à L-1 : # On parcourt les pixels de l'image "Im" en largeur
					r, v, b ← ? On récupère les composantes RVB du pixel de coordonnées (x ; y) de l'image "Im"
					r1 ← partie entière de ((128+ (r -128)*coef)
					v1 ← partie entière de ((128+ (v -128)*coef)
					b1 ← partie entière de ((128+ (b -128)*coef)
					On affecte au pixel de l'image "Nim" de coordonnées (x ; y) les composantes (r1, v1, b1)
				Fin Pour
			Fin Pour
			On sauvegarde la nouvelle image "Nim" dans le dossier qu'on veut en lui donnant un nom
			On affiche la nouvelle image "Nim"		
			

Vous allez mettre en oeuvre cet algorithme sur l'image neige.jpg ci-dessous :

Ouvrir cette image en cliquant ici puis faire un clic droit et enregistrer la dans le dossier "partie3"

Suivant votre aisance dans le langage Python, chercher un des exercices suivant :

Si vous avez compris les deux exercices sur les nuances de gris et sur le négatif, n'hésitez pas à tenter la version confirmée au moins.

  1. Télécharger le fichier acccessible ici où une partie du programme en langage Python est déjà écrite et l'enregistrer dans le même dossier "partie3" .

  2. Pour chacune des questions suivantes, lire le commentaire précédent la ligne du code à modifier et cliquer sur le lien afin d'obtenir un exemple d'utilisation qu'il suffit d'adapter.
    De plus, s'aider des programmes déjà réalisés sur le niveau de gris et sur le négatif est utile car les trois programmes sont proches.

  3. Compléter la ligne 4 du programme en précisant le nom du fichier où le contraste est à traiter.

  4. Compléter la ligne 6 du programme en utilisant l'instruction size présentée ici.

  5. Compléter la ligne 8 du programme en utilisant l'instruction new présentée ici.

  6. Compléter la ligne 10 du programme, comme demandé dans l'algorithme de contraste, en affectant la valeur 1.5 à la varaible coeff.

  7. Compléter la ligne 15 du programme en utilisant l'instruction getpixel présentée ici.

  8. Compléter les lignes 17 à 19 du programme en utilisant la formule du contraste explicité dans l'algorithme de contraste.

    l'instruction int permet de ne garder que la partie entière (c'est-à-dire celle devant la virgule) du résultat d'un calcul.

    int(1.2+3.4)

    renvoie 4 qui est la partie entière de 4.6, résultat de l'addition 1.2+3.4.

  9. Compléter la ligne 20 du programme en utilisant :

    l'instruction putpixel présentée ici.

  10. Compléter la ligne 22 du programme en donnant un nom à l'image créée où le contraste a été modifié.

    Le format de l'image créée est identique à celle de l'image initiale.

  11. Appliquer ce script à l'image neige.jpg téléchargée précédemment avec un coefficient coef de 1.5. Que pouvez-vous dire de l'image obtenue ?

  1. Dans Edupython, copier le script obtenu pour l'algorithme permettant d'obtenir le négatif d'une image.

  2. Modifier le nom des fichiers images ouvert et obtenu.

  3. Rajouter, comme demandé dans l'algorithme de contraste, une ligne où vous imposer la valeur de coef, coefficient de contraste.

  4. Rajouter, comme demandé dans l'algorithme de contraste, les lignes permettant d'obtenir les nouvelles valeurs des couleurs RVB.

  5. Appliquer ce script à l'image neige.jpg téléchargée précédemment avec un coefficient coef de 1.5. Que pouvez-vous dire de l'image obtenue ?

  1. Écrire un script en Python permettant de traduire l'algorithme de contraste. .

  2. Appliquer ce script à l'image neige.jpg téléchargée précédemment avec un coefficient coef de 1.5. Que pouvez-vous dire de l'image obtenue ?

Partie 4 : Algorithme de photomaton

Fond en couleur

Dans le script ci-dessous, l'image qui s’affiche est un carré de couleur noire.


				from PIL import Image
				fond=Image.new('RGB',(600,400))
				fond.show()
			

Il est possible de modifier sa couleur, en utilisant le codage RVB vu précédemment :

Pour cela, on rajoute à la fonction Image.new() un troisième paramètre qui permet d'avoir un fond de couleur souhaitée ; par exemple, (255,255,255) crée un fond blanc.


				from PIL import Image
				couleur=(190,245,116)
				fond=Image.new('RGB',(600,400),couleur)
				fond.show()
			

Exécuter le script de l'exemple précédent.

Quelle couleur de fond est affichée ?

Quand une image créée, elle est caractérisée par ses dimensions (largeur et hauteur), et chaque pixel de cette image est repéré par ses coordonnées (x et y).

L’origine se trouve en haut, à gauche. L’axe des abscisses est orienté de gauche à droite (de 0 à largeur), et l’axe des ordonnées de haut en bas (de 0 à hauteur) :

pixels

Une fois l'image est chargée, on peut récupérer ses dimensions comme suit :


						im = Image.open("Images/maisons.png")  # chargement de l'image maisons.png se trouvant dans le dossier Images
						L,H=im.size							   # récupération des dimensions
					

Collage d'une image

Pour insérer une image dans un fond déjà créé, deux étapes sont nécessaires :

  1. charger l’image et lui donner un nom :
  2. 
    im = Image.open("Images/souris.png")
    	

    La source de l’image est le fichier souris.png située dans le dossier Images. L’image chargée est appelée im.

  3. coller l’image à l’endroit souhaité dans le fond déjà créé :
  4. 
    fond.paste(im, (x,y,x+L,y+H))
    

    L’image nommée im est collée sur l'image créée appelée fond. Le coin supérieur gauche de l’image est positionné au point de coordonnées (x,y) et le coin inférieur droite de l’image est positionné au point de coordonnées (x+L,y+H), où L et H sont les dimensions de l'image chargée.

Voici un script permettant de coller une image sur un fond et l'afficher :


from PIL import Image
im = Image.open("Images/souris.png")
L,H=im.size
couleur=(190,245,116)
fond = Image.new('RGB',(600,500),couleur)
fond.paste(im, (100,100,100+L,100+H))
fond.show()
fond.save("Images/sourisModifiee.png", "PNG")

On obtient le résultat ci-dessous :

pixels
  1. Dans le dossier "Photographie", créer un dossier et l'appeler "partie4".

  2. Télécharger l'image la souris en cliquant ici puis faire un clic droit et enregistrer la dans un nouveau dossier qu'on nomme "partie4" dans le dossier "Photographie"

  3. Tester le code précédent.

  1. Créer un nouveau fichier Python nommé DoubleImages.py.

  2. Ouvrir cette image en cliquant ici puis faire un clic droit et enregistrer la dans le dossier "partie4".

  3. Rédiger un script permettant d’afficher deux images identiques l'une à côté de l'autre.

Si on prend par exemple l'image suivante :

pixels

On obtiendra à l'aide du script l'affichage suivante :

pixels

Algorithme de Photomaton

Si on illustre cette situation avec une image de dimensions 8×8, on obtient :

pixels

Le tableau suivant indique, pour quelques pixels, leurs coordonnées initiales et leurs coordonnées finales :

pixel a b c d e f g h
coordonnées initiales (0 ; 0) (1 ; 0) (0 ; 1) (1 ; 1) (2 ; 0) (3 ; 0) (2 ; 1) (3 ; 1)
coordonnées finales (0 ; 0) (4 ; 0) (0 ; 4) (4 ; 4) (1 ; 0) (5 ; 0) (1 ; 4) (5 ; 4)

En appliquant la transformation du photomaton à une photographie, on obtient par exemple les images suivantes (les quatre petites images sont semblables à la grande image de gauche, mais elles ne sont pas identiques) :

pixels pixels

On constate que :

Algorithme

Cet algorithme nous permet de sauvegarder la petite image située dans le carré en haut à gauche


im ← ? # On charge une image en lui donnant le nom "Im" par exemple
L, H ← Im.size  # On récupère les dimensions de l'image chargée qui sont deux entiers pairs.
l ← L/2
h ← H/2
Nim ← ? # On crée une nouvelle image nommée "Nim" de dimensions lxh
Pour y allant de 0 à H-1 : # On parcourt les pixels de l'image "Im" en hauteur
	Pour x allant de 0 à L-1 : # On parcourt les pixels de l'image "Im" en largeur
		si x est pair et y est pair alors
			r, v, b ← ? On récupère les composantes RVB du pixel de coordonnées (x ; y) de l'image "Im"
			x1 ← x//2  # on affecte à x1 le quotient de x par 2
			y1 ← y//2  # on affecte à x1 le quotient de x par 2
			On affecte au pixel de l'image "Nim" de coordonnées (x1 ; y1) les composantes (r, v, b)
	Fin Pour
Fin Pour
On sauvegarde la nouvelle image "Nim" dans le dossier qu'on veut en lui donnant un nom
On affiche la nouvelle image "Nim"		
				
  1. Traduire cet algorithme en langage Python
  2. ouvrir cette image en cliquant ici puis faire un clic droit et enregistrer la dans le dossier "partie4" qu'on a déjà créé
  3. Appliquer ce script à "maisons.png" et sauvegarder la nouvelle image sous le nom "maisonsPhoton.png"
  4. Déterminer la définition et le poids de chacune des deux images
  5. Calculer le taux de compression de cet algorithme.
  6. Que peut-on dire de la qualité de la nouvelle image

Ecrire un script en langage Python permettant d'afficher les quatre petites images obtenues par la méthode de l'algorithme du photomatton.

Pour obtenir à la fin l'image suivante :

pixels

Pour aller loin :

Modifier ce script pour qu’il affiche l’image transformée pendant quelques secondes, puis la transforme à son tour, et recommence ...

Pour obtenir à la fin l'image suivante :

pixels

Retouche d'image

Le but est de découvrir comment retoucher simplement des images à l'aide du logiciel GIMP, logiciel que vous avec télécharger en début de thème.

Vous allez retoucher les deux images accessibles ci-dessous :

Pour apprendre à modifier les deux images précédentes, il vous suffit de suivre pas-à-pas le document ci-dessous :

Une fois que vous avez terminé votre travail, vous pouvez l'envoyer à votre enseignant en suivant la procédure précisée en fin de document.

Une petite aide en vidéo.

Savoir repérer des images modifiées

Objectif de la partie

Vous avez vu dans la partie précédente, qu'il est aisée de modifier des photographies à l'aide de logiciel.

En tant que citoyen.ne, il est important que vous appreniez à devenir capable de reconnaître si une photographie a été retouchée ou non.

Dans cette partie, vous aurez à repérer si les deux images ci-dessous, issues de réseaux sociaux ou de médias, sont des photos réelles ou des photos retouchées.

tir missiles iraniens combat belette pic-vert

Cette partie est inspirée d'un' travail proposé par le groupe de formateurs en SNT de l'académie de Reims.

Découverte d'un site

Le site suivant permet d'étudier si une photographie a été retrouchée ou non : photo-forensics
Une image y apparaît ; est-elle vraie ou pas ?

invasion extraterrestre

Différents outils sont disponibles pour étudier si cette image est réelle ou non.

Si vous voulez découvrir chaque outil proposé, vous pouvez visionner une vidéo en anglais à ces adresses :

Premier outil : recherche d'éléments dupliqués

Aller sur le site photo-forensics.

Une image est parfois retouchée en dupliquant des parties (un peu comme vous aviez fait pour supprimer les boutons du visage).

L'outil Clone Detection du site permet de détecter en partie cela :

Cliquer sur Clone Detection.

où cliquer
  1. Régler les paramètres "Minimal Similarity", "Minimal detail" du bandeau de droite.

    Attendre un peu de temps pour que le serveur, ayant pris en compte les paramètres choisis, calcule et vous envoie le résultat de l'analyse.

    Suivant les valeurs prises, vous verrez apparaître une image proche de celle-ci :

    voir les éléments dupliqués
  2. Les traits roses relient différentes parties qui semblent être une copie l'une de l'autre.

    Que pouvez-vous en déduire quand à la photo initiale ?

  1. Importer sur le site l'image que vous avez retouchée pour la séance précédente sur GIMP.

  2. Régler les paramètres pour visualiser si vos duplications sont repérées ou non.

Deuxième outil : recherche d'une granularité différente

Lorsqu'une image est modifiée, des pixels sont modifiés par des algorithmes et le "grain" de l'image est modifié.

L'outil Magnifier du site permet de détecter en partie cela :

Cliquer sur Magnifier.

où cliquer2
  1. Régler les paramètres "Magnification" du bandeau de droite.

  2. Déplacer la souris sur l'image : vous verrez une portion de celle-ci zoomée, ce qui vous permet d'observer pixel par pixel.

    Par exemple, en plaçant la souris sur le pilote du parapente, on voit que les pixels sont différents tout autour.

    voir les éléments dupliqués
  3. Que pouvez-vous en déduire quand à la photo initiale ?

Troisième outil : recherche de zones manipulées

Des algorithmes permettent de reconnaître les zones probablement manipulées ou modifiées.

L'outil Error Level Analysis du site permet de détecter en partie cela :

Cliquer sur Error Level Analysis.

où cliquer3
  1. Régler les paramètres "JPEG Quality", "Error Scale" et "Opacity" du bandeau de droite.

  2. Avec certains niveaux choisis pour les réglages, vous pouvez obtenir :

    voir les éléments dupliqués

    Que pouvez-vous en déduire quand à la photo initiale ?

Quatrième outil : recherche des métadonnées

Des algorithmes permettent de reconnaître les zones probablement manipulées ou modifiées.

Dans tout fichier image, outre le codage des pixels, différentes données sont stockées mais non visibles directement : ce sont les métadonnées.

Certaines de cette métadonnées, si elles n'ont pas été effacées ou modifiées par un codage informatique, peuvent relever la géolocalisation de la photographie ou même l'image initiale avant retouche !

L'outil Meta Data du site permet de détecter en partie cela :

Cliquer sur Meta Data.

où cliquer4
  1. Faire défiler la liste des métadonnées obtenues

  2. Que pouvez-vous en déduire quand à la photo avec la soucoupe volante ?

  3. Est-ce que les informations disponibles permettent d'affirmer ou d'infirmer les conclusions obtenues avec les outils précédents ?

Application sur les deux images

Vous pouvez télécharger les deux images ci-dessous par clic droit.

tir missiles iraniens combat belette pic-vert

Les réponses à cet exercice seront écrites dans un document LibreOffice (ou Word) accompagnées de la copie d'écrans obtenus lors du travail sur le site.

  1. Utiliser le site précédemment utilisé photo-forensics pour savoir si la première image, celle du tir des missiles, a été modifiée ou pas.

    Vous devez faire des copies d'écran montrant comment vous avez utilisé le site et rédiger comment vous interprétez les résultats obtenus.

  2. Utiliser le site précédemment utilisé photo-forensics pour savoir si la deuxième image, celle sur le pic-vert et la belette, a été modifiée ou pas.

    Vous devez faire des copies d'écran montrant comment vous avez utilisé le site et rédiger comment vous interprétez les résultats obtenus.

  3. Effectuer une recherche Internet (vous pouvez utiliser certains outils proposés dans la remarque ci-dessous) pour vérifier ce que vous avec devinez quant à ces deux photos.

    Vous devez citer sur votre document les sites consultés ainsi que les informations que vous y avez trouvées.

Comme en tant que citoyen.ne, il est essentiel que vous ne vous fassiez pas avoir par de fausses images, nous vous proposons d'autres outils pour savoir si des photos ont été modifiées ou détournées ; en voici quelques-uns :

pour détecter l'origine d'une image, plusieurs sites existent :

Voici quelques vidéos qui permettent d'apprendre à repérer si une image est modifiée ou détournée :

  1. vérifier une image avec Tineye

  2. Comment vérifier l'origine d'une image depuis son téléphone portable.

Une dernière vidéo qui permet d'apprendre à repérer si une vidéo a été modifiée .

QCM : Questionnaire pour vérifier ses acquis

Cliquez ici pour ouvrir le QCM afin de vérifier vos acquis

Cours de synthèse

Une synthèse de l'ensemble du cours.

Licence Creative Commons
Les différents auteurs mettent l'ensemble du site à disposition selon les termes de la licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International