cours-codage des images

C1.2- CODAGE ET CHIFFRAGE
LYCEE BELLEVUE
COURS 1 : CODAGE ET CHIFFRAGE DES IMAGES
1.
REVISIONS CODAGE ..................................................................................................................................... 1
1.1.
Les nombres entiers naturels ..................................................................................... 1
1.2.
Les nombres rationnels ............................................................................................. 2
2. IMAGES ............................................................................................................................................................. 3
2.1.
Notions de colorimétrie ............................................................................................. 3
2.2.
Le modèle matriciel « bitmap »................................................................................. 4
2.3.
Le format BMP ......................................................................................................... 5
2.4.
Passer en niveau de gris ............................................................................................ 8
2.5.
Image monochrome ................................................................................................... 8
3. LA COMPRESSION DES IMAGES « BITMAP » ........................................................................................ 9
3.1.
Méthode à base de redondances : la compression RLE (Run-lenght encoding) ....... 9
3.2.
Méthode à base de dictionnaire : La compression LZW (Lempel Ziv Welch) ....... 10
3.3.
Méthode statistique : La méthode de Huffman ....................................................... 11
3.4.
La compression avec pertes JPEG .......................................................................... 13
1. REVISIONS CODAGE
Un code binaire est une correspondance arbitraire entre un ensemble de symboles (0 et 1) et un ensemble
d’objets (chiffres, lettres, couleurs, etc.).
On appelle « octet (o) », un mot binaire de 8 bits.
Préfixes binaires (préfixes CEI)
Préfixes décimaux (préfixes SI)
Nom Symb. Facteur
Nom Symb. Facteur
kibi Ki
210 = 1 024
kilo
mébi Mi
220 = 1 048 576
gibi Gi
Err.
103 = 1 000
2%
méga M
106 = 1 000 000
5%
230 = 1 073 741 824
giga G
109 = 1 000 000 000
7%
tébi Ti
240 = 1 099 511 627 776
téra
1012 = 1 000 000 000 000
10 %
pébi Pi
250 = 1 125 899 906 842 624
péta P
1015 = 1 000 000 000 000 000
13 %
k
T
Dans ce deuxième tableau, l’erreur indiquée dans la colonne de droite est celle effectuée quand on utilise un
préfixe SI à la place d’un préfixe binaire. L’usage de cette norme ne s’est pas encore généralisé. Microsoft
Windows continue à utiliser à tort les préfixes SI : par exemple 1 ko = 1024 octets au lieu de 1000 octets. D’autres,
comme les systèmes d’exploitation libres de type GNU/Linux, adoptent les préfixes binaires.
1.1.Les nombres entiers naturels
Le Code Binaire Naturel
Les codes utilisés en général pour représenter des nombres sont des codes pondérés : dans une base de
travail donnée, la valeur d’un rang donné, est un multiple par la base de celle du rang inférieur. Chaque
position de chiffre a un poids. Par exemple, pour un mot binaire à 8 bits (octet) :
Bit de poids fort (MSB)
Poids respectifs 
Bit de poids faible (LSB)
0
1
1
0
1
0
27
26
25
24
23
22
0
21
1
20
On appelle ce codage à champ fixe car le nombre « k » de bits destinés au codage est constant. Il est
alors possible de représenter un entier naturel « N » tel que 0  N  2k-1.
Fabien Hospital
1/13
C1.2- CODAGE ET CHIFFRAGE
LYCEE BELLEVUE
Un entier naturel codé sur un octet est forcément compris entre 0 et 255.
L’ Hexadécimal
Le système hexadécimal est un système de numération positionnel en base 16.
Il utilise ainsi 16 symboles, en général les chiffres arabes pour les dix
premiers chiffres et les lettres A à F pour les six suivants.
Le système hexadécimal est utilisé notamment en électronique numérique et
n informatique
1.2.Les nombres rationnels
Virgule flottante (« floating point »)  le standard IEEE 754
On représente les nombres sous la forme : N = ± 1,M × BE
B : la base est 2
M : la mantisse
E : l’exposant
Le nombre à représenter, une fois traduit en binaire, peut toujours s’écrire sous la forme 1, ... ; ainsi il est
inutile de représenter ce premier 1 et on codera la mantisse à partir du bit suivant la virgule.
Les deux normes suivantes sont définies :
- IEEE 754 simple précision : sur 32 bits
SM : 1 bit ; Eb : 8 bits ; M : 23 bits (biais = 127)
- IEEE 754 double précision : sur 64 bits
SM : 1 bit ; Eb : 11 bits ; M : 52 bits (biais = 1023)
Exemple : Nous voulons représenter 525,5 au format IEEE 754 simple précision.
On commence par écrire 525,5 en base 2 : 525,5(10) = 1000001101,1(2)
On en déduit 525,5(10)= 1,0000011011(2) × 29.
On a donc :
– SM = 0 car le nombre est positif
– Eb = E + 127 = 9 + 127 = 136(10) = 10001000(2) en base 2 sur 8 bits
– M = 00000110110000000000000(2)
La représentation du nombre 525,5 en binaire avec la norme IEEE 754 est donc :
0 10001000 00000110110000000000000(2) = 48036000(16)
En arithmétique à virgule flottante, on peut obtenir un résultat valable, ou alors rencontrer un
problème de dépassement par valeur supérieure (overflow) lorsque le résultat est trop grand pour
pouvoir être représenté, ou par valeur inférieure (underflow) lorsque le résultat est trop petit.
Certaines représentations sont réservées à la représentation de l’infini ou de codes d’erreurs. Ce qui
a été dit précédemment est valable pour tous les nombres dont la représentation au format IEEE 754,
a un exposant biaisé Eb strictement compris entre 0 et Valeur Max (255 en simple précision et 2047
en double précision).
Fabien Hospital
2/13
C1.2- CODAGE ET CHIFFRAGE
LYCEE BELLEVUE
2. IMAGES
Problème : Un ordinateur traite de l’information sous forme numérique binaire. Comment
coder les images à l’aide de codes binaires ?
Il existe deux modes de codage d’une image numérique :
1. Le mode matriciel (« bitmap ») : il repose sur le principe d’une grille de pixels,
2. Le mode vectoriel (« vector ») : on décrit les propriétés mathématiques des formes
de l’image.
Une image vectorielle peut être zoomée sans que cela n’altère
la qualité du rendu. Ce mode est adapté aux formes et images
qui ne sont pas trop complexes : logos, typographie, plans,
cartes, etc. Les formats de fichiers vectoriels sont PostScript,
PDF, SVG, etc.
Le nombre de pixels utilisés par unité de longueur donne un
rendu plus ou moins précis des formes de l’image. Un zoom
trop important fait apparaître la pixellisation de l’image. Les
formats de fichiers matriciels sont BMP, GIF, PNG, JPEG, etc.
On s’intéresse par la suite au codage des images par le mode matriciel.
2.1. Notions de colorimétrie
Problème : Comment coder les couleurs à l’aide de codes binaires ?
La synthèse additive est utilisée par les moniteurs et les projecteurs. Elle est constituée des trois lumières
de base qui sont le Rouge, le Vert et le Bleu (RVB). Les couleurs secondaires sont plus claires que les
primaires, c’est pour cela que leur synthèse est appelée additive.
La synthèse soustractive est utilisée
dans l’imprimerie et par les
imprimantes. Les couleurs primaires
sont le Cyan, le Magenta, le Jaune et le
Noir (CMJN). Si on mélange deux
couleurs primaires, le résultat sera une
couleur secondaire plus sombre qui
absorbera donc plus de lumière, c’est
pour cette raison que cette synthèse est
nommée soustractive.
Synthèse
additive
Un modèle de colorimétrie est une manière
de coder des couleurs avec des nombres.
Synthèse
soustractive
Le modèle Lab caractérise une couleur avec :
 un paramètre d'intensité correspondant à la luminance : la combinaison L* est la clarté, elle va de
