Codage des données

De nombreuses informations ont été trouvées sur le site du webpedagogique : Infinitude

Les paragraphes marqués d'un * sont optionnels

1) Codage d' un entier positif

Retour au haut de la page

Un ordinateur ne manipule que des 0 et des 1 (circuit ouvert ou fermé par exemple), toutes les données doivent donc être codées sous forme de suites de 0 et de 1, c'est à dire sous forme binaire.

Ecriture décimale - écriture binaire


Quand on écrit 578 cela signifie 5 paquets de 102 + 7 paquets de 10 + 8 unités.
De même quand on écrit 1010 en binaire, cela signifie :
1 paquet de 23 + 0 paquet de 22 + 1 paquet de 2 + 0 unité, autrement dit 10 en écriture décimale.

Exercice 1.1 : à quels décimaux correspondent les binaires 11111101 et 101010 ?

A l'inverse pour transformer un décimal en binaire, on peut faire des divisions successives par 2.
Par exemple 77//2 = 38 et il reste 1 (on a donc une unité)
38//2 = 19 et il reste 0 (on a donc 0 paquet de 2)
19//2 = 9 et il reste 1 (on a donc 1 paquet de 22)
9//2 = 4 et il reste 1 (on a donc 1 paquet de 23)
4//2 = 2 et il reste 0 (on a donc 0 paquet de 24)
2//2 = 1 et il reste 0 (on a donc 0 paquet de 25)
et on a un paquet de 26
Conclusion : 77 correspond à 1001101 en binaire


Voici la disposition classique de ce calcul
Autre méthode : transformons 177 en binaire.
On peut se demander quelle est la plus grande puissance de deux contenue dans 177.
Pour cela il faut bien connaître le tableau des puissances de 2 :

On voit que 27 est la plus grande puissance de 2 contenue dans 177.
Donc 177 = 27 + 49 car 27 = 128
Et on recommence : la plus grande puissance de 2 contenue dans 49 est 32 = 25. On a alors : 177 = 27 + 25 + 17.
Puis à l'étape suivante : 177 = 27+ 25 + 24 + 1.
Conclusion : 177 (10) = 10110001 (2) ( 1 paquet de 27, 0 paquet de 26, 1 paquet de 25, 1 paquet de 24, 0 paquet de 23, 0 paquet de 22, 0 paquet de 2 et une unité)
Cette seconde méthode est souvent plus rapide, surtout pour les grands nombres.

Exercice 1.2 : à quels binaires correspondent les décimaux 37 et 158 ?

Vocabulaire :

  • bit = chiffre binaire (binary digit) c'est à dire 0 ou 1
  • bit de poids fort : bit le plus à gauche
  • octet: nombre binaire de 8 chiffres (par exemple 11001110)
  • kilo-octet (Ko) : 1000 octets (une page de texte représente environ 2 ko)
  • mega-octet (Mo) : 106 octets (un CDROM contient environ 640 MO)
  • giga-octet (Go) : 109 octets (un DVD contient environ 4,7 Go, 10 mètres de livres environ 1Go)
  • téra-octet (To) : 1012octets

Exercice 1.3 : quel est le plus grand entier que l'on peut coder sur un octet ? Combien de données différentes peut-on coder avec 10 bits ?

Ecriture hexadécimale

L'écriture héxadécimale est l'écriture en base 16..Il faut alors 16 chiffres, qui sont les chiffres de 0 à 9, puis A, B, C, D, E et F qui correspondent à 10, 11, 12, 13, 14 et 15.
Exemple : A15BE signifie 10 *164 + 1 *163 +5 * 162 + 11 * 16 + 14 = 660926.
A l'inverse, en partant de 55684 en décimal:
55684//16=3480 et il reste 4 on a donc 4 unités
3480//16=217 et il reste 8 on a donc 8 *16
217//16=13 et il reste 9 on a donc 9*162
et on a 13 * 163 c'est à dire D fois 163 on obtient donc en héxadécimal : D984 Cette écriture est souvent utilisée en informatique car elle est plus concise que l'écriture binaire, et qu'il est aisé de passer du binaire à l'héxadécimal et inversement.

* 2) Codage d'un entier relatif (avec un signe)

Retour au haut de la page

