TP3: Transformée de Fourier discrète 2D

L'objectif de ce TP est de faire des manipulations simples de transformée de Fourier discrète 2D en partant
du calcul et de l'affichage vers le filtrage spectral et la manipulation d'amplitude et de phase.

A) Calcul et affichage

1) La fonction cosinus ci-dessous est un signal 2D réel à combien d'échantillons?

Entrée [ ]:

import numpy as np
import matplotlib.pyplot as plt

x = np.arange(0, 1001, 1)

X,Y = np.meshgrid(x, x)
wavelength = 250
cosinus = np.cos(2 * np.pi * X / wavelength)

Ecrivez ici vos réponses

2) Affichez l'image correspondant à ce signal 2D

Entrée [ ]:

import matplotlib.pyplot as plt

plt.imshow(cosinus,cmap='gray')
plt.show()

3) Changer la valeur de la variable wavelenght: wavelenght = 100 et affichez de nouveau l'image. Que
remarquez vous?
Ecrivez ici vos réponses

Entrée [ ]:

cosinus1 = np.cos(2 * np.pi * X /100)#diminution de periode

plt.imshow(cosinus1,cmap='gray')
plt.show()

4) Calculez et affichez la magnitude de la transformée de Fourier du signal 2D cosinus. Vous utiliserez pour
cela les fuctions suivante de la librairie numpy: fft.fft2 pour le calcul de la transformée de fourier, fft.fftshift
pour faire en sorte que les basses fréquences soient affichées au milieu. La magnitude est calculée avec la
function abs.

Entrée [ ]:

f1=np.fft.fft2(cosinus)
f2=np.fft.fftshift(f1)
mag=np.abs(f2)
plt.imshow(mag ,cmap='gray')
plt.title("magnitude")
plt.show()
5) Zoomez sur la région centrale de la transformée de Fourier. Choisissez les bonnes limites de votre
fenêtre d'affichage en vous aidant par un calcul. Une fois les limites calculée vous utiliserez les fonction xlim
et ylim de pyplot.

Entrée [ ]:

plt.xlim([490,510])
plt.ylim([490,510])
plt.imshow(mag ,cmap='gray')
plt.title("magnitude")
plt.show()

B) Filtrage spectral

1) La function suivante crée un masque binaire circulaire passe haut ou passe bas selon l'option choisie par
l'utilisateur

Entrée [ ]:

def makeCircularFilter(numRows, numCols, radius, highPass=True):

centerI, centerJ = int(numRows/2), int(numCols/2)
x,y=np.ogrid[:numRows,:numCols]
dist_from_center = np.sqrt((x - centerI)**2 + (y-centerJ)**2)
mask = dist_from_center <= radius
return 1 - mask if highPass else mask

2) Créez un masque circulaire passe haut de la même taille que l'image einstein et de rayon 10 et affichez
le.
Entrée [ ]:

import cv2
data=cv2.imread("einstein.png")
data.shape
ein=makeCircularFilter(380,364,10,highPass=True)
plt.imshow(ein,cmap='gray')
plt.show()

3) Créez un masque circulaire passe bas de la même taille que l'image einstein et de rayon 10 et affichez le.

Entrée [ ]:

import cv2
data=cv2.imread("einstein.png",0)
data.shape
mask_ein=makeCircularFilter(380,364,10,highPass=False)
plt.imshow(ein,cmap='gray')
plt.show()

4) Appliquez un filtrage passe haut à l'image einstein et affichez le résultat. Vous multiplierez pour cela la
transformée de Fourier de l'image einstein par le masque passe haut et vous calculerez la transformée de
Fourier inverse.
Entrée [ ]:

mask_ein=makeCircularFilter(380,364,10,highPass=True)
img_fft = np.fft.fft2(data)
img_fft_shifted = np.fft.fftshift(img_fft)
filtered_fft = img_fft_shifted * mask_ein
filtered_img = np.fft.ifft2(np.fft.ifftshift(filtered_fft)).real
plt.imshow(filtered_img, cmap='gray')
plt.show()
print(img_fft_shifted.shape)

(380, 364)

5) Appliquez cette fois-ci un filtrage passe bas à l'image einstein et affichez le résultat
Entrée [ ]:

mask_ein=makeCircularFilter(380,364,10,highPass=False)
img_fft = np.fft.fft2(data)
img_fft_shifted = np.fft.fftshift(img_fft)
filtered_fft = img_fft_shifted * mask_ein
filtered_img = np.fft.ifft2(np.fft.ifftshift(filtered_fft)).real
plt.imshow(filtered_img, cmap='gray')
plt.show()
print(img_fft_shifted.shape)

(380, 364)

6) Changez la taille du rayon à 40 et observez l'effet sur le filtrage passe haut et passe bas
Entrée [ ]:

#Hautes_Freq
mask_ein=makeCircularFilter(380,364,40,highPass=True)
img_fft = np.fft.fft2(data)
img_fft_shifted = np.fft.fftshift(img_fft)
filtered_fft = img_fft_shifted * mask_ein
filtered_img = np.fft.ifft2(np.fft.ifftshift(filtered_fft)).real
plt.imshow(filtered_img, cmap='gray')
plt.show()
print(img_fft_shifted.shape)
#Basses_Freq
mask_ein=makeCircularFilter(380,364,40,highPass=False)
img_fft = np.fft.fft2(data)
img_fft_shifted = np.fft.fftshift(img_fft)
filtered_fft = img_fft_shifted * mask_ein
filtered_img = np.fft.ifft2(np.fft.ifftshift(filtered_fft)).real
plt.imshow(filtered_img, cmap='gray')
plt.show()
print(img_fft_shifted.shape)

(380, 364)

(380, 364)

7) Appliquez un filtrage passe bas à l'image Marylin et le filtrage passe haut à l'image einstein. Vous
utiliserez pour les deux un rayon égal à 20. Additionnez les deux images et observez le résultat.
Type Markdown and LaTeX: 𝛼2
Entrée [ ]:

mask_ein=makeCircularFilter(380,364,40,highPass=False)
img_fft = np.fft.fft2(data)
img_fft_shifted = np.fft.fftshift(img_fft)
filtered_fft = img_fft_shifted * mask_ein
filtered_img = np.fft.ifft2(np.fft.ifftshift(filtered_fft)).real
#-------------------------------------------------------------------------------
marilyn=cv2.imread("marilyn.png",0)
mask_ein=makeCircularFilter(marilyn.shape[0],marilyn.shape[1],20,highPass=False)
img_fft = np.fft.fft2(marilyn)
img_fft_shifted = np.fft.fftshift(img_fft)
filtered_fft = img_fft_shifted * mask_ein
filtered_img_mar = np.fft.ifft2(np.fft.ifftshift(filtered_fft)).real
print(img_fft_shifted.shape)
sum=filtered_img_mar+filtered_img
plt.imshow(sum,cmap='gray')
plt.show()

(380, 364)