Etude bibliographique sur les algorithmes de compression sans perte

Républiqe Tunisienne
Ministère de l’Enseignement Supérieur et de la Recherche Scientifiqe
Université de Tunis El Manar
Département Technologies de l'Information et de la Communication
Projet de Fin d’Année
Réalise par :
Hamdi Ibtihej & Gam Chaima
Intitulé :
Etude bibliographique des algorithme de
compression sans perte
Encadré par :
Mme.Aicha Guefrachi
Année Universitaire : 2019/2020

Table des matières
Remerciements 6
Résumé 6
INTRODUCTION GÉNÉRALE 1
1 GENERALITE SUR LA COMPRESSION DES DONNÉES 3
1 INTRODUCTION : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2 DEFENITION D’UNE INFORMATION : . . . . . . . . . . . . . . . . . . . . . . . . . 3
3 TYPES DE COMPRESSION : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
3.1 Compression sans perte : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
3.2 Compression avec perte : . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
4 NOTIONS GÉNÉRALES : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
4.1 Les critères d’un algorithme de compression : . . . . . . . . . . . . . . . . . 5
4.2 Le code préfixe : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
4.3 Arbre binaire : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
5 CONCLUSION : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2 LES ALGORITHMES DE COMPRESSION DE DONNEES SANS PERTE 7
1 INTRODUCTION . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2 ALGORITHME DE HUFFMAN : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.1 Définition : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2 PRINCIPE DE L’ALGORITHME DE HUFFMAN : . . . . . . . . . . . . . . . 7
2.3 Algorithme de décompression : . . . . . . . . . . . . . . . . . . . . . . . . . 9
1

2.4 Simulation de l’algorithme : . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.5 Les avantages et les inconvénients de HUFFMAN : . . . . . . . . . . . . . . 10
2.6 Applications réelles de l’encodage de HUFFMAN : . . . . . . . . . . . . . . 11
3 RUN-LENGTH ENCODING : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.1 DÉFINITION : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.2 PRINCIPE DE RUN-LENGTH ENCODING : . . . . . . . . . . . . . . . . . . 11
3.3 Algorithme de compression : . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.5 Simulation de l’algorithme : . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.6 Les avantages et les inconvénients de RLE : . . . . . . . . . . . . . . . . . . 14
3.7 Applications réelles de l’encodage de RLE : . . . . . . . . . . . . . . . . . . . 14
4 LEMPEL-ZIV-WELCH : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
4.1 Définition : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
4.2 Algorithme de compression : . . . . . . . . . . . . . . . . . . . . . . . . . . 15
4.4 Les avantages et les inconvénients de LZW : . . . . . . . . . . . . . . . . . . 17
5 CONCLUSION : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
CONCLUSION GÉNÉRALE 19
Bibliographie 20
Annexes 23
1 Implémentation de codage de HUFFMAN avec le langage C . . . . . . . . . . . . . . 23
2 Implémentation de codage de RLE avec le langage C . . . . . . . . . . . . . . . . . . 28
TABLE DES MATIÈRES page2

Liste des tableaux
2.1 Table de calcul d’occurrence de caractères . . . . . . . . . . . . . . . . . . . . . . . 8
2.2 Table d’occurrence de caractères trié . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.3 Table des adresses des séquences de l’exemple de LZW . . . . . . . . . . . . . . . . 16
3

Table des figures
1.1 compression sans perte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2 compression avec perte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.3 arbre binaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.1 arbre de huffman de l’exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.2 fonction d’encodage de huffman . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.3 fonction de décodage de huffman . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.4 simulation de l’algorithme de Huffman . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.5 exemple de RLE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.6 compression d’un flux binaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.7 fonction d’encodage de RLE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.8 simulation de l’algorithme de RLE . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
4

Liste des abréviations
TIC : Technologies de l’Information et de Communication
TGA : Truevision Graphics Adapter
PCX : PiCture eXchange
ILBM : InterLeaved BitMap
BMP : BitMaP
ASCII : American Standard Code for Information Interchange
GZIP : GNU zip
ZIP : Zone Industrialo-Portuaire
JPEG : Join Photographic Experts Group
PNG : Portable Network Graphics
MP3 : Moving Picture Experts Group Layer-3 Audio
1

Remerciements
Nous tenons à remercier toutes les personnes qui nous ont aidée lors
de la rédaction de ce rapport.
Un spéciale remerciement pour notre encadreur qu’elle n’a pas
lésiné sur nous avec des informations.
Merci pour nos parents pour leur soutien constant et leur
encouragement.

Résumé
La compression des données est actuellement très attirée par le domaine de l’informatique pour
trouver des solutions logicielles rapides et un bon marché permettant au matériel utilisé, qui atteint
dans certains cas ses limites en termes de vitesse et de capacité mémoire, de gagner en efficacité et
en rapidité. Plusieurs méthodes de compression ont été développées. La diversité du type de données
visé (images, audio, vidéo, texte, etc.) donne lieu à cette variété de méthodes.
Ce document traite la notion de la compression de données et ses différents algorithmes.