Une solution qui semble simple, est de réserver un bit pour le signe (0 si l'entier est positif et 1 s'il est négatif).
Codons un entier sur un octet en réservant le bit de poids fort au signe :
15 se code 00001111 et -15 donne 10001111.
Quand on additionne ces deux nombres sous forme décimale, on trouve 0, mais si on les ajoute sous forme binaire on obtient :
10011110 ( car 1+1 = 0 et une retenue de 1) ce qui représente le décimal 158 !
Cette méthode n'est donc pas utilisée pour les entiers....: il faudrait traiter spécifiquement le signe !
La méthode utilisée s'appelle le "complément à 2"
Supposons que l'on veuille coder des entiers signés (relatifs donc) sur 8 bits. Cela autorise le codage de 28 nombres : on va coder les nombres de -27 jusqu'à 27 -1 (ce qui avec le zéro fait bien 28 nombres).
Si l'entier x est positif on le code comme vu ci-dessus, si x est négatif on le code comme l'entier positif x + 28.
Tous les entiers positifs commenceront alors par un 0, et tous les négatifs par un 1 (car ils seront situés entre 27 et 28-1).
Si l'on ajoute x et -x on obtiendra alors x + (-x+28) c'est à dire 28 ce qui se traduit par un nombre en binaire commençant par 1 et suivi de huit 0. Comme il n'y a que 8 chiffres représentés, on ne voit pas le 1, et le résultat apparaît comme 0 !
Dans la pratique pour réaliser ceci on utilise l'astuce suivante : 28 - x = (28-1) - x + 1...
En effet 28-1 est le binaire qui s'écrit avec 8 fois le chiffre 1.
si on soustrait 1 à ce nombre, le dernier chiffre devient 0, si on soustrait 11, les deux derniers chiffres deviennent 0 etc..
Plus généralement, quand on soustrait x à ce nombre, cela revient à changer tous les 0 de x en des 1 et inversement (autrement dit, ceci consiste à inverser tous les bits), et il ne reste plus qu'à ajouter 1.
Exemple : pour coder -3 on part de 3 qui en biniare s'écrit 00000011
on inverse tous les bits ce qui donne 11111100 ( qui correspond à (28 - 1) - 3 = 252)
on ajoute 1 ce qui donne 11111101 qui est le codage de -3 et correspond à 28 - 3 = 253.
Vérifiez que si l'on ajoute 00000011 et 11111101 on obtient bien 1 00000000 ....

Exercice 2.1 : coder sur 8 bits les entiers -64 et -35 ?

Exercice 2.2 : à quels décimaux correspondent 10011001 et 01100101 ?

* 3) Codage d'un nombre à virgule

Retour au haut de la page

Le codage d'un nombre à virgule comporte deux difficultés : l'écriture en binaire avec des virgules d'une part, et d'autre part le codage de la virgule.
Nous allons traiter ces deux difficultés séparément.
Pour bien comprendre le principe de ce codage, nous allons d'abord voir comment on pourrait encoder un décimal à virgule avec 11 chiffres (de 0 à 9), pas de signe, pas de virgule.
Il faut comprendre que 374.123456789 = 3 * 102 + 7 * 101 + 4 * 100 + 1 * 10-1+ 2 * 10-2.....+ 9 * 10-9.
Ce nombre est de l'ordre de grandeur de 102 : si on connaît cet ordre de grandeur, on sait que la virgule est après le troisième chiffre, le premier chiffre étant non nul.
On va donc coder trois éléments :

  • le signe (sur un chiffre)
  • e : l'exposant de l'ordre de grandeur (ici 2) sur deux chiffres
  • les chiffres, en partant du coefficient de 10e

Le signe

Il est codé 0 pour un nombre positif et 1 pour un nombre négatif

L'ordre de grandeur

l'ordre de grandeur est 10e. On va coder e. Mais attention, e peut être positif comme pour 374,12 ou négatif : par exemple pour 0,00027 c'est -3.
Or on ne peut écrire de signe (-)....Comme on code cet ordre de grandeur sur 2 chiffres, on peut coder 100 entiers (de 0 à 99). Comme on veut pouvoir coder aussi bien les positifs que les négatifs, on décide de coder les entiers de -49 à 50 en les décalant : on ajoute 49 à chaque entier. Ainsi 2 sera codé 51 et -3 sera codé 46. On dit qu'on a fait un décalage de 49.

Les chiffres

