traitement d'image : matlab

[invite98d5d2cd]

bonjour, je travail sur un programme de compression d'image et je me suis bloqué sur la parti codage de huffman, s'il y a quelqu'un peut me donner le code du codage de huffman
-----

[inviteb9f49292]

Google est-il si compliqué que celà ?

[invite98d5d2cd]

j'ai pas trouvé le code de cette fonction dans google si tu le trouve donne le moi

[inviteb9f49292]

Bon il faut apprendre à lire aussi alors car le 1er lien ressemble fortement à ce que tu cherches.
Sinon, il y a une autre technique: trouver une page décrivant les algo mis en oeuvre, et le traduire en MATLAB... Et si tu bloques, tu postes ton code sur ce forum et on t'aidera. Tout est dans le dernier mot: entraide, et non pas te faire le boulot. Une dernière possibilité est la sous-traitance, tu écris un cahier des charges, et tu payes quelqu'un pour le faire. Perso je doit être à une 100aine euros/heure...

[A voir en vidéo sur Futura]

[invite98d5d2cd]

Oui le 1er lien ressemble fortement à ce que je cherche ...mais j'ai déjà lit plusieurs cours concernant le codage de Huffman et j'ai compris son principe
facilement ...donc le problème c'est dans la partie programmation s'il y a quelqu'un qui peut m'expliquer comment le programmé c tt ...merci

[inviteb9f49292]

Poste ce que tu as fait en pointant les problèmes, et nous pourrons t'aider

[invite98d5d2cd]

ok , donc je travail sue la compression d l'image j'ai fais tous les étapes : la DCT , la quantification , le scan zigzag , le codage RLE et après le codage Huffman et ça le problème , dans l'étape du codage de Huffman j'ai utilisé la fonction qui dèja intégré dans Matlab mais moi je veux le code de cette fonction, j'ai bien compris le principe de codage de Huffman mais j'ai pas une idée comment le programmé car je suis pas fort en programmation c normal c pas mon domaine ....voila une parti de code matlab que j'ai crée

%jpeg : fichier principal
clear
%chargement de l'image sur matlab qui sera sous format entier uint8
% et la convertir en doublepour les calcul
img=double(imread('Arc.bmp'));

dim_bloc = 8; % dimension 8X8 des sous blocs
% Déclaration et initialisation des variables nécéssaires 
%(voir init_jpegT.m)
init_jpegT;   
% compression et codage du matrice de la luminance jpegY 
% (voir codage_jpegY.m)
codage_jpegY  
% compression et codage du matrice de la luminance jpegU 
% (voir codage_jpegU.m)
codage_jpegU
% compression et codage du matrice de la luminance jpegV 
% (voir codage_jpegV.m)
codage_jpegV 
% Décodage et décompression des 3 matrice de l'image jpegY,jpegU et jpegV
% (voir decodage_jpegT.m)
decodage_jpegT
% Assemblé les 3 matrices pour reconstruire l'image compréssée
img_compressee=cat(3,jpegY,jpegU,jpegV);
% Affichage de l'image original, de sa DCT, et l'image décompressé
figure(1);
subplot(1,3,1);
imshow(uint8(img));
title('image originale');
subplot(1,3,2);
imshow(uint8(img_compressee));
title('img_compresse');
subplot(1,3,3);
imshow(uint8(img_decompressee));
title('image décompressée');

%init_jpeg
%séparer les trois matrices couleur d'image  R,G et B 
R=img(:,:,1);
G=img(:,:,2);
B=img(:,:,3);
%transformation couleur ; de RGB vers YUV(YCbCr)
trans_couleur;
%La matrice 'offset' pour fair un décalage de niveaux 
offset = ones(dim_bloc,dim_bloc)*128;
%récupération des dimensions de l'image 
[m,n]=size(Y);
dim_jpegY=n*m;
dim_jpegU=m*n;
dim_jpegV=m*n;

