Répondre à la discussion
Affichage des résultats 1 à 7 sur 7

traitement d'image : matlab



  1. #1
    okitrinaw

    Post traitement d'image : matlab


    ------

    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

    -----

  2. Publicité
  3. #2
    lou_ibmix_xi

    Re : traitement d'image : matlab

    Google est-il si compliqué que celà ?

  4. #3
    okitrinaw

    Re : traitement d'image : matlab

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

  5. #4
    lou_ibmix_xi

    Re : traitement d'image : matlab

    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...

  6. A voir en vidéo sur Futura
  7. #5
    okitrinaw

    Re : traitement d'image : matlab

    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

  8. #6
    lou_ibmix_xi

    Re : traitement d'image : matlab

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

  9. Publicité
  10. #7
    okitrinaw

    Re : traitement d'image : matlab

    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

    Code:
    %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');

    Code:
    %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;

    Code:
    %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);

    Code:
    %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
    Dernière modification par JPL ; 20/04/2012 à 18h44. Motif: Remplacement de la balise Quote par Code

Discussions similaires

  1. [MATLAB] Segmentation d'image + edition d'une matrice d'image
    Par Djodjo89 dans le forum Logiciel - Software - Open Source
    Réponses: 1
    Dernier message: 04/11/2009, 13h24
  2. traitement d'image sous matlab
    Par MED ALI dans le forum Logiciel - Software - Open Source
    Réponses: 1
    Dernier message: 27/02/2009, 22h36
  3. Programmation Matlab, traitement d'image
    Par flaharrague dans le forum Logiciel - Software - Open Source
    Réponses: 6
    Dernier message: 14/01/2008, 12h11
  4. traitement d'image
    Par lak2007 dans le forum Logiciel - Software - Open Source
    Réponses: 4
    Dernier message: 03/12/2007, 09h14
  5. matlab et traitement d'image
    Par kiri43 dans le forum Logiciel - Software - Open Source
    Réponses: 16
    Dernier message: 19/07/2007, 12h16
Découvrez nos comparatifs produits sur l'informatique et les technologies.