On garde 8 chiffres (puisque 3 places sont déjà utilisées et qu'on en a 11). Pour 374,123456789, on garde 37412345.

Le résultat est donc pour ce nombre 0 51 37412345 (les espaces n'apparaissant pas, ils rappellent juste les trois parties du codage)
Il est alors simple de décoder en effectuant les opérations inverses et en plaçant la virgule de telle sorte que l'ordre de grandeur soit correct
Cela revient à utiliser l'écriture scientifique du nombre
374,123456789 = 3,74123456789 *102

On va faire de manière analogue avec un nombre écrit en binaire.

Ecriture en binaire avec une virgule

Par convention on écrira un "b" devant l'écriture d'un nombre en binaire
Il faut comprendre que b0,1 signifie 0 * 20 + 1 * 2-1
et b10,101 correspond à 1 * 21 + 0 * 20 + 1 * 2-1 + 0 * 2-2 + 1 * 2-3 de manière tout à fait analogue à l'écriture de nombres à virgule en décimal !
Cherchons l'écriture binaire de deux nombres à titre d'exemples :
a = 129,47.
Partons de 129 = 27+1, son ordre de grandeur binaire est 27.
Il s'écrira donc 27 + x1 * 26 + x2 * 25.....+ x7 * 20 + x8 * 2-1 + x9 * 2-2......l'écriture n'étant pas forcément finie.
x8, x9 etc...seront les chiffres derrière la virgule.
On connaît déjà x1, x2......x7. Comment faire pour trouver x8 ?
Il suffit de multiplier notre nombre par 2 et x8 sera alors le nombre d'unité binaire ( c'est à dire 1 si le résultat est impair et 0 sinon, car on est en base 2, on fait des "paquets" de deux...)
Or 129,47*2=258,94...Il n'y a pas d'unité binaire, donc x8=0.
Pour avoir x9, il suffit de multiplier encore par 2...129,47 * 22=517,88 donc x9 = 1 (il y a une unité binaire).
Donc 129,47 est environ égal à b10000001,01.
Autre exemple : b = 0,017.
Son ordre de grandeur est négatif !
Comment le trouver ? Il suffit de le multiplier par 2 jusqu'à obtenir plus que 1.
On voit que 0,017 * 26 = 1,088. Donc 0,017 = 1,088 * 2-6. L'ordre de grandeur est 2-6.
Ceci donne 0,017 = 2-6 + x1 * 2-7 + x2 * 2-8 .....
Si on veut obtenir x1 et x2, on multiplie par 28....si on veut aussi x3, on multiplie par 29 etc...
Multiplions par 210, on obtient 0,017 * 210 environ égal à 17. Or 17 = 24 + 20.
Ceci donne 0,017 environ égal à 2-6 + 2-10 donc son écriture binaire approximative est b0,0000010001.

La norme IEEE754

Cette norme encode les nombres à virgule en simple précision sur 32 bits (32 chiffres qui sont 0 ou 1), en réservant un bit au signe, 8 bits à l'ordre de grandeur, et les 23 bits restants aux chiffres (la mantisse plus précisément : voir ci dessous).

Le signe

Comme précédemment il est codé 0 pour un nombre positif et 1 pour un négatif

L'ordre de grandeur

Comme précédemment si le nombre est de l'ordre de grandeur de 2e , on va coder e.
8 bits, cela autorise 256 nombres. Mais comme ci-dessus, les ordres de grandeur peuvent être positifs ou négatifs. On décide de coder les entiers de -127 à 128 (ce qui en fait bien 256). Pour que tous ces codages correspondent à des entiers positifs, on fait un décalage de 127.
Pour 129,47 on code 7 et cela donne 7 + 127 = 134 = b10000110.
Pour 0,017 on code -6 et cela donne -6 + 127 = 121 = b1111001

La mantisse

129,47 environ égal à 1 * 27 + x1 * 26 + x2 * 25 +.............+ x23 * 2-16. Le coefficient de 27 est 1, et de manière générale, le coefficient de l'ordre de grandeur n'est pas nul...C'est donc toujours 1. On ne code que les chiffres suivants : cela s'appelle la mantisse.
Comme on veut 23 chiffres, le dernier coefficient est celui de 2-16.
Pour trouver x1, x2,.....x23, on calcule :
129,47 - 27 ≈ x1 * 26 + x2 * 25 +.............+ x23 * 2-16 et on multiplie par 216.
On obtient 1,47 * 2 16 ≈ x1 * 222 + x2 * 221 +.............+ x23 * 20
Il ne reste plus qu'à écrire en binaire 1,47 * 216 ≈ 96338 (arrondi à l'entier le plus proche)
96338 = b 00000010111100001010010 (sur 23 chiffres en ajoutant au besoin des zéros devant) donc :
x1 = 0, x2 = 0, x3 = 0, x4 = 0, x5 = 0, x6 = 0, x7 = 1, x8 = 0, x9 = 1 .......x22 = 1 et x23 = 0.
Faisons de même avec 0,017.
0,017 ≈ 1 * 2-6 + y1 * 2-7 + y2 * 2-8 + .....+ y23 * 2-29.
Donc 0,017 - 2-6 ≈ y1 * 2-7 + y2 * 2-8 + .....+ y23 * 2-29.
Ce qui donne 0,001375 ≈ y1 * 2-7 + y2 * 2-8 + .....+ y23 * 2-29.
Multiplions par 229 et arrondissons à l'entier le plus proche
738198 ≈ y1 * 222 + y2 * 221 + .....+ y23 * 20.
Il ne reste plus qu'à trouver l'écriture binaire de l'entier 738198 qui est b00010110100001110010110 (sur 23 chiffres).