jpegY=ones(size(Y));%matrice jpegY qui va contenir image compressée de la luminance
jpegU=ones(size(U));%matrice jpegY qui va contenir image compressée de la chrominance1
jpegV=ones(size(V));%matrice jpegY qui va contenir image compressée de la chrominance2
%Vecteurs d scan zigzag pour les 3 matrices jpegY,jpegU et jpegV
zigzagY=ones([1 dim_jpegY]);  zigzagU=ones([1 dim_jpegU]);  zigzagV=ones([1 dim_jpegV]);
%Fonction de récupération des indices du scan zigzag
[col lig]=init_indices_zigzag(dim_bloc);
%vecteur de codage RLE
rleY = [];   rleU = [];    rleV = [];   
%vecteur de décodage RLE    
rle_decoY = [];   rle_decoU = [];    rle_decoV = []; 
%vecteur de décodage de Huffman
huff_decoY = [];     huff_decoU = [];    huff_decoV = [];
%constantes utiles 
dec_l=0;   dec_c=0;
redondanceY = 0;   redondanceU = 0;   redondanceV = 0; 
col_rle_pY = 1;   col_rle_pU = 1;   col_rle_pV = 1;    
k=1;
y=1;   
u=1;    
v=1;
d=0;

%codage jpeg
%boucle général qui va parcourir l'image en sous bloc 8X8
for i=1:dim_bloc:m
    dec_l=i-1;%décalag vertical des sous bloc
    for j=1:dim_bloc:n
        dec_c=j-1;%décalage horizontal des sous bloc
        jpegY(i:i+7,j:j+7)=Y(i:i+7,j:j+7)-offset;%décalage de niveau de chaque sous bloc
        jpegU(i:i+7,j:j+7)=U(i:i+7,j:j+7)-offset;
        jpegV(i:i+7,j:j+7)=V(i:i+7,j:j+7)-offset;
        jpegY(i:i+7,j:j+7)=dct*jpegY(i:i+7,j:j+7)*dct';%Appliquer DCT
        jpegU(i:i+7,j:j+7)=dct*jpegU(i:i+7,j:j+7)*dct';
        jpegV(i:i+7,j:j+7)=dct*jpegV(i:i+7,j:j+7)*dct';
        jpegY(i:i+7,j:j+7)=jpegY(i:i+7,j:j+7) ./ quantificationY;% la quantification
        jpegU(i:i+7,j:j+7)=jpegU(i:i+7,j:j+7) ./ quantificationUV;
        jpegY(i:i+7,j:j+7)=jpegV(i:i+7,j:j+7) ./ quantificationUV;
        jpegY(i:i+7,j:j+7)=round(jpegY(i:i+7,j:j+7));%arrondir à l'entier le plus prés
        jpegU(i:i+7,j:j+7)=round(jpegU(i:i+7,j:j+7));
        jpegV(i:i+7,j:j+7)=round(jpegV(i:i+7,j:j+7));
        
        for q=1:64
            zigzagY(k)=jpegY(lig(q)+dec_l,col(q)+dec_c);%effectuer un scan zigzag
            zigzagU(k)=jpegU(lig(q)+dec_l,col(q)+dec_c);
            zigzagV(k)=jpegV(lig(q)+dec_l,col(q)+dec_c);
            k=k+1;
        end
        
        d=k-64;
        q=1;
        %Boucle while qui effectue un codage RLE sur chaque sous bloc de la
        %matrice de luminance jpegY
        while(q<64)
            if(q<dim_jpegY)&&(zigzagY(d)~=zigzagY(d+1));
                rleY(y)=zigzagY(d);
                d=d+1;
             
            elseif(q<dim_jpegY)&&(zigzagY(d)==zigzagY(d+1))&&(zigzagY(d+1)~=zigzagY(d+2));
                rleY(y)=zigzagY(d);
                rleY(y+1)=zigzagY(d+1);
                d=d+2;
        
            elseif(q<dim_jpegY)&&(zigzagY(d)==zigzagY(d+1))&&(zigzagY(d+1)==zigzagY(d+2))&&(zigzagY(d+2)~=zigzagY(d+3));
                rleY(y)=zigzagY(d);
                rleY(y+1)=zigzagY(d+1);
                
                d=d+3;
                q=q+3;
                y=y+3;
            elseif(q<dim_jpegY)&&(zigzagY(d)==zigzagY(d+1))&&(zigzagY(d+1)==zigzagY(d+2))&&(zigzagY(d+2)==zigzagY(d+3));
                redondanceY=4;
                rleY(y)=257;
                rleY(y+1)=redondanceY;
                rleY(y+2)=zigzagY(y);
                d=d+3;
                q=q+4;
                while(q<=64)&&(d<dim_jpegY)&&(zigzagY(d)==zigzagY(d+1))
                    redondanceY=redondanceY+1;
                    q=q+1;
                    d=d+1;
                end
                
                d=d+1;
                
            end
            if(q==64)
                q=q+1;
            end
        end
        %Boucle qui effectue le codage RLE sur chaque sous bloc de la
        %matrice chrominance1 jpegU
        d=k-64;
        q=1;
        while(q<64)
            if(q<dim_jpegU)&&(zigzagU(d)~=zigzagU(d+1));
                rleU(zu)=zigzagU(d);
               
                q=q+1;
                u=u+1;
            elseif(q<dim_jpegU)&&(zigzagU(d)==zigzagU(d+1))&&(zigzagU(d+1)~=zigzagU(d+2));
                rleU(u)=zigzagU(d);
                rleU(u+1)=zigzagU(d+1);
                d=d+2;
                
            elseif(q<dim_jpegU)&&(zigzagU(d)==zigzagU(d+1))&&(zigzagU(d+1)==zigzagU(d+2))&&(zigzagU(d+2)~=zigzagU(d+3));
                rleU(u)=zigzagU(d);
               
               
                u=u+3;
            elseif(q<dim_jpegU)&&(zigzagU(d)==zigzagU(d+1))&&(zigzagU(d+1)==zigzagU(d+2))&&(zigzagU(d+2)==zigzagU(d+3));
                redondanceU=4;
                rleU(u)=257;
                rleU(u+1)=redondanceU;
               
                q=q+4;
                while(q<=64)&&(d<dim_jpegU)&&(zigzagU(d)==zigzagU(d+1))
                    redondanceU=redondanceU+1;
                    q=q+1;
                    d=d+1;
                end
                rleU(u+1)=redondanceU;
                d=d+1;
                u=u+3;
            end
            if(q==64)
                q=q+1;
            end
        end
        %Boucle qui effectue le codage RLE sur chaque sous bloc de la
        %matrice chrominance2 jpegV
        d=k-64;
        q=1;
        while(q<64)
            if(q<dim_jpegV)&&(zigzagV(d)~=zigzagV(d+1));
                rleV(v)=zigzagV(d);
                d=d+1;
           
            elseif(q<dim_jpegV)&&(zigzagV(d)==zigzagV(d+1))&&(zigzagV(d+1)~=zigzagV(d+2));
                rleV(v)=zigzagV(d);
                rleV(v+1)=zigzagV(d+1);
                d=d+2;
                q=q+2;
                v=v+2;
            elseif(q<dim_jpegV)&&(zigzagV(d)==zigzagV(d+1))&&(zigzagV(d+1)==zigzagV(d+2))&&(zigzagV(d+2)~=zigzagV(d+3));
                rleV(v)=zigzagV(d);
                rleV(v+1)=zigzagV(d+1);
                rleV(v+2)=zigzagV(d+2);
                d=d+3;
                q=q+3;
                v=v+3;
            elseif(q<dim_jpegV)&&(zigzagV(d)==zigzagV(d+1))&&(zigzagV(d+1)==zigzagV(d+2))&&(zigzagV(d+2)==zigzagV(d+3));
                redondanceV=4;
                rleV(v)=257;
                rleV(v+1)=redondanceV;
                rleV(v+2)=zigzagV(d);
                d=d+3;
                q=q+4;
                while(q<=64)&&(d<dim_jpegV)&&(zigzagV(d)==zigzagV(d+1))
                    redondanceV=redondanceV+1;
                    q=q+1;
                    d=d+1;
                end
                rleV(v+1)=redondanceV;
                d=d+1;
                v=v+3;
            end
            if(q==64)
                q=q+1;
            end
        end
        
        %Début du codage entropique de Huffman pour la matrice de luminance jpegY.
        col_rleY = y-1;
        %Extraction des symboles uniques présent dans le vecteur RLE de jpegY.
        symbolesY = unique(rleY(col_rle_pY:col_rleY));
        nbr_symbolesY = numel(symbolesY);
        taille_blockY = numel(rleY(col_rle_pY:col_rleY));
        %calcul des probabilités de chaque symboles.
        table_pY = ones(1,nbr_symbolesY);
        for q=1:nbr_symbolesY
            itter = 0;
            for r=col_rle_pY:col_rleY
                if(rleY(r)==symbolesY(q))
                    itter=itter+1;
                end
            end
            table_pY(q)=repetition/taille_blockY;
        end
        %Dressage de l'arbre de huffman et codage de chaque symbole de
        %chaque sous bloc de la matrice lunimance jpegY.
        eval(sprintf('dicoY_%d_%d = huffmandict(symbolesY,table_pY);',i,i));
        eval(sprintf('hcodeY_%_% = huffmanenco(rleY(col_rle_pY:col_rleY),dicoY_%_%);',i,j,i,j));
        col_rle_pY = col_rleY+1;
        
        %Début du codage entropique de Huffman pour la matrice de chrominance jpegU.
        col_rleU = u-1;
        %Extraction des symboles uniques présent dans le vecteur RLE de jpegU.
        symbolesU = unique(rleU(col_rle_pU:col_rleU));
        nbr_symbolesU = numel(symbolesU);
        taille_blockU = numel(rleU(col_rle_pU:col_rleU));
        %calcul des probabilités de chaque symboles.
        table_pU = ones(1,nbr_symbolesU);
        for q=1:nbr_symbolesU
            itter = 0;
            for r=col_rle_pU:col_rleU
                if(rleU(r)==symbolesU(q))
                    itter=itter+1;
                end
            end
            table_pU(q)=repetition/taille_blockU;
        end
        %Dressage de l'arbre de huffman et codage de chaque symbole de
        %chaque sous bloc de la matrice lunimance jpegY.
        eval(sprintf('dicoU_%d_%d = huffmandict(symbolesU,table_pU);',i,i));
        eval(sprintf('hcodeU_%_% = huffmanenco(rleU(col_rle_pU:col_rleU),dicoU_%_%);',i,j,i,j));
        col_rle_pU = col_rleU+1;
        
        %Début du codage entropique de Huffman pour la matrice de chrominance2 jpegV.
        col_rleU = u-1;
        %Extraction des symboles uniques présent dans le vecteur RLE de jpegV.
        symbolesV = unique(rleV(col_rle_pV:col_rleV));
        nbr_symbolesV = numel(symbolesV);
        taille_blockV = numel(rleV(col_rle_pV:col_rleV));
        %calcul des probabilités de chaque symboles.
        table_pV = ones(1,nbr_symbolesV);
        for q=1:nbr_symbolesV
            itter = 0;
            for r=col_rle_pV:col_rleV
                if(rleV(r)==symbolesV(q))
                    itter=itter+1;
                end
            end
            table_pV(q)=repetition/taille_blockV;
        end
        %Dressage de l'arbre de huffman et codage de chaque symbole de
        %chaque sous bloc de la matrice lunimance jpegY.
        eval(sprintf('dicoV_%d_%d = huffmandict(symbolesV,table_pV);',i,i));
        eval(sprintf('hcodeV_%_% = huffmanenco(rleV(col_rle_pV:col_rleV),dicoV_%_%);',i,j,i,j));
        col_rle_pV = col_rleV+1;
    end
