Travaux pratiques de traitement d’image

Ce travail pratique permet de manipuler la transformée de Fourier appliquée aux images numériques. Vous apprendrez à comprendre la relation entre le domaine spatial et le domaine fréquentiel, à calculer et visualiser la transformée de Fourier 1D et 2D, à animer des spectres de fréquences, puis à appliquer une compression d’image basée sur la transformée en cosinus discret (DCT). Pour réaliser ce TP, il est nécessaire de disposer d’un environnement Matlab ou équivalent capable de traiter des images et d’exécuter des scripts de calcul matriciel.

Objectifs

• Comprendre la transformée de Fourier discrète (FFT) appliquée aux signaux 1D et 2D.
• Visualiser et interpréter le spectre fréquentiel d’images numériques.
• Créer et animer des images cosinus et observer leur transformée de Fourier.
• Appliquer la transformée en cosinus discret (DCT) pour la compression d’images.
• Mettre en œuvre la compression JPEG par découpage en blocs et filtrage fréquentiel.

Prérequis et installation

• Connaissances de base en traitement du signal et en transformée de Fourier.
• Maîtrise de Matlab ou d’un logiciel équivalent capable de lire des images, calculer des FFT et DCT, et afficher des images.
• Images d’exemple : « porte.bmp » et « clown.bmp » disponibles dans le répertoire de travail.
• Fonctions Matlab utilisées : imread, double, size, fft, fft2, fftshift, ifft, ifft2, dct2, idct2, imagesc, imshow, colormap, axis, plot, drawnow.

Manipulation de la transformée de Fourier 1D

Cette étape permet de revoir la construction de la transformée de Fourier discrète (FFT) sur un signal 2D en traitant une ligne d’image comme un signal 1D.

1. Ouvrez l’image « porte.bmp » avec la commande :

   MaPorte = imread('porte.bmp');

2. Convertissez l’image en valeurs réelles (double précision) pour plus de précision dans les calculs :

   MaPorte = double(MaPorte);

3. Récupérez les dimensions de l’image (nombre de lignes Nlin et de colonnes Ncol) :

   [Nlin, Ncol] = size(MaPorte);

4. Affichez l’image en niveaux de gris :

   figure(1); image(MaPorte);

5. Calculez la FFT d’une ligne centrale (Nlin/2) de l’image :

   Freq_ligne = fft(MaPorte(round(Nlin/2), :));

6. Tracez le spectre (module) de cette ligne :

   figure(2); plot(abs(Freq_ligne));

Freq_periodique = Freq_ligne;
for u = 2:16
    Freq_periodique = [Freq_periodique Freq_ligne];
end

figure(3);
plot(abs(Freq_ligne));
figure(4);
plot(abs(Freq_periodique));

Signal_reconstruit = ifft(Freq_periodique);

FFT_ligne = fftshift(fft(MaPorte(round(Nlin/2), :)));
figure(5);
plot(abs(FFT_ligne));

Vous constaterez que l’axe des abscisses correspond à l’indice des points calculés et non directement à la fréquence. Le spectre est périodique et symétrique, avec les basses fréquences au centre après fftshift.

Transformée de Fourier 2D

Cette étape consiste à appliquer la FFT sur l’image entière pour passer du domaine spatial au domaine fréquentiel.

1. Calculez la transformée de Fourier 2D de l’image « porte.bmp » :

   FFT_MaPorte = fft2(MaPorte);

2. Pour une meilleure visualisation, appliquez un décalage centré des fréquences :

   FFT_MaPorte = fftshift(FFT_MaPorte);

3. Affichez le module du spectre en ajustant l’échelle des niveaux de gris :

   Image_affiche = abs(FFT_MaPorte);
   imagesc(Image_affiche);
   colormap(pink(256));
   axis('image');

4. Vous pouvez aussi utiliser imagesc() qui ajuste automatiquement les niveaux de gris.

Animation de la transformée de Fourier 2D

Cette partie propose de créer une image cosinus 2D avec des fréquences variables et d’observer l’évolution de son spectre de Fourier.

1. Initialisez les périodes Tox et Toy à 0 :

   Tox = 0;
   Toy = 0;

2. Créez une boucle qui incrémente Tox et Toy, génère l’image cosinus, calcule et affiche sa FFT :

while (Tox <= 1024)
    Tox = Tox + 1;
    Toy = Toy + 1;
    for i = 1:128
        for j = 1:128
            mon_cos(i,j) = double(128*(1 + cos(2*pi*(i/Tox + j/Toy))));
        end
    end
    figure(1);
    imshow(((mon_cos - min(min(mon_cos))) * 1 / (max(max(mon_cos)) - min(min(mon_cos)))));
    drawnow;
    colormap(pink(256));
    axis('image');

    figure(2);
    colormap(pink(256));
    axis('image');
    FFT_MonCos = fft2(mon_cos);
    FFT_MonCos = fftshift(FFT_MonCos);
    Image_affiche = abs(FFT_MonCos);
    imshow(((Image_affiche - min(min(Image_affiche))) * 256 / (max(max(Image_affiche)) - min(min(Image_affiche)))));
    drawnow;