INTRODUCTION GÉNÉRALE
INTRODUCTION GENERALE
Avec le progrès scientifique et technologique, la nécessité d’échanger et de transmettre les infor-
mations devient plus en plus importante de façon qu’aujourd’hui, notre manière de communiquer
a radicalement changé. En plus, l’apparition de nouveau principe : les "3A" (Anything Anytime
Anywhere) [16], nous permet de communiquer numériquement et de viser à avoir une communi-
cation efficace et sécurisée. Par conséquent, la recherche dans ce domaine est consacrée à l’amélio-
ration de notre communication afin d’avoir des exigences plus fortes d’efficacité et de sécurité.[6]
Cependant, aujourd’hui la puissance des machines (pc, smartphones,...) s’accroît plus vite que
les capacités de stockage et la bande passante des réseaux, ce qui impose un grand problème de
déséquilibre entre la quantité des données à traiter ou à stocker et sa transmission.
En effet, ce problème encourageait les chercheurs dans le domaine de l’informatique de trouver une
solution qui serve à réduire le volume des données; c’est la méthode de compression de données.
Comprimer une donnée c’est supprimer simplement toute information inutile, c’est à dire, la di-
minution de la répétition.[7]
En fait, la répétition peut être issue de la non efficacité de la perception des donnés et son annu-
lation dans ce cas n’évite pas la reconstitution des données grâce à des techniques de compression
réversibles.[7]
Ces techniques garantissent l’efficacité de transmettre de l’information, quelque soit le type de cet
information (image,vidéo,texte...etc). Par ailleurs, il existe deux grands types de compression de don-
nées : méthodes de compression sans perte (lossless) et autres avec perte (lossy).
Les méthodes de compression avec perte impliquent la réduction de la taille d’un fichier, généra-
lement en supprimant les petits détails qui nécessitent une grande quantité de données à stocker en
toute fidélité, mais il est impossible de restaurer le fichier d’origine en raison de la suppression des
données essentielles. La compression avec perte est le plus souvent utilisée pour stocker des don-
nées d’image et audio, et bien qu’elle puisse atteindre des taux de compression très élevés grâce à la
suppression des données, elle n’est pas traitée dans cet article. La compression de données sans perte
est la réduction de la taille d’un fichier, de sorte qu’une fonction de décompression peut restaurer le
fichier d’origine exactement sans perte de données. Elle est utilisée de manière omniprésente dans
l’informatique, de l’économie d’espace sur votre ordinateur personnel à l’envoi de données sur le
Web, à la communication via un shell sécurisé ou à l’affichage d’une image PNG ou GIF.
Dans ce contexte, notre travail vise à étudier les principaux méthodes de compression et nous
nous intéressons à la classe des algorithmes sans perte.
Afin d’atteindre cet objectif, ce rapport est constitué de deux chapitres qui sont organisés comme
suit :
Le premier chapitre présente les principaux concepts de la compression de données.
page1

INTRODUCTION GÉNÉRALE
Le deuxième chapitre est consacré à l’étude des différents algorithmes de compression sans perte en
montrant leurs avantages et leurs inconvénients.
page2

Chapitre1.GENERALITE SUR LA COMPRESSION DES DONNEES
Chapitre 1
GENERALITE SUR LA COMPRESSION DES
DONNÉES
1 INTRODUCTION :
La compression des données est aujourd’hui essentielle pour la communication numérique. Sans
compression des données, nous n’aurions pas de téléviseurs numériques, de téléphones intelligents,
de communications par satellite, d’Internet, etc.
Alors, ce chapitre va nous permet de s’ouvrir sur le monde du compression des données et ses
concepts généraux.
2 DEFENITION D’UNE INFORMATION :
Pour bien comprendre la notion de compression de données, il faut tout d’abord connaître la
définition de l’information.
En réalité, l’information est une notion général et difficile à comprendre ou à préciser son être de
matière ou d’énergie car il peut être appliqué dans tous les domaine[10].
Cependant, au contraire des êtres, l’information ne peut pas être isolée [10]. Par conséquent, elle ne
peut pas être compris en dehors un système donné, puisque elle est un message de communication
entre une source et un destinataire[10].
On peut déduire finalement que l’information n’est qu’une partie d’un système donné[10].
3 TYPES DE COMPRESSION :
Il existe deux types de compression des données : compression sans perte et avec perte.
page3

3.1 Compression sans perte :
Les techniques de compression sans perte, comme leur nom l’indique, n’impliquent aucune perte
d’informations. Si les données ont été compressées sans perte, les données d’origine peuvent être
récupérées exactement à partir des données compressées après un cycle de compression / expansion.
Elle est généralement utilisée pour les données dites "discrètes", telles que les enregistrements de
base de données, les feuilles de calcul, les fichiers de traitement de texte et même certains types
d’informations d’image et vidéo[12].
Figure 1.1 – compression sans perte
3.2 Compression avec perte :
Les techniques de compression avec perte impliquent une certaine perte d’informations, et les
données qui ont été compressées à l’aide de techniques avec perte ne peuvent généralement pas être
récupérées ou reconstruites exactement. En contrepartie d’accepter cette distorsion dans la recons-
truction, nous pouvons généralement obtenir des taux de compression beaucoup plus élevés que ce
qui est possible avec ce type de compression[12].
Dans de nombreuses applications, ce manque de reconstruction exacte n’est pas un problème. Par
exemple, lors du stockage ou de la transmission de la parole, la valeur exacte de chaque échantillon
de parole n’est pas nécessaire[12].
Figure 1.2 – compression avec perte
page4

4 NOTIONS GÉNÉRALES :
4.1 Les critères d’un algorithme de compression :
Pour choisir le meilleur algorithme qui peut satisfaire le besoin de l’utilisateur, il faut le choisir
en fonction de :
• Taux de compression : le quotient de la taille du fichier compressé par celle du fichier
initial[5]
T=taille compressé/taille original
• Quantité de compression (dans le cas de compression avec perte, il faut savoir la
pourcentage de perte de données)[5]
• Vitesse de compression et de décompression [5]
4.2 Le code préfixe :
On dit qu’un code (ensemble des mots non vide) est préfixe si et seulement si il n’existe aucun
mot de ce code est préfixe d’un autre dans le code.[13]
Exemple :
Soit le code suivant : "11.100.0.101"=> il est un code préfixe, c’est à dire, ici il n’y a pas un mot qui
commence par 11 ou 0.
Ce code doit être représenté par un arbre binaire ou on l’appel aussi arbre de codage.
4.3 Arbre binaire :
Les feuilles de l’arbre sont étiquetés par les symboles qui construisent l’information à compresser
et ses branches sont indiquées par 0 ou 1 (bit).[4]
Exemple :
Figure 1.3 – arbre binaire
page5