0% (noir) à 100% (blanc),
 deux paramètres de chrominance qui décrivent la couleur : la composante
a* représente la gamme de l'axe du vert (-128) au rouge (+128). La
composante b* représente la gamme de l'axe du bleu (-128) au jaune
(+128). Ce modèle est proche de la vision humaine.
Le modèle RVB caractérise une couleur à l'aide de trois paramètres (chacun sur
un octet, soit un nombre de 0 à 255) correspondant aux trois couleurs Rouge, Vert
et Bleu.
00 00 00(16) = (0,0,0) = noir
Fabien Hospital
Palette
« Paint
Shop »
3/13
C1.2- CODAGE ET CHIFFRAGE
LYCEE BELLEVUE
FF FF FF(16) = (255,255,255) = blanc
FF 00 00(16) = (255,0,0) = rouge
2.2. Le modèle matriciel « bitmap »
Une matrice de pixels (« picture elements ») est constituée d'un ensemble de points pour former une
image. Le pixel représente ainsi le plus petit élément constitutif d'une image numérique.
- Formats limités à 256 couleurs : GIF, PCX, PGM, etc.
- Formats acceptant différentes quantifications BMP, TIFF, TGA, PNG, etc.
- Formats limités à 16 millions de couleurs JPEG, etc.
Les images peuvent facilement être créées et stockées dans un tableau de pixels, la lecture et l’écriture
d’un pixel sont aisées.
Par contre, les fichiers peuvent être très gros (nécessité de compression).
De plus, il y a des problèmes de changement d'échelle (apparition d’effets de marches d’escalier ou de
flou avec interpolation). Enfin, les dimensions de l’image doivent être prévues pour la
résolution de l'interface de sortie (écran, imprimante).
La discrétisation d’une image se caractérise par sa définition, c'est-à-dire le nombre de pixels
utilisés.
La résolution de l’image établit un lien entre le nombre de pixels d’une image et sa taille
réelle. Elle se caractérise par un nombre de pixels par unité de longueur.
Pixel ?
25,4 mm
La quantification des couleurs est exprimée en bits par pixel (bpp) : 1 (deux
couleurs : noir et blanc par exemple), 8 (niveaux de gris entre 0 et 255 par exemple,
256 couleurs), 16 bits, etc
8 dpi
Exemple 1 :
« 800  600 » signifie une largeur de 800 et une hauteur de 600 pixels.
« 600 dpi » (« ppp » : point par pouce, « dpi » : dots per inch) signifie 600 pixels par pouce (1 pouce =
25,4 mm).
En connaissant le nombre de pixels d'une image et la mémoire
nécessaire à l'affichage d'un pixel, il est alors possible de définir
exactement la taille qu’occupe le fichier.
Une définition du type 800  600 avec un codage sur 24 bits (3 octets)
des couleurs, donne un fichier image de taille 1,44 Mo.
En-tête (« header »)
Identificateur du format
Palette de couleur (éventuellement)
Données d’image
Suite
Fabien Hospital
de
pixels
éventuellement
4/13
C1.2- CODAGE ET CHIFFRAGE
LYCEE BELLEVUE
2.3.Le format BMP
Fabien Hospital
5/13
C1.2- CODAGE ET CHIFFRAGE
Fabien Hospital
LYCEE BELLEVUE
6/13
C1.2- CODAGE ET CHIFFRAGE
LYCEE BELLEVUE
Exemple 2 : Inversion des couleurs d’une image
Inverser les couleurs d’une image ayant deux couleurs « noir » et « blanc » revient à changer les pixels
noirs en blancs et inversement.
Pour le modèle RVB, cela revient à changer chaque « valeur initiale » R, V et B en « 255 – valeur
initiale ».
Algorithme 1 Inversion des couleurs d’une image BMP codée en 24 bits
Données : T[1..n] : le tableau des n octets du fichier image
Résultat : le tableau T avec les couleurs de chaque pixel inversées
Pour i de 55 à n faire
T[i]