Résultats

129,47 se code donc 0 10000110 00000010111100001010010
et 0,017 se code : 0 01111001 00010110100001110010110
A méditer chaque fois que l'on utilise des "floats" dans un programme !

On pourra télécharger Free Hex Editeur Neo et vérifier les conversions en modifiant dans "Affichage" "Afficher comme" (binaire ou float).

Exercice 3.1 : à quels décimaux correspondent 01000001100001000000000000000000 et 10000001100101100000000000000000 ?

Exercice 3.2 : encoder les décimaux - 12.575 et 11.625 ?

4) Codage des caractères

Retour au haut de la page

Le cours vu en classe sur les caractères

Un résumé de ce qu'il faut savoir sur le codage des caractères

Découverte :
Ouvrir le bloc note (dans démarrer/tous les programmes/accessoires) et écrire deux ou trois mots sans accents, puis écrire le caractère 'é'.
Enregistrer, puis ouvrir ce fichier avec le logiciel Free Hex Editeur Neo(en réglant dans Affichage/Afficher comme décimal).
On constate que chaque caractère correspond à un nombre ...
Reprendre le bloc note et enregistrer sous un nouveau nom en choisissant comme encodage Utf-8.
L'ouvrir alors avec FHEN...Le début est le même, à l'exception des trois premiers octets (qui s'appellent le BOM, Byte Order Mark qui indique au décodeur que l'encodage est Utf-8) mais le 'é' est codé avec deux nombres...On va voir que son charset est resté le même, mais que cela a été encodé différemment. Il existe différentes tables d'encodage des caractères, qui sont pour les caractères simples compatibles entre elles. La plus ancienne est la table ASCII (American Standard Code for Information Interchange) qui permet le codage de 128 caractères, qui ont été codés sur 7 bits (un bit étant réservé pour le contrôle des erreurs).
Cette table a été étendue pour gérer plus de caractères en utilisant le 8ème bit (quand l'electronique est devenue plus fiable) et est devenue la table ANSI (American National Standard Institute). Chaque caractère est donc codé par un octet dans ces deux tables (compatibles entre elles). Vous trouverez facilement cette table sur internet.
Evidemment un octet (8 bits) ne peut suffire pour coder tous les caractères existant sur la terre !
Un consortium a alors créé la norme UNICODE qui est une table de correspondance entre tous les caractères et un code.
L'Utf-8 est un encodage de cette norme. La principale différence est que tous les caractères ne sont pas codés sur le même nombre d'octets !
Les caractères les plus fréquents (ceux de la table ASCII) sont codés sur 1 octet (et cette norme est donc compatible avec l'ASCII), mais les suivants peuvent être codés sur 2, 3 ou 4 octets !
Pour décoder, il faut donc savoir si on doit considérer 1, 2, 3 ou 4 octets à la fois.
Ce sont les bits de poids forts qui donnent cette indication. Si l'octet commence par 0, il correspond à lui tout seul au caractère de la table ASCII, codé sur les 7 bits suivants.
Exemple : 01000101 correspond à 69 et au caractère 'E'.
Si l'octet commence par 110 il doit être associé à l'octet suivant qui commencera par 10. Afficher le deuxième fichier du bloc note en binaire, et constater que le 'é' est codé sur deux octets, le premier commençant par 110 et le second par 10.
Exemple : 11000001 10100000 correspond au binaire 00001100000 (on enlève le 110 à l'avant du premier octet et le 10 à l'avant du second) qui correspond à 192 c'est à dire au A majuscule avec un accent grave.
Faites de même avec les octets correspondants à 'é'...Que devrait-on retrouver ?
De même si l'octet commence par 1110 il faut lire 3 octets en enlevant le 1110 du premier et les 10 au début des deux suivants.
Et cela se termine avec un octet commençant par 11110 qui doit se lire avec les trois suivants, qui commencent par 10.
Ceci a été fait dans un souci d'économie : si tous les caractères étaient codés sur un même nombre d'octets, les caractères les plus fréquents occuperaient au moins le double de place, et finalement, les textes occuperait également plus de place en mémoire. Ce principe est d'ailleurs également mis en oeuvre dans certains programmes de compression (Huffmann par exemple).
Ecrire dans un fichier du bloc-note le caractère spécial ™ (Le TM de Trade Mark que l'on peut écrire en allant dans Démarrer/Tous les programmes/accessoires/outils système/table des caractères) , puis l'ouvrir avec FHEN : afficher en binaire et noter les octets correspondants.
Déterminer à quel charset cela correspond....Dans une console python taper ord('™') et vérifier votre résultat

Exercice 4.1 : écrire un programme python qui donne les 10000 premiers caractères (en unicode) et leur charset (pour ceux pour lesquels c'est possible). On rappelle que chr(62) donne le caractère de charset 62, ord('a') étant l'instruction inverse. Il sera indispensable d'utiliser les instructi ons "Try" et "Except" car le système ne sait pas afficher tous ces caractères !

Dans Word ou Open Office, on peut retrouver les codes des caractères spéciaux lors de leur insertion, mais le charset est donné en hexadecimal, c'est à dire en base 16..., souvent sous la forme U+222B par exemple pour le caractère correspondant à l'intégrale de charset 222B en hexadécimal (8747 en décimal).

Les deux schémas suivants résument ces notions sur le codage des caractères :

tables de caractères

utf-8

5) Codage des images

Retour au haut de la page

Un document plus complet sur le codage des couleurs et des images

Voici une partie du codage d'une image (Lena.bmp) :
01000010 01001101 00110110 00000000 00001100 00000000 00000000 00000000 00000000 00000000 00110110 00000000 00000000 00000000 00101000 00000000
00000000 00000000 00000000 00000010 00000000 00000000 00000000 00000010 00000000 00000000 00000001 00000000 00011000 00000000 00000000 00000000
00000000 00000000 00000000 00000000 00000000 00000000 01110101 00001010 00000000 00000000 01110101 00001010 00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000000 00000000 00000000 00111001 00010110 01010010 00111001 00010110 01010010 00111110 00100000 01100000 00111110
00011100 01011101 01000001 00011110 01100001 00111001 00010101 01011110 00111110 00011010 01011100 00111100 00011100 01011101 01000100 00100100
01100010 01000010 00011011 01011110 00111010 00010101 01011001 01000010 00011001 01011101 01001011 00011011 01011111 01000101 00011100 01100000
01010111 00111000 01111001 01110100 01011000 10010011 10000000 10000001 10110111 10011101 10110001 11010001 10101010 10111100 11011010 10110001
10111101 11011001 10101111 10111101 11011011 10110011 11000000 …..
Problème : comment restituer l'image à partir de ce fichier !
En fait ce fichier commence par un entête permettant de savoir comment traiter le fichier. Le début de l'entête indique le format du fichier (ici BMP) c'est la signature du format (sous Windows c'est BM). Ceci permet de savoir comment l'image a été codée. En jaune (octets11, 12, 13 et 14) l'offset : permet de savoir où commence le début du corps de l'image : ici cela donne 54, ce qui mène aux octets en bleu.
Dans le format BMP une image est vue comme une carte de points : c'est le sens de "bitmap". Chaque "point" de l'image, appelé pixel, est décrit par sa couleur.
On dit que l'on a une image matricielle (une matrice en maths est un tableau de nombres) Par exemple, pour une image en noir et blanc, "00110100" signifierait que le premier pixel est noir, le second aussi, le troisième est blanc etc…. Encore faut-il savoir combien il y a de pixels dans chaque ligne et dans chaque colonne ! L'image précédente pourrait correspondre à :

00    ou   0011
11           0100
01
00     par exemple !

D'où l'intérêt de l'entête : on y lit la taille de l'image, c’est-à-dire sa largeur et sa hauteur, ce qui permet de retrouver la place de chaque pixel.
On y lit aussi le nombre de couleurs possibles pour un pixel.

  • Un pixel en noir et blanc peut être décrit par un seul bit (0 ou 1).
  • Un pixel en niveau de gris est généralement décrit par un octet (256 niveaux de gris de 0 à 255). Le fichier précédent représenterait alors un seul pixel avec un niveau de gris égal à 0+0*2+1*4+0*8+1*16+1*32 = 52 : plus ce nombre est bas, plus le gris est foncé (car on approche de 0, et quand on ne projette aucune couleur on a un écran noir).
  • Un pixel en "True color" est codé sur trois octets : l'un donne le niveau de rouge (de 0 à 255), l'un le niveau de vert ( de 0 à 255) et le dernier le niveau de bleu (de 0 à 255). C'est le codage RVB (ou RGB en anglais). La couleur sera rouge si le niveau de vert et de bleu sont nuls, par exemple ( 240,0,0), le premier entier n'étant pas trop faible, sinon cela ressemblera plus à du noir ! Plus ce premier nombre est élevé, plus la couleur est claire. Noir correspond à (0, 0 , 0) et les gris à (n,n,n) où n est un entier entre 1 et 254. Par exemple ( 120, 120, 120) est un gris moyen. Vous pouvez utiliser "La boîte à couleur" pour visualiser les couleurs suivant leur code RGB.

Image extraite du site : http://www.mysti2d.net/
Evidemment, ce format est très volumineux.
Pour diminuer le poids des images matricielles on utilise la compression.
Exemple : si vous devez dicter "AAAAAAAHHHHHHHHAA" vous allez dire "7A8H2A"…Vous avez compressé votre chaîne de caractères …Vous avez même fait une compression sans perte, car à partir de "7A8H2A" vous pouvez très bien retrouver la chaîne de départ !
La compression en archives ZIP est aussi une compression sans perte pour tous types de fichiers.
Il existe d'autres types de compressions, appelées compressions avec perte : on comprend bien que si on change la couleur d'un seul pixel d'une image, on ne verra pas la différence avec l'image originelle (si l'image est assez grande). La compression utilisée par le format JPEG est de ce type. Bien sûr, le type de compression est indiqué dans l'entête pour permettre la décompression !
Voici différents formats d'images matricielles, sauf pour le dernier:

  • bmp : Format originel qui applique une couleur à chaque pixel (codée sur 1bit, 1 octet ou 3 octets). En général sans compression. Format très volumineux non adapté à internet. 224 à 16 millions de couleurs possibles.
  • gif : utilise une palette de 256 couleurs (choisies selon l'image) et n'est plus tellement utilisé sauf pour des gifs animés. Au départ il y a 16 millions de couleurs comme pour le BMP, mais les 256 plus utilisées sont repérées et numérotées de 0 à 255. On attribue alors à chaque pixel la couleur de la palette la plus proche. Un seul octet suffit alors pour coder chaque pixel. Format assez léger à cause du nombre réduit de couleurs, mais peu adapté à la photographie.
  • jpg : Idéal pour les photographies mais il faut éviter les sauvegardes consécutives avec compression, car la compression se fait avec perte. Le niveau de compression est choisi par l'utilisateur.
  • png : Idéal pour des logos ou des icônes. Gère la transparence. Remplace maintenant souvent les gifs.
  • svg : Images vectorielles : qui décrit les formes géométriques présentes au lieu de donner une couleur à chaque pixel comme les images matricielles . Idéal pour des dessins géométriques (plans, logos). La taille de ce type d'images peut être modifiée sans aucune perte de qualité, ce qui n'est pas le cas pour une image matricielle (pixelisation).

Ces images sont extraites du site : http://www.mysti2d.net/

Poids de cette image pour différent formats:

  • BMP : 49 242 octets
  • JPG : 2 873 octets
  • PNG : 398 octets
  • SVG : 249 octets