5 CONCLUSION :
La compression est un domaine très vaste qui possède plusieurs concepts à connaître. Cepen-
dant, ce document est essentiellement fait pour étudier les principaux algorithmes de compression
sans perte puisque ce type de compression est très utilisable dans le domaine des Technologies de
l’Information et de la Communication (TIC).
Pour cela, le chapitre suivant va parler sur ces algorithmes.
page6

Chapitre2.LES ALGORITHMES DE COMPRESSION DE DONNEES SANS PERTE
Chapitre 2
LES ALGORITHMES DE COMPRESSION DE
DONNEES SANS PERTE
1 INTRODUCTION
Des nombreuses techniques sont utilisées pour compresser les données. La plupart des techniques
de compression ne peuvent pas fonctionner seules, mais doivent être combinées ensemble pour for-
mer un algorithme de compression. Ils entrent dans la catégorie des codeurs entropiques (algorithme
de Huffman), mais il y en a d’autres telles que l’encodage en longueur et LZW(algorithme qui utilise
les dictionnaire).[8]
Dans ce chapitre, on a la chance de découvrir ces différents algorithmes.
2 ALGORITHME DE HUFFMAN :
2.1 Définition :
L’algorithme de Huffman est un algorithme découvert par le mathématicien américain DAVID
ALBERT HUFFMAN. Il appartient à une famille d’algorithmes avec une longueur de mot de code
variable. Cela signifie que les symboles individuels (caractères dans un fichier textuel à titre d’exemple)
sont remplacés par des séquences de bits qui ont une longueur distincte. Ainsi, les symboles qui se
produisent souvent dans un fichier reçoivent une courte séquence tandis que d’autres qui sont uti-
lisés obtiennent rarement une séquence de bits plus longue[11].
2.2 PRINCIPE DE L’ALGORITHME DE HUFFMAN :
L’algorithme de Huffman se base essentiellement sur la construction d’un arbre binaire dont la
définition a été présentée dans le premier chapitre). Il faut tout d’abord calculer la probabilités de
l’apparence des symboles dans le fichier à compresser et les trier par ordre décroissant selon leur
fréquence puis on crée l’arbre de codage.
page7

La construction de l’arbre se fait comme suit :
1. Construire des sous-arbres, chacun est formé par une feuille contient l’alternance d’un sym-
bole de fichier à compresser.
2. Coupler deux à deux les sous-arbres dont l’alternance est minimale => obtention d’un arbre
qui possède comme valeur de l’alternance la somme des alternances des deux sous-arbres.
3. On s’arrête lorsqu’il ne reste qu’un seul arbre => l’arbre de HUFFMAN.
Exemple illustratif d’encodage de Huffman :
On prend cette phrase :‘’ bonjour mes dames et messieurs ”
• Calcul de fréquences des caractères :
caractères b o n j u r m e s d a t i Espace
fréquences 1 2 1 1 2 2 3 5 5 1 1 1 1 4
Table 2.1 – Table de calcul d’occurrence de caractères
• Trie de fréquences :
caractères e s Espace m u r o b n d a t i j
fréquences 5 5 4 3 2 2 2 1 1 1 1 1 1 1
Table 2.2 – Table d’occurrence de caractères trié
• Construction de l’arbre :
Figure 2.1 – arbre de huffman de l’exemple
page8

Donc on a les codes des caractères suivants :
e : 0 s : 10
espace : 110 m :1110
u :11110 r :111110
o :1111110 b :11111110
n :111111110 d :1111111110
a :11111111110 t :111111111110
i :1111111111110 j :1111111111111
=> On obtient le code binaire suivant :
0111111101111110111111111111111111111011111101111011111 011 0111001
0111111111011111111110111001 011 0011111111111 011 011100101011111111111100111101111101
=> On a 151 bits au lieu de 240 bits
2.3 Algorithme de décompression :
Pour décoder les données encodées, nous avons besoin de l’arbre de Huffman. Nous parcourons
les données codées binaires. [9]
Pour trouver le caractère correspondant aux bits actuels, nous utilisons les étapes simples sui-
vantes :
1. Nous partons de la racine et suivons jusqu’à ce qu’une feuille soit trouvée.
2. Si le bit actuel est 0, nous passons au nœud gauche de l’arbre.
3. Si le bit est 1, on se déplace vers le nœud droit de l’arbre.
4. Si pendant la traversée, nous rencontrons un nœud feuille, nous imprimons le caractère de ce
nœud feuille particulier puis continuons à nouveau l’itération des données codées à partir de
l’étape 1.
2.4 Simulation de l’algorithme :
On a essayé de créer un programme d’algorithme de Huffman à l’aide de langage "C" sur la plat-
forme "Code-Blocks" (voir annexe).
Dans un premier lieu, on a crée une structure de l’arbre de huffman puis on a fait une fonction pour
lire la fréquence des symboles dans le fichier à compresser.
On choisit comme un fichier à compresser "in.txt" et "out.txt" comme un fichier de sortie contenant
la séquence binaire de fichier d’entré.
Dans un second lieu, on écrit une fonction s’appelle encode ,qui prend comme paramètres une arbre
binaire, un caractère, un entier et une chaîne de caractères, permettant de transformer une chaîne
de caractères en une séquence binaire :
page9

