Le codage des couleurs d'une image matricielle
1- Le codage RVB
Pour comprendre le codage numérique des couleurs, il faut pour cela revenir au fonctionnement de l'œil humain, à savoir comment nous pouvons percevoir les différentes couleurs. Le schéma ci-contre permet de visualiser le fonctionnement de l'oeil humain. Les rayons lumineux sont projetés au fond de l'œil 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. |  |
En conclusion, notre œil perçoit les différentes couleurs en superposant du rouge, du vert et du bleu. On parle alors de :
codage RVB : Rouge, Vert et Bleu en français
codage RGB : Red, Green and Blue en anglais.
Exemple : Addition des 3 couleurs sur PHOTOFILTRE
Pour se rendre compte de l'addition des trois couleurs, on va utiliser le logiciel de traitement d'image PHOTOFILTRE.
En déplaçant le curseur, tu dois observer les informations suivantes :
les teintes de rouge, vert et bleu varient entre 0 et 255,
par ajout de ces trois teintes, on obtient une multitude de couleur.
Une petite animation est disponible via le programme Python suivant à ouvrir dans EduPython puis à lancer en exécution.
Programme Python de superposition des couleurs RVB
En modifiant les différentes valeurs des composantes Red, Green et Blue, observer la couleur obtenue par addition de ces trois composantes.
Quelle couleur obtient-on avec :
red = 255, green = 0 et blue = 0 ?
red = 0, green = 255 et blue = 0 ?
red = 0, green = 0 et blue = 255 ?
red = 0, green = 0 et blue = 0 ?
red = 255, green = 255 et blue = 255 ?
red = 80, green = 80 et blue = 80 ?
2- Profondeur d'une image
En plus de sa définition, une image numérique utilise plus ou moins de mémoire selon le codage des informations de couleurs qu'elle possède. C'est ce que l'on nomme le codage de couleurs ou profondeur des couleurs, exprimé en bit par pixel (bpp) : 1, 4, 8, 16 bits...
Définition : Profondeur de couleurs
Nombre de bits utilisés pour coder la couleur d'un pixel, ou nombre de valeurs correspondants à ce nombre de bits.
Quelques exemples :
Pour une image en noir et blanc : un pixel prend la valeur 0 ou 1 selon qu'il prend la couleur blanc ou noir. Pour mémoriser cette information, un bit suffit. La profondeur de l'image est donc de 1 bit par pixel.
Pour une image en gris : les nuances de gris prennent les valeurs de 0 à 255. Pour mémoriser cette information, il faut donc coder en langage binaire les nombres de 0 à 255. Nous avons besoin pour cela de 8 bits soit 1 octet (Voir séance 3 du thème Internet). Ainsi, la profondeur d'une image en nuance de gris est de 8 bits par pixel ou encore 1 octet par pixel.
Pour une image en couleur RGB : chaque pixel représente un triplet (R,G,B) donc trois nombres allant de 0 à 255. Il faut alors 3 x 8=24 bits pour mémoriser l'information. La profondeur d'une image R,G,B est donc de 24 bits. Une image de profondeur 24 bits permet 256 x 256 x 256 couleurs différentes.
3- Poids d'une image
En connaissant le nombre de pixels d'une image et la mémoire nécessaire à l'affichage d'un pixel, il est normalement possible de définir exactement le poids que va utiliser le fichier image dans une mémoire informatique.
Définition : Calcul du poids d'une image
Formule théorique pour calculer le poids d'une image en octet :
Nombre de pixel total x codage couleurs (octet) = Poids (octet)
Quelques exemples :
Exemple d'image noir et blanc de taille 120 x 96 pixels :
Cette image contient 120 x 96 = 11 520 pixels. La profondeur de cette image est de 1 bit par pixel.
Son poids est donc de : 11520 x 1 = 11520 bits soit 11520/8 = 1440 octets = 1,44 Ko
Exemple d'image en couleur RGB de taille 1200 x 960 pixels :
Cette image contient 1200 x 960 = 1 152 000 pixels. La profondeur de cette image est de 24 bits par pixel.
Son poids est donc de : 1 152 000 x 24 = 27 648 000 bits soit 27 648 000/8 = 3 456 000 octets = 3456 Ko = 3,456 Mo