// on démarre après les entêtes du fichier et du bitmap
255 – T[i]
Fin Pour
Programme python simplifié
def inversion(data):
i=0
l=len(data)
while i<len(data):
data[i]=255-data[i]
i+=1
return
Algorithme 1.2
Inversion au dessus de la diagonale des couleurs d’une image BMP codée en 24 bits
Données : T[1..n] : le tableau des n octets du fichier image
L, H : largeur et hauteur de l’image
Résultat : le tableau T avec les couleurs de chaque pixel situés au dessus de la diagonale inversées
// Chaque ligne comporte un nombre d’octets multiple de 4
Si L mod 4 <> 0 alors
x  L + 4 - L mod 4
Sinon
xL
Fin Si
Pour i de 55 à n faire
// on démarre après les entêtes du fichier et du bitmap
y  ( i – 55 ) div 3
// y mod x est la colonne du pixel
Si (y mod x) < (y div x)*L/H alors
// y div x est la ligne du pixel
T[i]

255 – T[i]
Fin Si
Fin Pour
Image 3
Fabien Hospital
3
image inversée
image avec inversion au dessus de la diagonale
7/13
C1.2- CODAGE ET CHIFFRAGE
Image 1600
 1200
LYCEE BELLEVUE
image inversée
image avec inversion au dessus de la diagonale
2.4. Passer en niveau de gris
Une des possibilités pour obtenir une image en niveau de gris à partir d'une image codée sur les 3
composantes de couleur (bleu,vert,rouge) est de remplacer la valeur de chaque composante de chaque
pixel par la moyenne des valeurs des 3 composantes du pixel considéré.
Algorithme 2 Passage en niveau de gris
Données : T[1..n] : le tableau des n octets du fichier image
Résultat : le tableau T avec les couleurs en niveau de gris
Tant que i < = n-2 faire // utiliser un while
moy  int((T[i+1]+T[i+2]+T[i])/3)
T[i]  moy
T[i+1]  moy
T[i+2]  moy
i  i+3
Fin Tant que
def niveau_de_gris(data):
i=0
l=len(data)
while i<l-2:
moy=int((data[i+1]+data[i+2]+data[i])/3)
data[i]=moy
data[i+1]=moy
data[i+2]=moy
i+=3
return
2.5. Image monochrome
Chaque composante peut prendre 256 valeurs, de 0 à 255. Pour rendre l'image monochrome ( 2 couleurs),
il faut donc réduire le nombre de valeurs de chaque composante et donc la couleur de chaque pixel à 2.
Pour ce faire, il suffit de fixer un seuil (par exemple 128). Pour chaque pixel, pour chaque composante, il
faut alors effectuer une comparaison. Si la valeur de la composante est inférieure au seuil, alors la
composante prend par exemple la valeur 0. Sinon, elle prend la valeur 255.
Algorithme 3 Passage en monochrome d’une image BMP codée en 24 bits
Données : T[1..n] : le tableau des n octets du fichier image, le seuil et les deux niveaux de couleurs choisis
Résultat : le tableau T avec uniquement les 2 couleurs choisies
Tant que i <= n faire // utiliser un while
SI T[i]<seuil alors
T[i] = T[i+1] = T[i+2] = niveau1
Sinon
T[i] = T[i+1] = T[i+2] = niveau 2
Fin si
i=i+3
Fin Tant que
def monochrome(data,seuil,niveau1,niveau2):
Fabien Hospital
8/13
C1.2- CODAGE ET CHIFFRAGE
LYCEE BELLEVUE
i=0
l=len(data)
while i<len(data):
if data[i]<seuil:
data[i]=niveau1
else:
data[i]=niveau2
i+=1
return
3. LA COMPRESSION DES IMAGES « BITMAP »
Certains formats de fichiers « bitmap » autorisent la compression des données.
Celle-ci peut se faire sans pertes (compression RLE, LZW, Huffman) ou avec pertes (compression
JPEG). On définit le facteur de compression comme le rapport entre la taille du fichier initial et la taille
du fichier compressé.
Les méthodes RLE, LZW et Huffman, sont utilisées pour d’autres codages que celui des images.
Le format BMP autorise des compressions de type RLE, LZW ou JPEG.
Les formats TIFF, PNG et GIF utilise la compression LZW.
3.1. Méthode à base de redondances : la compression RLE (Run-lenght
encoding)
Un encodage RLE consiste à indiquer pour chaque suite de pixels d'une même couleur, le nombre de
pixels de cette séquence. Le résultat comporte en général moins de caractères, bien que ça ne soit pas une
obligation.
Le format BMP permet d'utiliser la compression RLE pour les images en 1, 4 et 8 bits/pixel.
Plus le nombre de couleurs est important, moins nombreuses sont les chances de redondance. La méthode
est donc particulièrement intéressante pour les images en deux couleurs (noir et blanc).
Par exemple la liste « 0 0 0 0 F F 0 0 0 0 0 0 F F F F », peut-être encodée comme suit :
« 4 0 2 F 6 0 4 F ».
Si chaque caractère est codé sur 8 bits, la chaîne initiale fait 16  8=128 bits.
La chaîne encodée fait 8  8=64 bits.
Algorithme 4 Compression RLE
Données : T[1..n] : un tableau de n caractères
Résultat : le tableau L encodant la liste de caractères du tableau T selon la méthode RLE
Compression_RLE(T)
L  []
Pour i de 1 à n faire
c  T[i]
k1
Tant que i+k<=n et T[i+k]==c faire
k  k+1
Fin Tant que
L  L + [k]
L  L + [c]
i i + k
Fin Pour
Retourner L
Fabien Hospital
9/13
C1.2- CODAGE ET CHIFFRAGE
LYCEE BELLEVUE
def Compression_RLE (data):
i=1
L=[]
n=len(data)
For i in range(n):
c=data[i]
while (i+k<n & data[i+k]==c) :
k+=1
L=L+[k]
L=L+[c]
i+=k
return L
3.2. Méthode à base de dictionnaire : La compression LZW (Lempel Ziv
Welch)
Le principe général est de :
 trouver des séquences de pixels qui se répètent,
 construire un dictionnaire associant un code unique à chaque séquence,
 remplacer la séquence de pixels par le code.