end

Vous observerez que les pics du spectre se déplacent en fonction des fréquences du cosinus, illustrant la relation entre fréquence spatiale et spectre.

Compression d’image par transformée en cosinus discret (DCT)

Cette partie illustre la compression JPEG basée sur la DCT, qui découpe l’image en blocs, calcule la DCT de chaque bloc, supprime certaines fréquences, puis reconstruit l’image.

Principe

• Découpage de l’image en blocs de taille 8x8.
• Calcul de la DCT 2D sur chaque bloc.
• Regroupement des coefficients DCT par ordre de fréquence.
• Suppression des coefficients correspondant aux hautes fréquences.
• Calcul de la DCT inverse sur chaque bloc.
• Reconstruction de l’image compressée.

Manipulation

1. Chargez l’image « clown.bmp » et calculez sa DCT complète :

   MonClown = imread('clown.bmp');
   DCT = dct2(MonClown);

2. Affichez la DCT avec une colormap adaptée :

   figure(1);
   imagesc(DCT);
   colormap(pink(256));

3. Notez que l’origine des fréquences est en haut à gauche.
4. Pour simuler une compression, mettez à zéro les coefficients au-delà de la bissectrice rouge (haut à gauche conservé, bas à droite supprimé).
5. Calculez la DCT inverse et affichez l’image reconstruite :

   Ma_DCT_inv = idct2(DCT);
   figure(2);
   imagesc(Ma_DCT_inv);
   colormap(gray(256));

tbloc = 8;
[Nlin, Ncol] = size(MonClown);
for i = 1:round(Ncol / tbloc)
    for j = 1:round(Nlin / tbloc)
        for k = 1:tbloc
            for l = 1:tbloc
                bloc(k,l) = MonClown((i-1)*tbloc + k, (j-1)*tbloc + l);
            end
        end
        dct_image(i,j,:,:) = dct2(bloc);
    end
end

7. Reconstituez une image en conservant la position des blocs DCT :

   for i = 1:round(Ncol / tbloc)
       for j = 1:round(Nlin / tbloc)
           for k = 1:tbloc
               for l = 1:tbloc
                   DCT1((i-1)*tbloc + k, (j-1)*tbloc + l) = dct_image(i,j,k,l);
               end
           end
       end
   end
   figure(3);
   imagesc(DCT1);
   colormap(gray(256));

8. Représentez la DCT en regroupant les pixels de tous les blocs par coefficient (tous les premiers pixels ensemble, etc.) :

   for k = 1:tbloc
       for l = 1:tbloc
           for i = 1:Ncol / tbloc
               for j = 1:Nlin / tbloc
                   DCT2((k-1)*Ncol/tbloc + i, (l-1)*Nlin/tbloc + j) = dct_image(i,j,k,l);
               end
           end
       end
   end
   figure(4);
   imagesc(DCT2);
   colormap(gray(256));

9. Reconstruction par DCT inverse avec application d’un masque binaire (0 ou 1) pour filtrer les coefficients :

   for i = 1:round(Ncol / tbloc)
       for j = 1:round(Nlin / tbloc)
           bloc = idct2(masque .* reshape(dct_image(i,j,:,:), tbloc, tbloc));
           for k = 1:tbloc
               for l = 1:tbloc
                   ImReconstitue((i-1)*tbloc + k, (j-1)*tbloc + l) = bloc(k,l);
               end
           end
       end
   end
   figure(5);
   imagesc(ImReconstitue);
   colormap(gray(256));

Le masque est une matrice tbloc x tbloc composée de 0 et 1. Les coefficients multipliés par 0 sont supprimés, ceux multipliés par 1 sont conservés. Expérimentez différentes configurations pour observer l’impact sur la qualité de l’image reconstruite.

Résultats attendus

• Visualisation correcte des spectres de Fourier 1D et 2D, avec les basses fréquences centrées après fftshift.
• Animation fluide montrant le déplacement des pics fréquentiels en fonction des fréquences du cosinus.
• Affichage clair des coefficients DCT de l’image « clown.bmp » avec origine en haut à gauche.
• Images reconstruites après compression DCT présentant une perte progressive de qualité selon le masque appliqué.
• Différence visible entre l’image originale et l’image reconstruite, quantifiable par une erreur croissante avec la suppression de coefficients.

Pièges courants

• Oublier de convertir l’image en double avant calcul des FFT ou DCT, ce qui peut fausser les résultats.
• Confondre les indices des pixels avec les fréquences réelles dans les spectres, notamment avant fftshift.
• Ne pas centrer le spectre avec fftshift, rendant l’interprétation difficile.
• Ne pas normaliser ou ajuster l’échelle des images affichées, ce qui peut masquer les détails du spectre.
• Dans la compression DCT, appliquer un masque incorrect ou mal dimensionné, provoquant une reconstruction erronée.
• Ne pas respecter la taille des blocs lors du découpage, ce qui peut entraîner des erreurs d’indice ou des blocs incomplets.
• Oublier d’utiliser drawnow dans la boucle d’animation, ce qui empêche la mise à jour visuelle en temps réel.