1
TP N° 01
1) Introduction :
Le codage de Huffman est une technique de compression de données
largement utilisée qui permet de représenter efficacement des symboles avec
des longueurs de code variables. Il a été développé par David Huffman en 1952
et est largement utilisé dans les domaines de la compression de données, de la
transmission de données et du stockage de données.
L'idée fondamentale du codage de Huffman est d'attribuer des codes binaires courts
aux symboles fréquents et des codes binaires plus longs aux symboles moins
fréquents. Cela permet de réduire la taille totale du message compressé, car les
symboles fréquents sont représentés par des codes plus courts, tandis que les
symboles moins fréquents sont représentés par des codes plus longs.
Le processus de codage de Huffman se déroule en plusieurs étapes :
1. Calcul des fréquences d'apparition des symboles : Les fréquences d'apparition de
chaque symbole dans le message d'origine sont déterminées.
2. Construction de l'arbre de Huffman : Un arbre binaire est construit en utilisant
les fréquences des symboles. Les symboles les plus fréquents sont placés près de la
racine de l'arbre, tandis que les symboles moins fréquents sont situés plus loin.
3. Attribution des codes binaires : En parcourant l'arbre de Huffman, des codes
binaires sont attribués à chaque symbole. Les symboles fréquents ont des codes plus
courts, tandis que les symboles moins fréquents ont des codes plus longs. Cette
propriété permet de représenter efficacement les symboles dans le message
compressé.
4. Codage du message : Le message d'origine est codé en remplaçant chaque
symbole par son code binaire correspondant.
- Le codage de Huffman est un codage sans perte, ce qui signifie que le message
d'origine peut être parfaitement récupéré à partir du message codé.
Cependant, il est important de noter que le processus de codage de Huffman
nécessite la connaissance préalable des fréquences des symboles, afin que le
même arbre de Huffman puisse être utilisé pour le codage et le décodage.
- En utilisant efficacement les longueurs de code variables, le codage de Huffman
permet d'atteindre une compression significative pour les données présentant
des caractéristiques de fréquence différentes pour chaque symbole. C'est
pourquoi il est largement utilisé dans de nombreuses applications de
compression de données, notamment la compression d'images, de fichiers
texte, de fichiers audio et vidéo, ainsi que dans les protocoles de
communication.
2
C. Calcul de l’entropie par une boucle:
1/l’entropie :
entropie.m
function [H ] = entropie(p);
p=[0.2 0.4 0.2 0.1 0.1];
for i=1:length(p)
H(i)=-sum(p(i).*log2(p(i)))
end
l’affichage:
H = 0.4644 0.5288 0.4644 0.3322 0.3322
2/lmoy de code huff:
average_cod.m
clc;
clear all;
close all;
symbol=[1 2 3 4 5];
p=[0.2 0.4 0.2 0.1 0.1];
[dict,avglen]=huffmandict(symbol,p,2)
[L]=average_cod(dict,p)
l’affichage:
l = 2.2000
3/l'eff d'un code:
clc
clear all
symbols=[1 2 3 4 5];
p=[0.2 0.4 0.2 0.1 0.1];
[dict,avglen]=huffmandict(symbols,p,2)
[L]=average_cod(dict,p)
[H]=entropie(p)
eff=[H]/[L]
l’affichage:
eff = 0.9645
D/ codage huffman de sig :
1.
clc; clear all;
sig= repmat ([3 3 1 3 3 3 3 3 2 3],1,50);
symboles=[1 2 3];
p=[0.1 0.1 0.8];
[dict,Lh]=huffmandict(symboles,p);
x=dict(1,2)
y=dict(2,2)
z=dict(3,2)
hcode=huffmanenco(sig,dict);
l’affichage:
x=[1x2double] | y = [1x2 double] | z = [0]
donc:
x= 1 1 y = 1 0 z = 0
3
2. l'eff de code:
clc; clear all;
sig=repmat([3 3 1 3 3 3 3 3 2 3],1,50);
symboles=[1 2 3];
p=[0.1 0.1 0.8];
[dict,Lh]=huffmandict(symboles,p);
x=dict(1,2)
y=dict(2,2)
z=dict(3,2)
hcode=huffmanenco(sig,dict);
Lh=numel(hcode)/numel(sig)
h=-sum(p.*log2(p))
eff1=h/Lh
l’affichage:
Lh = 1.2000 ||h =0.9219 ||eff1 =0.7683
3. la comparaison:
clc;
clear all;
close all;
sig =repmat([3 3 1 3 3 3 3 3 2 3], 1, 50);
[p,freq,sym]=proba(sig)
[dict,Lh]=huffmandict(sym,p);
hcode=huffmanenco(sig,dict);
dhcode=huffmandeco(hcode,dict);
test1=all(all(sig==dhcode))
test2=isequal(sig,dhcode)
x=dict(1,2)
y=dict(2,2)
z=dict(3,2)
fprintf('la taille de signal original est %d bits\n',numel(dec2bin(sig,8)))
fprintf('la taille de signal comprese est %d bits\n',numel(hcode))
Lh1=numel(hcode)/numel(sig)
h1=-sum(p.*log2(p))
eff1=h1/Lh1
Tc1=numel(dec2bin(sig,8))/numel(hcode)
fprintf('Lh1=%f bits/symb, h1=%f bits/symb, eff1=%f, Tc1=%f,codage de huffman
pour 1000 symboles\n',Lh1,h1,eff1,Tc1)
l’affichage:
Lh1=1.200000 bits/symb, h1=0.921928 bits/symb, eff1=0.768273,
Tc1=6.666667,codage de huffman pour 1000 symboles
4. refaire la qst(D):
clc;
clear all;
close all;
sig =repmat([3 3 1 3 3 3 3 3 2 3], 1, 50);
alpha=unique(sig)
[p,freq,alpha]=proba(sig)
4
l’affichage:
p = 0.1000 0.1000 0.8000
freq = 50 50 400
alpha = 1 2 3
E. l'entopie de l'image:
clc;
clear all;
close all;
I = imread('[Link]');
I = I(1:64, 1:64);
sig = I(:);
[l, c] = size(I);
[p, freq, symbols] = proba(sig);
[dict, Lh1] = huffmandict(symbols, p);
hcode = huffmanenco(sig, dict);
dhsig = huffmandeco(hcode, dict);
V = reshape(dhsig, [l, c]);
test = all(all(V == I));
fprintf('La taille du sig original pour le codage de Huffman est %d bits\n',
numel(dec2bin(sig, 8)))
fprintf('La taille du sig compressé pour le codage de Huffman est %d bits\n',
numel(hcode))
fprintf('La taille du sig décompressé pour le codage de Huffman est %d bits\n',
numel(dhsig))
disp('Le test (V == I) est :');
disp(test);
l’affichage:
La taille du sig original pour le codage de Huffman est 32768 bits
La taille du sig compressé pour le codage de Huffman est 19663 bits
La taille du sig décompressé pour le codage de Huffman est 4096 bits
Le test (V == I) est : 1
N.B:
On observe une différence au nombre de les bits entre la sig original et la sig decompressé le
nombre diminue
F. la fonction unique_decod1 :
5
function uniqueness = unique_decod1(x)
x1 = [0];
x2 = [0 1];
x3 = [1 0];
x4 = [1 1 1];
x = [x1 x2 x3 x4];
y1 = numel(x1);
y2 = numel(x2);
y3 = numel(x3);
y4 = numel(x4);
m = 1/2^y1 + 1/2^y2 + 1/2^y3 + 1/2^y4;
if (y1 == y2) || (y2 == y3) || (y3 == y1) || (y4 == y1)
uniqueness = 'pas unique';
else
if (x1(x) == x2(x)) && (x2(x) == x3(x)) && (x3(x) == x1(x)) &&
(x2(x) == x4(x)) && (x4(x) == x1(x))
uniqueness = 'pas unique et a prefixe';
else
uniqueness = 'unique';
if m <= 1
uniqueness = 'unique';
end
end
end
end
l’affichage: ‘EXEMPLE’ :
x = 1;
uniqueness = unique_decod1(x);
disp(uniqueness);
est:
unique
1) Conclusion:
6
En conclusion, le codage de Huffman est une technique de compression de
données efficace qui permet de réduire la taille des messages en attribuant
des codes binaires courts aux symboles fréquents et des codes binaires plus
longs aux symboles moins fréquents. Cette méthode permet de compresser les
données sans perte, ce qui signifie que le message d'origine peut être
parfaitement récupéré à partir du message codé.
- Le codage de Huffman est largement utilisé dans divers domaines, tels que la
compression de fichiers, la transmission de données et le stockage de données.
Il offre des avantages significatifs en termes de réduction de la taille des
données et de transmission plus rapide. Il est particulièrement efficace pour
les données avec des caractéristiques de fréquence différentes pour chaque
symbole.
- L'efficacité du codage de Huffman repose sur une analyse précise des
fréquences des symboles dans le message d'origine. En utilisant cette
information, un arbre de Huffman est construit pour attribuer les codes
binaires aux symboles. Les symboles fréquents sont représentés par des codes
courts, tandis que les symboles moins fréquents sont représentés par des
codes plus longs.
- Cependant, il est important de noter que le codage de Huffman est plus efficace
pour les messages contenant des symboles présentant des fréquences
différentes. Pour les messages avec des symboles de fréquences similaires, la
compression peut être moins significative.
- Dans l'ensemble, le codage de Huffman est une méthode de compression de
données populaire et largement utilisée en raison de son efficacité et de sa
simplicité. Il constitue une composante essentielle de nombreux algorithmes
de compression et joue un rôle clé dans la gestion efficace des données dans
divers domaines d'application.
TP N° 02
7
1)Introduction :
- Le codage arithmétique est une technique de compression de données utilisée
pour représenter des informations de manière plus compacte. Contrairement
au codage de Huffman qui associe des codes à des symboles individuels, le
codage arithmétique attribue des intervalles de valeurs à des symboles ou des
groupes de symboles.
- L'idée principale du codage arithmétique est de représenter une séquence de
symboles par un seul nombre réel dans un intervalle prédéfini. Chaque
symbole est associé à un intervalle proportionnel à sa probabilité d'apparition.
Les symboles fréquents auront des intervalles plus grands, tandis que les
symboles moins fréquents auront des intervalles plus petits.
Le processus de codage arithmétique se déroule généralement en trois étapes :
Initialisation de l'intervalle : Un intervalle initial est défini pour représenter
l'ensemble des symboles possibles. Cet intervalle couvre l'intervalle [0, 1).
Mise à jour de l'intervalle : Pour chaque symbole dans la séquence à coder,
l'intervalle est mis à jour en réduisant sa taille en fonction de la probabilité du
symbole. La plage de l'intervalle est ajustée en fonction de la probabilité
cumulative du symbole.
Quantification de l'intervalle : Lorsque tous les symboles ont été codés, la
valeur finale de l'intervalle est quantifiée en une séquence de bits pour
représenter les données compressées.
- L'avantage du codage arithmétique est sa capacité à atteindre une compression
plus élevée que d'autres méthodes, telles que le codage de Huffman.
Cependant, la décompression et le décodage nécessitent une représentation
précise de l'intervalle, ce qui peut poser des défis en termes de précision
numérique.
- Il convient également de noter que le codage arithmétique est sensible à
l'ordre des symboles, ce qui signifie que l'encodage et le décodage doivent être
effectués avec la même table de probabilités pour obtenir des résultats
cohérents.
- Enfin, le codage arithmétique est une méthode de compression de données qui
permet de représenter une séquence de symboles par un seul nombre réel
dans un intervalle donné. Il offre une compression efficace en utilisant des
probabilités de symboles pour attribuer des intervalles adaptés à chaque
symbole.
1/ Codage arithmetique :
A/
8
proba:
function [p,freq,Alph]=proba(x)
Alph=unique(x);
freq=zeros(size(Alph));
for sym=1:length(Alph)
freq(sym)=sum(x==Alph(sym));
p=freq/sum(freq);
end
A.1 /programme implementer la methode du codage arithmetique :
clear all;
close all;
clc;
Alph=[1 2 3];
seq=[2 3 1 3 3];
freq=[29 48 100];
hcode=arithenco(seq,freq)
dhcode=arithdeco(hcode,freq,length(seq))
l’affichage:
hcode :
0100110001000000
dhcode:
23133
B)
clc; clear all; close all;
sig=repmat([3 3 1 3 3 3 3 3 2 3],1,50);
[p,freq,Alph]=proba(sig);
code1=arithenco(sig,freq);
dhcode1=arithdeco(code1,freq,length(sig));
Test1=all(sig==dhcode1)
H1=-sum(p.*log2(p)); Lh1=numel(code1)/length(sig); eff1=H1/Lh1;
Tc1=numel(dec2bin(sig,8))/numel(code1);
fprintf('la taille de la séquence avant le codage est: %d bits\
n',numel(dec2bin(sig,8)))
fprintf('la taille de la séquence aprés le codage est: %d bits\n',numel(code1))
fprintf('Lh1= %f bits/symbol, H1= %f bits/symbol,eff1= %f,Tc1= %f,Codage
Arithmetique pour 500 symboles\n',Lh1,H1,eff1,Tc1)
l’affichage:
Test1 = 1
la taille de la séquence avant le codage est: 4000 bits
la taille de la séquence aprés le codage est: 471 bits
Lh1= 0.942000 bits/symbol, H1= 0.921928 bits/symbol,eff1= 0.978692,Tc1= 8.492569,Codage
Arithmetique pour 500 symboles
La comparison:
9
En performance le codage arithmétique est mieux que codage de Hoffman pour les
séquences longues
PROGRAMME (La comparison):
clear all;
close all; clc;
[p,freq,Alph]=proba(sig);
[dict,Lh]=huffmandict(Alph,p);
sig=repmat([3 3 1 3 3 3 3 3 2 3],1,50);
hcode=huffmanenco(sig,dict);
dhcode=huffmandeco(hcode,dict);
Test=all(sig==dhcode)
H=-sum(p.*log2(p));
LH=numel(hcode)/length(sig);Eff=H/LH;
Tc=numel(dec2bin(sig,8))/numel(hcode);
fprintf('la taille de la séquence avant le codage est: %d bits\
n',numel(dec2bin(sig,8)))
fprintf('la taille de la séquence aprés le codage est: %d bits\n',numel(hcode))
fprintf('LH=%f bits/symbol,H=%f bits/symbol,Eff=%f,Tc= %f,Codage huffman pour
500 symboles\n',LH,H,Eff,Tc)
code1=arithenco(sig,freq);
dhcode1=arithdeco(dhcode,freq,length(sig));
Test1=all(sig==dhcode1)
H1=-sum(p.*log2(p));
LH1=numel(code1)/length(sig);
Eff1=H1/LH1;
Tc1=numel(dec2bin(sig,8))/numel(code1);
fprintf('la taille de la séquence avant le codage est: %d bits\
n',numel(dec2bin(sig,8)))
fprintf('la taille de la séquence aprés le codage est: %d bits\n',numel(code1))
fprintf('LH1= %f bits/symbol, H1= %f bits/symbol,Eff1=%f,Tc1= %f,Codage
Arithmétique pour 500 symboles \n',LH1,H1,Eff1,Tc1)
l’affichage:
Test = 1
la taille de la séquence avant le codage est: 4000 bits
la taille de la séquence aprés le codage est: 600 bits
LH=1.200000 bits/symbol,H=0.921928 bits/symbol,Eff=0.768273,Tc=
6.666667,Codage huffman pour 500 symboles
Test = 1
La taille de la séquence avant le codage est : 4000 bits
La taille de la séquence après le codage est : 471 bits
LH1= 0.942000 bits/symbol, H1= 0.921928 bits/symbol, Eff1= 0.978692,
Tc1= 8.492569, Codage Arithmétique pour 500 symboles
4) Question(B)la sequence a codé :
10
clc
clear all
close all
sig=repmat([3 3 1 3 3 3 3 3 2 3],1,50);
[p,freq,Alph]=proba(sig)
l’affichage:
p = 0.1000 0.1000 0.8000
freq = 50 50 400
Alph = 1 2 3
C) codage pour 10000 symboles:
clear all; close all;
sig = repmat([3 3 1 3 3 3 3 3 2 3], 1, 50);
sig2 = repmat([3 3 1 3 3 3 3 3 2 3], 1, 1000);
[p, freq, Alph] = proba(sig);
[dict, Lh] = huffmandict(Alph, p);
hcode = huffmanenco(sig, dict);
dhcode = huffmandeco(hcode, dict);
test = all(sig == dhcode);
H1 = -sum(p.*log2(p));
Lh1 = numel(hcode) / length(sig); Eff1 = H1 / Lh1;
Tc1 = numel(dec2bin(sig, 8)) / numel(hcode);
[p2, freq2, Alph2] = proba(sig2);
[dict2, Lh2] = huffmandict(Alph2, p2);
hcode2 = huffmanenco(sig2, dict2);
dhcode2 = huffmandeco(hcode2, dict2);
test2 = all(sig2 == dhcode2);
H2 = -sum(p2.*log2(p2));
Lh2 = numel(hcode2) / length(sig2);
Eff2 = H2 / Lh2;
Tc2 = numel(dec2bin(sig2, 8)) / numel(hcode2);
code3 = arithenco(sig, freq);
dhcode3 = arithdeco(code3, freq, length(sig));
test3 = all(sig == dhcode3);
H3 = -sum(p.*log2(p));
Lh3 = numel(code3) / length(sig);
Eff3 = H3 / Lh3;
Tc3 = numel(dec2bin(sig, 8)) / numel(code3);
Code4 = arithenco(sig2, freq2);
dhcode4 = arithdeco(code4, freq2, length(sig2));
test4 = all(sig2 == decode4);
H4 = -sum(p2.*log2(p2));
Lh4 = numel(code_A2) / length(sig2);
Eff4 = H4 / Lh4;
Tc4 = numel(dec2bin(sig2, 8)) / numel(code_A2);
fprintf('La taille de la séquence avant le codage est : %d bits pour 500
symboles.\n', numel(dec2bin(sig, 8)));
fprintf('La taille de la séquence après le codage est : %d bits.\n',
numel(hcode));
fprintf('Lh1 = %f bits/symbole, H1 = %f bits/symbole, Eff1 = %f, Tc1 = %f,
Codage Huffman pour 500 symboles.\n', Lh1, H1, Eff1, Tc1);
11
fprintf('La taille de la séquence avant le codage est : %d bits pour 1000
symboles.\n', numel(dec2bin(sig2, 8)));
fprintf('La taille de la séquence après le codage est : %d bits.\n',
numel(hcode2));
fprintf('Lh2 = %f bits/symbole, H2 = %f bits/symbole, Eff2 = %f, Tc2 = %f,
Codage Huffman pour 1000 symboles.\n', Lh2, H2, Eff2, Tc2);
fprintf('La taille de la séquence avant le codage est : %d bits pour 500
symboles.\n', numel(dec2bin(sig, 8)));
fprintf('La taille de la séquence après le codage est : %d bits.\n',
numel(code_A));
fprintf('Lh3 = %f bits/symbole, H3 = %f bits/symbole, Eff3 = %f, Tc3 = %f,
Codage Arithmétique pour 500 symboles.\n', Lh3, H3, Eff3, Tc3);
fprintf('La taille de la séquence avant le codage est : %d bits pour 1000
symboles.\n', numel(dec2bin(sig2, 8)));
fprintf('La taille de la séquence après le codage est : %d bits.\n',
numel(code_A2));
fprintf('Lh4 = %f bits/symbole, H4 = %f bits/symbole, Eff4 = %f, Tc4 = %f,
Codage Arithmétique pour 1000 symboles.\n', Lh4, H4, Eff4, Tc4);
l’affichage:
La taille de la séquence avant le codage est : 4000 bits pour 500
symboles.
La taille de la séquence après le codage est : 600 bits.
Lh1 = 1.200000 bits/symbole, H1 = 0.921928 bits/symbole, Eff1 =
0.768273, Tc1 = 6.666667, Codage Huffman pour 500 symboles.
La taille de la séquence avant le codage est : 80000 bits pour
1000 symboles.
La taille de la séquence après le codage est : 12000 bits.
Lh2 = 1.200000 bits/symbole, H2 = 0.921928 bits/symbole, Eff2 =
0.768273, Tc2 = 6.666667, Codage Huffman pour 1000 symboles.
La taille de la séquence avant le codage est : 4000 bits pour 500
symboles.
La taille de la séquence après le codage est : 471 bits.
Lh3 = 0.942000 bits/symbole, H3 = 0.921928 bits/symbole, Eff3 =
0.978692, Tc3 = 8.492569, Codage Arithmétique pour 500 symboles.
La taille de la séquence avant le codage est : 80000 bits pour
1000 symboles.
La taille de la séquence après le codage est : 9234 bits.
Lh4 = 0.923400 bits/symbole, H4 = 0.921928 bits/symbole, Eff4 =
0.998406, Tc4 = 8.663634, Codage Arithmétique pour 1000 symboles.
commentaire:
Ce programme met en œuvre les techniques de codage Huffman et codage
arithmétique pour la compression de séquences de symboles. Il calcule et affiche des
mesures de performance telles que l'efficacité du codage, la taille de la séquence
après le codage et le taux de compression
Le programme génère des séquences de symboles, construit les dictionnaires de
codage Huffman correspondants et effectue le codage et le décodage des séquences. Il
vérifie ensuite la validité des opérations en comparant les séquences originales avec
les séquences décodées.
En conclusion, ce programme fournit une implémentation des techniques de codage
pour la compression de séquences de symboles, et les mesures de performance
calculées permettent d'évaluer l'efficacité des algorithmes de codage utilisés.
E) codage arithmetique pour l’image <<cameraman>> :
12
clc; clear all;
i = imread('[Link]');
sig = i(:);
[l, c] = size(i);
[p, freq, Alph] = proba(sig);
x = reshape(i, [c, l]);
test = all(all(i == x));
tcodage = tic;
hcode = arithenco(sig, freq);
tdecoda = toc(tcodage);
dhcode = arithdeco(hcode, freq, length(sig));
Lh1 = length(hcode) / length(sig);
h1 = -sum(p .* log2(p));
eff = h1 / Lh1;
Y = reshape(i, [c, l]);
Test = all(all(Y == i));
% Calcul du taux de compression
taille_sig_original = numel(dec2bin(sig, 8));
taille_sig_compresse = numel(hcode);
taux_compression = taille_sig_compresse / taille_sig_original;
% Calcul du débit
debit = taille_sig_compresse / (l * c);
fprintf('Taux de compression: %.2f\n', taux_compression);
fprintf('Debit: %.2f bits/pixel\n', debit);
fprintf('Temps de codage: %.4f secondes\n', tdecoda);
l’affichage:
Taux de compression: 0.74
Debit: 0.59 bits/pixel
Temps de codage: 0.0349 secondes
22/codage RLE :
clc; clear all;
%data=RLE(x)(de)compresses les données avec the RLE algorithme
%compresion
%decompresion
if iscell(x)%decoder
i=cumsum([1 *{2}]);
j=zeros(1,i(end)-1);
j(i(1:end-1))=1;
data=x{1}(cumsum(j));
else %coder
if size(x,1)>size(x,2),x=x';
end
i= (find(x(1:end-1)=x(2:end))length(x));
data{2}=diff([0 i]); data{1}=x(i);
end; end;
l’affichage:
x=repmat([3 3 1 3 3 3 3 3 2 3],1,50);
y=RLE(x)
y = [1x5 double] [1x5 double]
x=RLE(y)
x=3313333323
13
Conclusion :
En conclusion, le codage arithmétique est une technique de compression de données
avancée qui permet de représenter des informations de manière plus compacte en
utilisant des intervalles de valeurs proportionnels aux probabilités des symboles.
Voici les points clés à retenir :
- Le codage arithmétique représente une séquence de symboles par un seul nombre
réel dans un intervalle prédéfini.
- Les symboles fréquents sont associés à des intervalles plus grands, tandis que les
symboles moins fréquents ont des intervalles plus petits.
- Le processus de codage arithmétique se déroule en trois étapes : initialisation de
l'intervalle, mise à jour de l'intervalle pour chaque symbole et quantification finale de
l'intervalle en une séquence de bits compressée.
- Le codage arithmétique offre une compression plus élevée que d'autres méthodes,
comme le codage de Huffman.
- Cependant, le codage arithmétique nécessite une représentation précise de
l'intervalle lors de la décompression et du décodage, ce qui peut poser des défis en
termes de précision numérique.
- Il est important de noter que l'encodage et le décodage doivent être effectués avec la
même table de probabilités pour obtenir des résultats cohérents.
- Le codage arithmétique est sensible à l'ordre des symboles, ce qui signifie que la
séquence des symboles doit être conservée lors de l'encodage et du décodage.
En utilisant le codage arithmétique de manière appropriée, il est possible d'obtenir
une compression efficace tout en préservant l'intégrité des données. Cependant, il est
important de prendre en compte les contraintes de précision numérique et de
s'assurer que l'ordre des symboles est correctement maintenu pour garantir une
décompression précise.
TP N° 03
14
1/ Quantification scalaire uniforme, compression d’image avec perte,
et evaluation de la qualité des images décompressées
clc; clear all; close all;
m=imread('[Link]');
o=double(m);
figure(1)
imshow(m);
title('image quantifée à 8 bit');
[freq,val]=imhist(uint8(o),256);
figure(2)
plot(val,freq,'k','linewidth',2);
title('histogramme de l''image');
xlabel('valeur de pixel');
ylabel('frequence');
Iq = zeros(size(o));
%% QNTFCT
% B = 1;
b=2;
segma=std2(o);
SNR=zeros(b,1);
for B=1:b
z=2^B;
delta = (255-0)/z;
d=linspace(0,255,z+1);
r=zeros(z,1);
for j=1:z
r(j) =d(j)+(delta/2);
end;
for j=1:z
[x,y]=find(s>d(j) & s<=d(z+1));
for i = 1:length(x)
Iq(x(i),y(i))=round(r(j)); %f1
end; end
if B == 1 || B==2 || B==3 % || B == 4 || B==5 || B==6
figure(13);
imshow(uint8(Iq));
title(['IMAGE QUANTIFE A ' , num2str(B) ' BIT'])
SNR(B)=(20*log10(segma/std2(s-Iq)));
end
SNR
%codage huffman
rth=Iq(:);
[c,l]=size(Iq);
[p,Frequence,Alph]=proba(rth);
[dict,Lh2]=huffmandict(Alph,p)
tic
hcode =huffmanenco (rth,dict);
tcodhuff=toc
tic
dec=huffmandeco(hcode ,dict);
tdecodhuff=toc
%calcule de psnr
[M,N]=size(G)
mse=(1/(M*N))*sum(sum((double(G))-( double(reshape(dec,[c,l])))).^2)
Psnr=10*log10(255^2/mse)
l’affichage:
15
1/
De 1 bit :
De 2 bit :
De 3 bit :
16
Pour 1 bit :
SNR = 5.4236
Lh2 = 1 ||tauxcodage = 0.6220 || mse =1.3133e+005 ||3/ Psnr =-3.0530
Pour 2 bit :
SNR =
0
11.1412
Lh2 =1.5992 ||tauxcodage =1.1843 ||mse = 4.2848e+003 ||3/ Psnr =11.8115
Pour 3 bit :
SNR =
0
0
17.2904
Lh2 = 2.3715 ||tauxcodage =1.4037 ||mse =1.9112e+003 ||3/ Psnr =15.3177
22) Codage predictif et compression sans pert
a.b)
clear all;
close all;
clc;
sig=[1 2 3 2 3 4 5 4 5 6 7 8 9 8 9 10]
[p,Frequence,Alph] =proba(sig)
[dict,Lh]=huffmandict (Alph,p)
H1=entrop(sig)
L’affichage:
Lh = 3.2500 ||| H1 =3.2500
C)
clear all; close all; clc;
sig= [1 2 3 2 3 4 5 4 5 6 7 8 9 8 9 10]
[p1,Frequence1, Alph1] =proba (sig)
[dict1, Lh1] =huffmandict (Alph1, p1)
H1=entrop (sig)
R(1) =1
for i = 2:length (sig)
R(i) =sig (i) -sig (i-1) ;
end
[p2, Frequence2, Alph2] = proba (R)
[dict2,Lh2] =huffmandict (Alph2, p2)
H11=entrop(R)
Invr (1) =sig (1);
for i=2:length (R)
Invr(i)=R(i-1)+R(i)
end
[p3, Frequence3, Alph3] = proba (Invr)
[dict3, Lh3] =huffmandict (Alph3, p3)
H22=entrop (Invr)
17
l’affichage:
Lh1 = 3.2500 ||| H1 = 3.2500
Lh2 = 1 ||| H11 = 0.6962
Lh3 = 1.4375 ||| H22 = 1.2476
4)
a)
clear all;
close all;
clc;
sig2=repmat ([1 2 3 2 3 4 5 4 5 6 7 8 9 8 9 10],1, 50)
[p, Frequence, Alph] =proba (sig2)
[dict, Lh] =huffmandict (Alph, p)
H11=entrop (sig2)
L’affichage:
Lh = 3.2500 || H11 = 3.2500