Plus le nombre de couleurs est important, moins il est probable que des séquences se répètent.
La méthode n’est donc pas appliquée lorsque le nombre de couleurs est élevé.
Initialement, le dictionnaire comprend tous les caractères de la table ASCII. Les index de 0 à 255 sont
donc occupés. Le dictionnaire est ensuite complété lorsque des suites nouvelles de caractères
apparaissent.
Au fur et à mesure que la taille du dictionnaire augmente, il faut augmenter le nombre de bits nécessaires
au codage des éléments. Au delà du 255e, 511e indice, etc., il faut rajouter un bit.
Par contre, le dictionnaire est reconstruit à partir du fichier compressé, il n'est pas nécessaire de le joindre
à ce dernier.
Par exemple la chaîne « 0 0 0 0 F F 0 0 0 0 0 0 F F F F », peut-être encodée comme suit :
i
x
1
Fabien Hospital
T[i]
x+T[i]
0
0
Ajout dans L
Ajout dans dictionnaire
0
<256> = 00
2
0
0
00
3
0
0
00
4
00
0
000
<256>
<257> = 000
5
0
F
0F
0
<258> = 0F
6
F
F
FF
F
<259> = FF
7
F
0
F0
F
<260> = F0
8
0
0
00
9
00
0
000
10
000
0
0000
<257>
<261> = 0000
11
0
0
00
12
00
0
000
13
000
F
000F
<257>
<262> = 000F
14
F
F
FF
15
FF
F
FFF
<259>
<263> = FFF
16
F
F
FF
17
FF
<259>
10/13
C1.2- CODAGE ET CHIFFRAGE
LYCEE BELLEVUE
Chaîne encodée : « 0 <256> 0 F F <257> <257> <259> <259> ».
Chaque caractère de la chaîne encodée est codé sur 9 bits (il faut aller au delà de 256 valeurs distinctes).
Celle-ci fait donc 9  9=81 bits.
Dans l’algorithme suivant, le dictionnaire est une liste de chaînes de caractères. Les fonctions
Est_dans_dictionnaire() et Ajouter_dans_dictionnaire() ne sont pas détaillées
Algorithme 5 Compression LZW
Données : T[1..n] : un tableau de n caractères
Résultat : le tableau L encodant la liste de caractères du tableau T selon la méthode LZW
Compression_LZW(T)
i1
L  []
x  ""
Tant que i<=n+1 faire
Si i<n alors
Si Est_dans_dictionnaire(x+T[i]) alors
x  x + T[i]
Sinon
Ajouter_dans_dictionnaire(x+T[i])
L L + x
x  T[i]
Fin Si
Sinon
// i=n

