Le principe
Les algorithmes qui permettent de réduire la taille des
fichiers sont souvent complexes. Il n'est pas question d'envisager
de les expliquer ici. Contentons-nous de montrer comment il serait
possible de comprimer un fichier contenant un texte ou une image.
Cas d'un texte: un texte est formé d'un
certain nombre de mots. Prenons, par exemple, la phrase
'une petite
faute ou une toute petite faute est une faute'
Bien!
Ca commence fort, comme exemple. Il contient lui-même une faute!
Il faut dire 'une petite faute ou une toute petite faute sont des
fautes'.
Remarque
extrêmement pertinente, cher élève. Je propose donc que vous trouviez
un meilleur exemple qui remplacera illico ce fragment de phrase
boiteux, dès que vous me l'aurez proposé.
La phrase donnée en exemple contient 56 caractères, y compris
les 'espaces'. Il est cependant possible de compresser un peu le
fichier correspondant en repérant
les différents mots et en composant un 'dictionnaire'. On y trouve
les mots:
1 |
une |
3 caractères |
2 |
'espace' |
1 caractère |
3 |
petite |
6 caractères |
4 |
faute |
5 caractères |
5 |
ou |
2 caractères |
6 |
toute |
5 caractères |
7 |
est |
3 caractères |
soit 25 caractères + 7 codes associés à chacun des mots = 32
signes.
Il suffit donc d'enregistrer ce dictionnaire et les codes correspondants
aux différents mots qu'il contient. Ensuite, il faut enregistrer
les mots sous forme de suites de codes:
1 |
2 |
3 |
2 |
4 |
2 |
5 |
2 |
1 |
2 |
6 |
2 |
3 |
2 |
4 |
2 |
7 |
2 |
1 |
2 |
4 |
soit 21 signes.
Cela nous mène donc à un total de 53 signes à enregistrer au lieu
de 56.
Ouaah!
Quel gain phénoménal!
Moquez-vous,
jeune homme! L'avantage du codage est bien sûr minime, dans l'exemple
proposé. Cependant, sur des textes plus longs et contenant plus
de mots
répétés, le
gain deviendra appréciable.
L'exemple ne vise qu'à montrer qu'il est possible de compresser.
Dans les méthodes réelles de compression, ce ne sont pas des
mots qui figurent dans les dictionnaires, mais des motifs de caractères
répétés.
Cas
d'un dessin point par point: dans un dessin point par
point (BMP, par exemple), chaque pixel de l'image est codé par
un nombre.
Par exemple, pour l'image de
taille 16 pixels x 16 pixels, agrandie ci-contre:
- noir = 0;
- blanc = 16;
- orange = 8;
- ...
On pourrait donc enregistrer l'image sous forme d'un tableau de
16x16 = 256 nombres:
16 |
16 |
16 |
16 |
16 |
0 |
0 |
0 |
0 |
0 |
0 |
16 |
16 |
16 |
16 |
16 |
16 |
16 |
16 |
0 |
0 |
8 |
8 |
8 |
8 |
8 |
8 |
0 |
0 |
16 |
16 |
16 |
16 |
16 |
0 |
8 |
8 |
8 |
8 |
8 |
8 |
8 |
8 |
8 |
8 |
0 |
16 |
16 |
16 |
0 |
8 |
8 |
8 |
8 |
8 |
8 |
8 |
8 |
8 |
8 |
8 |
8 |
0 |
16 |
etc... |
Pour la portion de l'image présentée ci-dessus, il faudrait donc
enregistrer 4x16=64 nombres.
Mais il serait aussi possible d'enregistrer les mêmes informations
sous la forme de couples
(couleur:nombre de pixels).
Ce qui, pour les quatre lignes illustrées, donnerait
l'ensemble de couples suivants 16:5;
0:6; 16:5
16:3; 0:2; 8:6; 0:2; 16:3
16:2; 0:1; 8:10; 0:1; 16:2
16:1; 0:1; 8:12; 0:1; 16:1
Soit seulement 36 nombres. Le fichier enregistré serait donc presque
deux fois plus petit. L'inconvénient est qu'il faut décoder les
informations et reconstruire l'image au moment de relire le fichier.
|