Figure 2.2 – fonction d’encodage de huffman
Enfin, on développe une fonction s’appelle interpret ,qui prend comme paramètres une chaine de
caracteres ,un entier et un arbre binaire, permettant de faire le travail inverse de la fonction encode,
c’est à dire, de transformer une séquence binaire en une chaîne de caractères :
Figure 2.3 – fonction de décodage de huffman
–> Resultat de simulation :
Figure 2.4 – simulation de l’algorithme de Huffman
Le fichier "in.txt" contient la chaîne suivante : je suis un ingenieur et le fichier "out.txt" contient
la séquence binaire suivante : 00111011000111010001111110111001010111111010101000
2.5 Les avantages et les inconvénients de HUFFMAN :
Avantages :
page10

• Ce schéma de codage permet d’économiser beaucoup d’espace de stockage, car les codes bi-
naires générés sont de longueur variable.
• Il génère des codes binaires plus courts pour coder les symboles / caractères qui apparaissent
plus fréquemment dans la chaîne d’entrée.
• Les codes binaires générés sont sans préfixe.
Inconvénients :
• Les schémas de codage de données sans perte, comme le codage Huffman, permettent d’obte-
nir un taux de compression inférieur par rapport au codage avec perte. Ainsi, les techniques
d’encodage sans perte comme le codage Huffman ne conviennent que pour le codage de fi-
chiers texte et programme et il ne convient pas pour l’encodage d’images numériques.
• L’encodage Huffman est un processus relativement plus lent car il utilise deux passes : une
pour construire le modèle statistique et une autre pour l’encodage.
• Comme la longueur de tous les codes binaires est différente, il devient difficile pour le logi-
ciel de décodage de détecter si les données codés sont corrompues. Cela peut entraîner un
décodage incorrect et, par conséquent, une sortie incorrecte.
2.6 Applications réelles de l’encodage de HUFFMAN :
• L’encodage Huffman est largement utilisé dans les formats de compression comme GZIP, PK-
ZIP (winzip) et BZIP2.
• Les codecs multimédias comme JPEG, PNG et MP3 utilisent l’encodage Huffman (pour être
plus précis les codes préfixes).
• Le codage Huffman domine toujours l’industrie de la compression, car les nouveaux schémas
de codage arithmétique et de plage sont évités en raison de leurs problèmes de brevet.
3 RUN-LENGTH ENCODING :
3.1 DÉFINITION :
RLE est un très simple procédé de compression de données sans perte qui s’exécute sur des sé-
quences ayant la même valeur se produisant plusieurs fois de suite et il code la séquence pour ne
stocker qu’une seule valeur et son nombre[15].
3.2 PRINCIPE DE RUN-LENGTH ENCODING :
Le principe RLE de base est que la suite de caractères est remplacée par le nombre des mêmes
caractères et un seul caractère. Considérons l’exemple dans lequel nous avons représenté une image
page11

MxN dont la moitié supérieure totalement blanc, et la moitié inférieure est totalement noire. Cet
exemple était une tentative primitive pour coder l’image à l’aide de RLE. Le principe du RLE est
d’exploiter la répétition valeurs dans une source. L’algorithme compte le nombre de répétitions
consécutives d’un et utilise cette valeur pour représenter la course. Ce principe simple fonctionne
mieux sur certains types de source dans lesquels les valeurs de données répétées sont significatives.
Noir blanc les images de documents, les images de dessins animés, etc.
En fait, RLE peut être utilisé sur tout type de source quel que soit son contenu, mais son efficacité
change considérablement en fonction des types de données qui peuvent être utilisés ou non.
Comme autre application adaptée à RLE, nous pouvons mentionner les fichiers texte qui contiennent
plusieurs espaces pour l’indentation et la mise en forme des paragraphes, tableaux et graphiques.
3.3 Algorithme de compression :
RLE fonctionne en réduisant la taille physique d’une chaîne de caractères répétitive. Cette chaîne
extensible, appelée exécution, est généralement codée sur deux octets. Le premier octet représente le
nombre de caractères dans l’exécution et est appelé le nombre d’exécutions. En pratique, une exécu-
tion codée peut contenir de 1 à 128 ou 256 caractères; le nombre d’exécutions contient généralement
le nombre de caractères moins un (une valeur comprise entre 0 et 127 ou 255). Le deuxième octet
est la valeur du caractère dans l’exécution, qui est dans la plage de 0 à 255, et est appelée la valeur
d’exécution.
Exemple illustratif d’encodage de RLE :
Soit le texte suivant :
” wwwwwwwwwwwwwwwwwwwwbwwwwwwwwwwwwwwbbbbb
wwwwwwwwwwwwwwbbwwwwwwwwwwwwww ”
Avec un algorithme de compression de données RLE (encodage de longueur d’exécution) appliqué
à la ligne de balayage hypothétique ci-dessus, il peut être rendu comme suit :
20w1b14w5b14w2b12w
L’idée est d’exécuter un balayage linéaire sur la chaîne et pour chaque caractère distinct, nous
ajoutons le caractère et son occurrence consécutive dans la chaîne de sortie.
Notez que dans le pire des cas, la taille de sortie sera juste le double de la taille d’entrée, donc
l’algorithme ne peut pas s’exécuter sur place abcd-> a1b1c1d1
Figure 2.5 – exemple de RLE
Chaque série de zéros est remplacée par deux caractères dans le fichier compressé : un zéro pour
indiquer que la compression est en cours, suivi du nombre de zéros dans l’exécution
page12