end
jpeg=cat(3,jpegY,jpegU,jpegV);

%décodage jpegT
for i=1:dim_bloc:m
    for j=1:dim_bloc:n
        eval(sprintf('huff_decoY = [huff_decoY huffmandeco(hcodeY_%d_%d,dicoY_%d_%d)];',i,j,i,j));
        eval(sprintf('huff_decoU = [huff_decoU huffmandeco(hcodeU_%d_%d,dicoU_%d_%d)];',i,j,i,j));
        eval(sprintf('huff_decoV = [huff_decoV huffmandeco(hcodeV_%d_%d,dicoV_%d_%d)];',i,j,i,j));
    end
end
%Décodage RLE du matrice jpegY
i=1;
k=1;
while(k<=numel(huff_decoY))
    if(huff_decoY(k)==257)
        rle_decoY(i:(i-1+huff_decoY(k+1)))=huff_decoY(k+2);
        i=i+huff_decoY(k+1);
        k=k+3;
    else
        rle_decoY(i)=huff_decoY(k);
        i=i+1;
        k=k+1;
    end
end
%Décodage RLE du matrice jpegU
i=1;
k=1;
while(k<=numel(huff_decoU))
    if(huff_decoU(k)==257)
        rle_decoU(i:(i-1+huff_decoU(k+1)))=huff_decoU(k+2);
        i=i+huff_decoU(k+1);
        k=k+3;
    else
        rle_decoU(i)=huff_decoU(k);
        i=i+1;
        k=k+1;
    end