L
L+x
Fin Si
i  i+1
Fin Tant que
Retourner L
3.3. Méthode statistique : La méthode de Huffman
Exemple : Coder 4000 caractères de 6 valeurs différentes
En ASCII, cela nécessite 8  4000 = 32000 bits.
En limitant le codage à 3 bits/caractère, il faut 3  4000 = 12000 bits.
Facteur de compression : 2,6.
Peut-on faire encore mieux ?
Par exemple si la répartition des caractères est connue (voir tableau) :
Il faut alors 3  800+3  400+3  400+4  200+1  2000+4  200 = 8400 bits.
Facteur de compression : 3,8.
Caractère 1
Caractère 2
Caractère 3
Caractère 4
Caractère 5
Caractère 6
Fréquence (%)
20
10
10
5
50
5
Codage binaire de
longueur fixe
000
001
010
011
100
101
Codage
de
variable
111
101
100
1101
0
1100
"préfixe"
longueur
Certaines couleurs de pixels reviennent plus souvent que d’autres.
Fabien Hospital
11/13
C1.2- CODAGE ET CHIFFRAGE
LYCEE BELLEVUE
L'idée est de réduire le nombre de bits utilisés pour le codage des pixels les plus fréquents et d'augmenter
ce nombre pour les pixels plus rares. On utilise alors un codage de taille variable.
Par contre, il faut utiliser un codage "préfixe", c'est à dire tel qu'un mot du code n'est pas le préfixe d'un
autre mot. On peut alors lire une séquence codée sans ambiguïtés.
Problème : Comment déterminer le codage de longueur variable optimal ?
Pour représenter un codage préfixe, on utilise un arbre :
- Les feuilles sont les caractères,
- Les branches sont "0" (fils gauche) ou "1" (fils droit),
- Chaque nœud interne contient la somme des poids de ses fils,
- Chaque mot de code est donc un chemin de la racine vers une feuille contenant le caractère codé.
100
0
45
0
100
0
1
car 5 : 50
55
1
1
50
0
1
1
30
15
1
0
car 2 : 10
car 1 : 20
20
0
0
30
0
1
1
0
car 3 : 10
car 4 : 5
car 3 : 10
0
car 6 : 5
car 5 : 50
10
car 2 : 10
1
1
car 6 : 5
car 4 : 5
car 1 : 20
Dans l'exemple de gauche, le caractère 1 est codé « 000 ». Dans l'exemple de droite, il est codé « 111 ».
Dans l'exemple de gauche, le caractère 5 est codé « 10 ». Dans l'exemple de droite, il est codé « 0 ».
L'algorithme de Huffman permet de construire l'arbre optimal, permettant d'obtenir l'encodage le plus
efficace, c'est à dire minimisant la taille du fichier compressé.
Chaque nœud est un objet contenant :
 le fils gauche,
 le fils droit,
 la somme de la fréquence de ses fils.