Figure 2.6 – compression d’un flux binaire
L’algorithme de décompression de RLE est présenté comme suit :[1]
Alg : algorithme de RLE de décompression :
Boucle répéter jusqu’à ce que le nombre d’octets
de sortie soit égal à la taille de segment non
compressé
Lire l’octet source suivant dans n
Si (n> = 0 et n <= 127) alors
produire les n + 1 octets suivants littéralement
Sinon si ( n = - 128 ) alors
rien à sortir
Sinon
n <= - 1 et n> = -127 puis
afficher l’octet suivant -n + 1 fois
Fin si
Fin de boucle.
3.5 Simulation de l’algorithme :
On a développé une fonction s’appelle encode qui prend comme paramètre une chaîne de carac-
tères à compresser et retourne une chaîne de caractères contenant la séquence compressée :
Figure 2.7 – fonction d’encodage de RLE
page13

–> Resultat de simulation :
Figure 2.8 – simulation de l’algorithme de RLE
3.6 Les avantages et les inconvénients de RLE :
Avantages :
• C’est un algorithme très facile à implémenter et ne nécessite pas beaucoup de puissance CPU.
• Il peut être utilisé sur n’importe quel type de fichier.
Inconvénients :
La compression RLE n’est efficace qu’avec des fichiers contenant de nombreuses données répéti-
tives. En effet, pour éliminer cet inconvénient, l’algorithme Rle doit être précédé d’une transforma-
tion qu’elle va reclasser le fichier dans le but d’élever la chance pour avoir plus de caractères.
3.7 Applications réelles de l’encodage de RLE :
Les formats courants pour les données encodées de longueur d’exécution incluent Truevision
TGA, PackBits, PCX et ILBM. L’union internationale des télécommunications décrit également une
norme pour coder la longueur de couleur des télécopieurs, connue sous le nom de T.45. La norme,
qui est combinée avec d’autres techniques dans le codage Huffman modifié, [citation nécessaire] est
relativement efficace car la plupart des documents faxés sont généralement des espaces blancs, avec
des interruptions occasionnelles de noir.
• Le format BMP de Windows et OS/2 permet d’utiliser la compression RLE pour les images en
1, 4 et 8 bits/pixel ou bien noir et blanc, ou 16 couleurs et 256 couleurs.
• Le format PCX de principe également à RLE pour les images en 8 et 24 bits/pixel. Dans le cas
des images en 24 bits/pixel, l’image découpée en trois plans (rouge, vert et bleu) où chaque
plan est encodé comme une image en 8 bits/pixel
page14

4 LEMPEL-ZIV-WELCH :
4.1 Définition :
L’algorithme LZW (Lempel-Ziv-Welch) est un algorithme de compression sans perte. Cet algo-
rithme est le fruit d’un travail collectif des trois professeurs : Abraham Lampel, Jacob Ziv et Terry
Welch[2]. Il a pour but de minimiser la taille des mots qui se répètent fréquemment dans un mes-
sage transmis. Il est une méthode de type dictionnaire car au cours de la compression de données, il
utilises les dictionnaires.
4.2 Algorithme de compression :
L’algorithme crée une table de traduction des chaînes à partir du texte compressé. Cette table
construit des codes de longueur fixe (généralement 12 bits) aux chaînes et elle est initialisée avec
toutes les chaînes à un seul caractère (256 entrées dans le cas de caractères 8 bits). Au fur et à mesure
que le compresseur examine le texte en série, il stocke chaque chaîne unique de deux caractères
dans la table sous forme de concaténation de code/caractère, avec le mappage de code sur le premier
caractère correspondant. Lorsque chaque chaîne de deux caractères est stockée, le premier caractère
est émis. Chaque fois qu’une chaîne précédemment rencontrée est lue à partir de l’entrée, la plus
longue chaîne précédemment rencontrée est déterminée, puis le code de cette chaîne concaténée
avec le caractère d’extension est stocké dans la table.[14] Cette table est un dictionnaire de taille
variable, dont ses premières adresses contiennent les codes ASCII et les chaînes ont des adresses
supérieurs à 255.
Alg.3.1 : algorithme de LZW de compression :
Données :
• Le dictionnaire des caractères rencontrés : D
• Le fichier à compresser : F
Résultat : fichier compressé.
Début
O=premier octet de fichier
tant que (F n’atteint pas sa fin) faire :
p=octet suivant
r=concaténation de O et p
si ( r appartient à D) alors O=r
sinon
ajouter r à D puis écrire l’adresse de O puis O=p
fin si.
fin tant que.
écrire l’adresse de O
Fin
page15

Exemple illustratif d’encodage de LZW :
Soit la séquence suivante :"isis!et?sisi";
donc le premier octet est ’i’ => O=i, puis on a l’octet suivant ’s’, alors on obtient r=O+p="is", comme
la chaîne obtenue ne fait pas partie du dictionnaire, on l’ajoute dans le dictionnaire.
Cette séquence va obtenir l’adresse 256, car les 255 premières adresses sont conservées pour les
codes ASCII. Finalement, on affecte à ’i’ une adresse dans le fichier qui est sa valeur ASCII (105). On
complète avec ce processus pour le caractère suivant.
Lorsque on rencontre une paire encore une fois (comme ’is’ par exemple), qui existe déjà dans notre
dictionnaire, on émet l’adresse de la séquence ’is’ et non pas l’adresse de séquence de i et de s, on ajou-
tera la séquence qui contient 3 caractères dans le dictionnaire (comme ’isi’ dans notre exemple).[3]
En résumant :
phase 1 phase 2 phase 3 phase 4 phase 5 phase 6 phase 7
Valeur de O i s i is ! e t
Valeur de p s i s ! e t ?
Valeur de r is si is is! !e et t?
r appartient au D? non non oui non non non non
ajout dans D is si is! !e et t?
l’adresse de i est 105 s est 115 is est 256 ! est 33 e est 101 t est 116
phase 8 phase 9 phase 10 phase 11 phase 12
Valeur de O ? s si s si
Valeur de p s i s i
Valeur de r ?s si sis si
r appartient au D? non oui non oui
ajout dans D ?s sis
l’adresse de ? est 63 si est 257 si est 257
Table 2.3 – Table des adresses des séquences de l’exemple de LZW
=> A la fin, on obtient la suite d’adresse existée dans le fichier compressé :
105.115.256.33.101.116.63.257.257
Il adopte presque le même processus de l’algorithme de compression.[3]
page16