end
%Décodage RLE du matrice jpegV
i=1;
k=1;
while(k<=numel(huff_decoV))
    %if(k<numel(rle_decoV))
    if(huff_decoV(k)==257)
        rle_decoV(i:(i-1+huff_decoV(k+1)))=huff_decoV(k+2);
        i=i+huff_decoV(k+1);
        k=k+3;
    else
        rle_decoV(i)=huff_decoV(k);
        i=i+1;
        k=k+1;
    end
    %end
end
k=1;
for i=1:dim_bloc:m
    dec_l=i-1;
    for j=1:dim_bloc:n
        dec_c=j-1;
         %scan zigzag inverse de la matrice jpegU
        for q=1:64
            imgU_decompressee(lig(q)+dec_l,col(q)+dec_c) = rle_decoU(k);
            imgV_decompressee(lig(q)+dec_l,col(q)+dec_c) = rle_decoV(k);
            imgY_decompressee(lig(q)+dec_l,col(q)+dec_c) = rle_decoY(k);
            k=k+1;
        end
        %quantification inverse
        imgU_decompressee(i:i+7,j:j+7) = imgU_decompressee(i:i+7,j:j+7) .* quantificationUV;
        imgV_decompressee(i:i+7,j:j+7) = imgV_decompressee(i:i+7,j:j+7) .* quantificationUV;
        imgY_decompressee(i:i+7,j:j+7) = imgY_decompressee(i:i+7,j:j+7) .* quantificationY;
        %DCT inverse
        imgU_decompressee(i:i+7,j:j+7) = dct'*imgU_decompressee(i:i+7,j:j+7)*dct;
        imgV_decompressee(i:i+7,j:j+7) = dct'*imgV_decompressee(i:i+7,j:j+7)*dct;
        imgY_decompressee(i:i+7,j:j+7) = dct'*imgY_decompressee(i:i+7,j:j+7)*dct;
        %remise des niveaux
        imgU_decompressee(i:i+7,j:j+7) = imgU_decompressee(i:i+7,j:j+7) + offset;
        imgV_decompressee(i:i+7,j:j+7) = imgV_decompressee(i:i+7,j:j+7) + offset;
        imgY_decompressee(i:i+7,j:j+7) = imgY_decompressee(i:i+7,j:j+7) + offset;
    end
end
img_decompressee=cat(3,imgY_decompressee,imgU_decompressee,imgV_decompressee);

donc voila mon code c clair que dans la parti codage de Huffman j'ai utilisé la fonction intégré dans Matlab qui est dèja programmé ...donc s'il ya quelqu'un peut m'aidé pour programmé la fonction huffman

j'ai supprimé quelques lignes pour le code soit pas utilisable car simplement c mon code