Objet
« nœud »
Fils gauche (nœud)
Fils droit (nœud)
Soit un ensemble E de n caractères « c » dont la fréquence d'apparition est définie par f(c).
Les feuilles de l'arbre sont les caractères. Ils peuvent être modélisés comme des nœuds qui ont une
fréquence, mais pas de fils droit ou gauche (sous-arbres vides).
Le principe est alors le suivant :
 on construit l'arbre du bas vers le haut,
 on commence avec n feuilles et on effectue n-1 fusions.
La fusion s'effectue sur les objets les moins fréquents.
Les algorithmes de Huffman seront développés en TF
Fabien Hospital
12/13
C1.2- CODAGE ET CHIFFRAGE
LYCEE BELLEVUE
Les arbres sont implémentés par des listes chaînées (files)
Comme les compressions RLE et LZW, cette méthode est inefficace lorsque le nombre de
couleurs devient trop important. Toutes ces méthodes de compression sans pertes sont
applicables pour des pixels, des chaînes de caractères et autres données informatiques.
3.4. La compression avec pertes JPEG
Pour des nombres de couleurs important (supérieur à 256), on utilise des méthodes de compression avec
pertes, et notamment le format JPEG.
Ce dernier utilise plusieurs techniques de compression sans pertes, mais aussi des méthodes permettant de
réduire la taille de l’image en utilisant des propriétés de la vision humaine.
Les étapes de la compression JPEG sont les suivantes :
 Ré-échantillonnage de la chrominance, car l'œil ne peut discerner de différences de chrominance
au sein d'un carré de 2  2 pixels,
 Découpage de l'image en blocs de 8  8 pixels, puis application de la fonction DCT
(transformation discrète en cosinus) qui décompose l'image en somme de fréquences,
 Quantification de chaque bloc, c'est-à-dire application d’un coefficient de perte (fonction du ratio
taille/qualité) qui annule ou diminue des valeurs de hautes fréquences, afin d'atténuer les détails en
parcourant le bloc intelligemment avec un codage RLE (en zig-zag pour enlever un maximum de
valeurs nulles).
 Encodage de l'image puis compression avec la méthode d'Huffman.
On utilise aussi des méthodes de compression avec pertes dans les fichiers vidéo et audio …
Fabien Hospital
13/13