Alg.3.2 : algorithme de LZW de décompression :
Données :
• Le dictionnaire des caractères rencontrés :
D
• Le fichier à décompresser : F
Résultat : fichier décompressé.
Début
k=séquence de la première adresse existé dans le
fichier
écrire k
tant que (F n’atteint pas sa fin) faire :
L=adresse suivante
si ( L appartient à D) :
S=séquence (L)
sinon
S=k+L
fin si.
écrire la chaîne S
p=S[0]
ajouter la concaténation (Séquence(k)+p) dans D
k=L
fin tant que.
Fin
4.4 Les avantages et les inconvénients de LZW :
Avantages :
• LZW ne nécessite aucune information préalable sur le flux de données d’entrée.
• LZW peut compresser le flux d’entrée en un seul passage.
• Sa simplicité, il permet une exécution rapide.
Inconvénients :
• LZW est un peu lent. En effet, la recherche dans le dictionnaire prend beaucoup de temps.
• LZW pénètre quelques éléments qui peuvent ne pas être utilisés.
page17

5 CONCLUSION :
En conclusion, on pourrait dire que les compressions sans perte avaient un taux maximum de
compression proche de 50 pourcents. Nous avons également pu dire que ces algorithmes sont sus-
ceptibles de traiter toutes sortes de données mais que les performances y sont directement liées.
Hormis les algorithmes typographiques (Huffman), les autres algorithmes sont toujours sensible-
ment les mêmes : ils sont basés sur la suppression de la redondance. Aussi, nous avons également
constaté que la taille des fichiers à compresser affectait considérablement les performances. Ainsi,
la chose la plus importante lors de l’utilisation d’un algorithme de compression est de comprendre
le type de données et leur taille. C’est à dire qu’en fonction du type de données traitées, il est facile
de faire le bon choix et de ne pas utiliser d’algorithmes très compliqués pour des types de données
qui pourraient être compressés par des algorithmes assez simples.
page18

CONCLUSION GÉNÉRALE
CONCLUSION GENERALE
La compression des données est appelée à prendre une position encore plus grande en raison de la
mise en réseau et de la croissance multimédia. Son intérêt est due principalement à la latence entre les
possibilités matérielles des appareils que nous utilisons (vitesse Internet, sur Numeris et les différents
câbles, capacité de la mémoire... ) et les exigences articulées par les utilisateurs (visiophonie, vidéo
plein écran, transfert des quantités de connaissances sur des périodes toujours plus courtes)[3].
Les méthodes actuellement utilisées sont puissants et très perfectionnées (Huffman, LZW, JPEG)
et utilisent des théories très compliqués. Il y a des méthodes naissants qui sont favorables, mais on est
très loin d’épuiser toutes les stades d’étude. Les méthodes pour l’avenir s’adapteront probablement à
la nature des données à compresser et utiliseront l’intelligence artificielle, mais on peut se demander,
la compression est-elle utile à l’avenir, alors que les contraintes de ressources deviennent de moins
en moins importantes?[3].
page19

Bibliographie
[1] DICOM :Digital Imaging and Communications in Medicine. The rle algorithm, 2013.
http://dicom.nema.org/dicom/2013/output/chtml/part05/sect_
G.3.html.
[2] ETHW. "milestones :lempel-ziv data compression algorithm, 1977".
https://ethw.org/Milestones:Lempel-Ziv_Data_Compression_
Algorithm,_1977, september 2004.
[3] PEREIRA Vincent - LEPRETTE Franck - HACAULT Vincent. "Compression de don-
nées". PhD thesis, Décembre 2004. Exposé.
[4] Stéphane Grandcolas. "Huffman". PhD thesis, Faculté des sciences : Aix Marseille
Université, 2011-2012.
[5] BENOIT Christophe - DUSSON Alexandre. "tipe sur la compression de données infor-
matiques"
. http://mp01.free.fr/comp/comp.htm.
[6] Bruno Carpentieri. "efficient compression and encryption for digital data transmis-
sion".
https://www.hindawi.com/journals/scn/2018/9591768/, 2018.
[7] Chérif TAOUCHE. "Implémentation d’un Environnement Parallèle pour la Compres-
sion d’Images à l’aide des Fractales". PhD thesis, Université Mentouri Constantine-
Faculté des Sciences de l’Ingénieur, 2005. Exposé.
[8] ETHW. "history of lossless data compression algorithms ".
https://ethw.org/History_of_Lossless_Data_Compression_
Algorithms, janvier 2019.
[9] Harshit Sidhwa. "huffman decoding". GeeksforGeeks : A computer science portal for
geeks, 2017.
https://www.geeksforgeeks.org/huffman-decoding/.
[10] Jean Zin. "le monde de l’information". article, 2004.
[11] Karthikeya Boyini. "huffman coding algorithm", juillet 2018.
https://www.tutorialspoint.com/Huffman-Coding-Algorithm.
[12] Khalid Sayood. "Introduction to Data Compression". Elsevier Inc., 2006.
20

[13] Meriem Hnida - Assil Smaili El Alaoui. "codes préfixes et arbres", décembre 2011.
https://sites.google.com/site/portfolioassilmeriem/
parallelprocessing/travaux-de-recherche/heap-monceau/
utilisations/administration-systemes/travaux-pratiques.
[14] MohitBansal3 - KewalShah. "lzw (lempel–ziv–welch) compression technique".
https://www.geeksforgeeks.org/lzw-lempel-ziv-welch-compression-tech
[15] Techie Delight. "run length encoding (rle) data compression algorithm", 2018.
[16] Pierre Jouvelot. "Compression de données texte, son, image". PhD thesis, Centre de
recherche en informatique, Ecole des mines de Paris, 2006.
page21

1 #include <stdio.h>
2
3 #define nb_lettres 26
4
5 #define LEFT 'L'
6 #define RIGHT 'R'
7
8 #define longeur_code 128
9
10 #define TYPED_ALLOC(type) (type *) malloc( sizeof(type) )
11 #define BYTE_SIZE 8
12
13
14 typedef struct arbre_binaire
15 {
16 int frequence;
17 char c;
18 char code[longeur_code];
19 struct arbre_binaire *left;
20 struct arbre_binaire *right;
21 } arbre_binaire ;
22
23 arbre_binaire *arr[nb_lettres], *letters[nb_lettres];
24
25
26
27 int main()
28 {
29 char str[longeur_code];
30 int lignefichier;
31 int i, j, k, index, n;
32 float min, secondMin;
33 int minIndex, secondMinIndex;
34 int nb_charactere = 0;
35 arbre_binaire *tree;
36 FILE *in = fopen("in.txt", "r");
37 FILE *out;
38 if ( in == NULL )
39 {
40 printf("nFile not found");
41 return 0; 42
}
43 else
44 {
45 /*
46 * debut: initialisation du tablesu
47 */
48 for (i = 'A'; i <= 'Z'; i++)
49 {
50 index = i - 'A';
51 arr[index] = NULL; 52
}
53 /*
54 * fin de l'initialisation
55 */
56 nb_charactere = 0;
57 lignefichier = fgets(str, longeur_code, in) != NULL;
58 while(!feof(in) || lignefichier)
59 {
60 n = strlen(str);
61 printf("n%s", str);
62 for (i = 0; i < n ; i ++ )
63 {
64 str[i] = toupper(str[i]);
65 if (str[i] >= 'A' && str[i] <= 'Z')
66 {
67 nb_charactere ++;
68 index = str[i] - 'A';
69 if (arr[index] == NULL)
70 {
71 arr[index] = TYPED_ALLOC(arbre_binaire );//
malloc(sizeof(arbre_binaire));
72 arr[index]->c = str[i];
73 arr[index]->frequence = 1;
74 arr[index]->left = arr[index]->right = NULL; 75}
76 else
77 {
78 arr[index]->frequence += 1;
Annexes
1 Implémentation de codage de HUFFMAN avec le langage C
page23

79 }
80 }
81 }
82 if (lignefichier)
83 {
84 lignefichier= fgets(str, longeur_code, in) != NULL;
85 }
86 }
87 }
88 fclose(in);
89
90 for ( i = 0, n = 0 ; i < nb_lettres ; i ++ )
91 {
92 letters[i] = arr[i];
93 if (arr[i] != NULL)
94 {
95 arr[i]->frequence ; // compter la frequence des characteres
96 n ++;
97 }
98 }
99
100 j = 1;
101 do
102 {
103 findMinAndSecondMin(arr, &min, &minIndex, &secondMin, &secondMinIndex);
104
105 if (minIndex != -1 && secondMinIndex != -1 && minIndex != secondMinIndex)
106 {
107 arbre_binaire *temp;
108 tree = TYPED_ALLOC(arbre_binaire );// malloc(sizeof(arbre_binaire ));
109 tree->frequence= arr[minIndex]->frequence + arr[secondMinIndex]->frequence;
110 tree->c = j;
111 tree->left = arr[minIndex];
112 temp = TYPED_ALLOC(arbre_binaire );// malloc(sizeof(arbre_binaire ));
113 temp->c = arr[secondMinIndex]->c;
114 temp->frequence = arr[secondMinIndex]->frequence;
115 temp->left = arr[secondMinIndex]->left;
116 temp->right = arr[secondMinIndex]->right;
117 tree->right = temp;
118
119 arr[minIndex] = tree;
120
121 arr[secondMinIndex] = NULL;
122 }
123 j ++;
124 }
125 while( j < n );
126
127 for ( i = 0 ; i < nb_lettres ; i ++ )
128 {
129 if (arr[i] != NULL)
130 {
131 char code[longeur_code];
132 strcpy(code, "");
133 encode(tree = arr[i], letters, 0, 0, code);
134 puts("nSuccessful encoding");
135 printTree(arr[i]);
136 break;
137 }
138 }
139 in = fopen("in.txt", "r");
140 out = fopen("out.txt", "w");
142 while(!feof(in) || lignefichier)
143 {
144 n = strlen(str);
145 for (i = 0; i < n ; i ++ )
146 {
147 str[i] = toupper(str[i]);
148 if (str[i] >= 'A' && str[i] <= 'Z')
149 {
150 index = str[i] - 'A';
151 fputs(letters[index]->code, out);
152 }
153 }
155 {
157 }

158 }
159
160 fclose(in);
161 fclose(out);
162
163 printf("nla taille de fichier d'entré avec les characteres seulement: %d bits",
nb_charactere * BYTE_SIZE);
164
165 out = fopen("out.txt", "r");
166 lignefichier = fgets(str, longeur_code, out) != NULL;
167 nb_charactere = 0;
168 while(!feof(out) || lignefichier)
169 {
170 nb_charactere += strlen(str);
172 {
174 }
175 }
176
177
fclose(out);
178
179
printf("nla taille du fichier compressé: %d bits", nb_charactere);
180 printf("nInterprétation du fichier compressé:n");
181 out = fopen("out.txt", "r");
183 while(!feof(out) || lignefichier)
184 {
185 n = strlen(str);
186 i = 0 ;
187 while(i < n)
188 {
189 interpret(str, &i, tree);
190 }
192 {
194 }
195 }
196 fclose(out);
197
198 puts("n");
199 return 0;
200 }
201 /*
202 *
203 */
204
205
void encode(arbre_binaire *node, arbre_binaire **letters, char direction,
char* code)
{
short level,
206 int n;
207 if ( node != NULL )
208 {
209 if ((n = strlen(code)) < level)
210 {
211 if (direction == RIGHT)
212 {
213 strcat(code, "1");
214 }
215 else
216 {
217 if (direction == LEFT)
218 {
220 }
221 }
222 }
223 else
224 {
225 if (n >= level)
226 {
227 code[n - (n - level) - 1] = 0;
228 if (direction == RIGHT)
229 {
231 }
232 else
233 {
234 if (direction == LEFT)

235 {
237 }
238 }
239 }
240 }
241 if (node->c >= 'A' && node->c <= 'Z')
242 {
243 strcpy(node->code, code);
244 strcpy(letters[node->c - 'A']->code, code);
245 }
246 encode(node->left, letters, LEFT, level + 1, code);
247 encode(node->right, letters, RIGHT, level + 1, code);
248 }
249 }
250
251 void printTree(arbre_binaire *node)
252 {
253 int n;
254 if ( node != NULL )
255 {
256 if (node->c >= 'A' && node->c <= 'Z')
257 {
258 printf("t%c - frequence: %itencoding: %sn", node->c, node->frequence,
node->code);
259 }
260 printTree(node->left);
261 printTree(node->right);
262 }
263 }
264
265 /*
266 * Begin: Minimum and second minimum
267 */
268
269
void findMinAndSecondMin(arbre_binaire *arr[], float *min, int *minIndex, float *secondMi n,
int *secondMinIndex)
{
270 int i, k;
271 k = 0;
272 *minIndex = -1;
273 /*
274 * Skipping all the NULL elements.
275 */
276 while (k < nb_lettres && arr[k] == NULL) k++;
277
278 *minIndex = k;
279 *min = arr[k]->frequence;
280
281 for ( i = k ; i < nb_lettres; i ++ )
282 {
283 if ( arr[i] != NULL && arr[i]->frequence < *min )
284 {
285 *min = arr[i]->frequence;
286 *minIndex = i;
287 }
288 }
289
290 k = 0;
291 *secondMinIndex = -1;
292 /*
293 * Skipping all the NULL elements.
294 */
295 while ((k < nb_lettres && arr[k] == NULL) || (k == *minIndex && arr[k] != NULL)) k++;
296
297 *secondMin = arr[k]->frequence;
298 *secondMinIndex = k;
299
300 if (k == *minIndex) k ++;
301
302 for ( i = k ; i < nb_lettres; i ++ )
303 {
304 if ( arr[i] != NULL && arr[i]->frequence < *secondMin && i != *minIndex )
305 {
306 *secondMin = arr[i]->frequence;
307 *secondMinIndex = i;
308 }
309 }
310 /*
311 * End: Minimum and second minimum

312 */
313 }
314
315 void interpret(char *str, int *index, arbre_binaire *tree)
316 {
317 int n = strlen(str);
318 if (tree->c >= 'A' && tree->c <= 'Z')
319 {
320 printf("%c ", tree->c);
321 return ;
322 }
323 else
324 {
325 if ( *index < n )
326 {
327 if (str[*index] == '0')
328 {
329 (*index) ++;
330 interpret(str, index, tree->left);
331 }
332 else
333 {
334 if (str[*index] == '1')
335 {
336 (*index) ++;
337 interpret(str, index, tree->right);
338 }
339 }
340 }
341 }
342 }
343

1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4 #define MAX_RLEN 50
5
6
7 char* encode(char* str) /*Renvoie la chaîne Run Length Encodé pour le chaîne source str*/
8 {
9 int rLen;
10 char count[MAX_RLEN];
11 int len = strlen(str);
12
13 /* Si tous les caractères de la chaîne source sont différents,
14 alors la taille de la chaîne de destination serait le double de la chaîne d'entrée.
15 Par exemple, si le str est "abcd", alors dest serait "a1b1c1d1"
16 Pour les autres entrées, la taille serait inférieure à deux fois. */
17 char* dest = (char*)malloc(sizeof(char) * (len * 2 + 1));
18
19 int i, j = 0, k;
20
21 /* traverser la chaîne d'entrée une par une */
22 for (i = 0; i < len; i++)
23 {
24
25 /* Copiez la première occurrence du nouveau caractère */
26 dest[j++] = str[i];
27
28 /* Comptez le nombre d'occurrences du nouveau personnage */
29 rLen = 1;
30 while (i + 1 < len && str[i] == str[i + 1])
31 {
32 rLen++;
33 i++;
34 }
35
36 /* Stocker rLen dans un nombre de tableaux de caractères [] */
37 sprintf(count, "%d", rLen);
38
39 /* Copiez count[] vers la destination */
40 for (k = 0; *(count + k); k++, j++)
41 {
42 dest[j] = count[k];
43 }
44 }
45
46 /*terminer la chaîne de destination */
47 dest[j] = '0';
48 return dest;
49 }
50
51
52 int main()
53 {
54 char str[] = "gam chaima";
55 char* res = encode(str);
56 printf("la chaine a compresser est: ");
57 printf("%s",str);
58 printf("nla chaine compressé est: ");
59 printf("%s", res);
60 getchar();
61 return 0;
62 }
63
Annexes
2 Implémentation de codage de RLE avec le langage C
page28

Etude bibliographique sur les algorithmes de compression sans perte

Contenu connexe

Tendances

Similaire à Etude bibliographique sur les algorithmes de compression sans perte

Etude bibliographique sur les algorithmes de compression sans perte