MATLAB Language
Transformées de Fourier et Transformées de Fourier Inverse

Syntaxe

1. Y = fft (X)% calcule la FFT de Vector ou Matrix X en utilisant une longueur de transformation par défaut de 256 (à confirmer pour la version)

2. Y = fft (X, n)% calcule la FFT de X en utilisant n comme longueur de transformation, n doit être un nombre basé sur 2 puissances. Si la longueur de X est inférieure à n, Matlab compresse automatiquement X avec des zéros tels que la longueur (X) = n

3. Y = fft (X, n, dim)% calcule la FFT de X en utilisant n comme longueur de transformation le long de la dimension dim (peut être égale à 1 ou 2 pour l'horizontale ou la verticale, respectivement)

4. Y = fft2 (X)% Calculer la FFT 2D de X

5. Y = fftn (X, dim)% Calculer la FFT dimensionnelle dimensionnelle de X, par rapport au vecteur de dimensions dim.

6. y = ifft (X)% calcule l'inverse de FFT de X (qui est une matrice / vecteur de nombres) en utilisant la longueur de transformation par défaut de 256

7. y = ifft (X, n)% calcule l'IFFT de X en utilisant n comme longueur de transformation

8. y = ifft (X, n, dim)% calcule l'IFFT de X en utilisant n comme longueur de transformation sur la dimension dim (peut être 1 ou 2 pour l'horizontale ou la verticale, respectivement)

9. y = ifft (X, n, dim, 'symétrique')% L'option Symétrique permet à ifft de traiter X comme conjugué symétrique le long de la dimension active. Cette option est utile lorsque X n'est pas exactement conjugué symétrique, simplement en raison d'une erreur d'arrondi.

10. y = ifft2 (X)% Calculer l'inverse 2D ft de X

11. y = ifftn (X, dim)% Calculer l'inverse dim dimensionnel fft de X.

Paramètres

Remarques

ifft(fft(X)) = X

Implémenter une simple transformation de Fourier dans Matlab

La transformation de Fourier est probablement la première leçon de traitement du signal numérique, son application est omniprésente et constitue un outil puissant pour analyser des données (dans tous les secteurs) ou des signaux. Matlab dispose d'un ensemble de boîtes à outils puissantes pour la transformation de Fourier. Dans cet exemple, nous utiliserons la transformée de Fourier pour analyser un signal sinusoïdal de base et générer ce que l'on appelle parfois un périodogramme à l'aide de la FFT:

%Signal Generation
A1=10;                % Amplitude 1
A2=10;                % Amplitude 2
w1=2*pi*0.2;          % Angular frequency 1
w2=2*pi*0.225;        % Angular frequency 2
Ts=1;                 % Sampling time
N=64;                 % Number of process samples to be generated
K=5;                  % Number of independent process realizations
sgm=1;                % Standard deviation of the noise
n=repmat([0:N-1].',1,K);             % Generate resolution
phi1=repmat(rand(1,K)*2*pi,N,1);     % Random phase matrix 1
phi2=repmat(rand(1,K)*2*pi,N,1);     % Random phase matrix 2
x=A1*sin(w1*n*Ts+phi1)+A2*sin(w2*n*Ts+phi2)+sgm*randn(N,K);   % Resulting Signal

NFFT=256;            % FFT length
F=fft(x,NFFT);       % Fast Fourier Transform Result
Z=1/N*abs(F).^2;     % Convert FFT result into a Periodogram

Notez que la Transformée de Fourier Discrète est implémentée par Fast Fourier Transform (fft) dans Matlab, les deux donneront le même résultat, mais FFT est une implémentation rapide de DFT.

figure
w=linspace(0,2,NFFT);
plot(w,10*log10(Z)),grid;
xlabel('w [\pi rad/s]')
ylabel('Z(f) [dB]')
title('Frequency Range: [ 0 ,  \omega_s ]')

Transformées de Fourier Inverse

L'un des principaux avantages de la transformation de Fourier est sa capacité à revenir au domaine temporel sans perdre d'informations. Considérons le même Signal que nous avons utilisé dans l'exemple précédent:

A1=10;                % Amplitude 1
A2=10;                % Amplitude 2
w1=2*pi*0.2;          % Angular frequency 1
w2=2*pi*0.225;        % Angular frequency 2
Ts=1;                 % Sampling time
N=64;                 % Number of process samples to be generated
K=1;                  % Number of independent process realizations
sgm=1;                % Standard deviation of the noise
n=repmat([0:N-1].',1,K);             % Generate resolution
phi1=repmat(rand(1,K)*2*pi,N,1);     % Random phase matrix 1
phi2=repmat(rand(1,K)*2*pi,N,1);     % Random phase matrix 2
x=A1*sin(w1*n*Ts+phi1)+A2*sin(w2*n*Ts+phi2)+sgm*randn(N,K);   % Resulting Signal

NFFT=256;            % FFT length
F=fft(x,NFFT);       % FFT result of time domain signal

Si nous ouvrons F dans Matlab, nous constaterons que c'est une matrice de nombres complexes, une partie réelle et une partie imaginaire. Par définition, afin de récupérer le signal Time Domain d'origine, nous avons besoin à la fois du Real (qui représente la variation de l'amplitude) et de l'Imaginary (qui représente la variation de phase).

TD = ifft(F,NFFT);   %Returns the Inverse of F in Time Domain

Notez que TD renvoyé aurait la longueur 256 car nous avons défini NFFT sur 256, mais la longueur de x est seulement 64, donc Matlab compilera les zéros à la fin de la transformation TD. Ainsi, par exemple, si NFFT était 1024 et que la longueur était 64, le TD retourné serait 64 + 960 zéros. Notez également qu'en raison de l'arrondi à virgule flottante, vous pourriez obtenir quelque chose comme 3.1 * 10e-20 mais pour des raisons générales: Pour tout X, ifft (fft (X)) est égal à X dans l'erreur d'arrondi.

Disons un instant qu'après la transformation, nous avons fait quelque chose et ne sommes restés qu'avec la partie REAL de la FFT:

R = real(F);         %Give the Real Part of the FFT
TDR = ifft(R,NFFT);  %Give the Time Domain of the Real Part of the FFT

Cela signifie que nous perdons la partie imaginaire de notre FFT et que, par conséquent, nous perdons des informations dans ce processus inverse. Pour préserver l'original sans perdre d'informations, vous devez toujours conserver la partie imaginaire de la FFT en utilisant imag et appliquer vos fonctions à la fois à la pièce réelle et à la pièce.

figure
subplot(3,1,1)
plot(x);xlabel('time samples');ylabel('magnitude');title('Original Time Domain Signal')
subplot(3,1,2)
plot(TD(1:64));xlabel('time samples');ylabel('magnitude');title('Inverse Fourier Transformed - Time Domain Signal')
subplot(3,1,3)
plot(TDR(1:64));xlabel('time samples');ylabel('magnitude');title('Real part of IFFT transformed Time Domain Signal')

Images et FT multidimensionnelles

Dans l'imagerie médicale, la spectroscopie, le traitement d'images, la cryptographie et d'autres domaines de la science et de l'ingénierie, on souhaite souvent calculer des transformées de Fourier multidimensionnelles. Ceci est assez simple dans Matlab: les images (multidimensionnelles) ne sont que des matrices à n dimensions, après tout, les transformées de Fourier sont des opérateurs linéaires: l'une juste transforme Fourier selon d'autres dimensions. Matlab fournit fft2 et ifft2 pour le faire en fftn , ou fftn en n-dimensions.

Un écueil potentiel est que la transformée de Fourier des images est généralement représentée "centrée sur l'ordre", c'est-à-dire avec l'origine de l'espace k au milieu de l'image. Matlab fournit la commande fftshift pour échanger de manière fftshift l'emplacement des composants DC de la transformée de Fourier. Cette notation permet de simplifier considérablement les techniques courantes de traitement des images, dont l'une est illustrée ci-dessous.

Zéro remplissage

Une façon "rapide et sale" d’interpoler une petite image à une plus grande taille est de la transformer en Fourier, de placer des zéros dans la transformée de Fourier, puis de prendre la transformation inverse. Cela interpole efficacement chaque pixel avec une fonction de base en forme de sinc et est couramment utilisé pour mettre à niveau les données d'imagerie médicale à basse résolution. Commençons par charger un exemple d'image intégré

%Load example image 
I=imread('coins.png'); %Load example data -- coins.png is builtin to Matlab 
I=double(I); %Convert to double precision -- imread returns integers 
imageSize = size(I); % I is a 246 x 300 2D image

%Display it
imagesc(I); colormap gray; axis equal; 
%imagesc displays images scaled to maximum intensity

Nous pouvons maintenant obtenir la transformée de Fourier de I. Pour illustrer ce fftshift fait fftshift , comparons les deux méthodes:

% Fourier transform 
%Obtain the centric- and non-centric ordered Fourier transform of I
k=fftshift(fft2(fftshift(I))); 
kwrong=fft2(I); 

%Just for the sake of comparison, show the magnitude of both transforms: 
figure; subplot(2,1,1); 
imagesc(abs(k),[0 1e4]); colormap gray; axis equal; 
subplot(2,1,2); 
imagesc(abs(kwrong),[0 1e4]); colormap gray; axis equal;
%(The second argument to imagesc sets the colour axis to make the difference clear). 

Nous avons maintenant obtenu le FT 2D d'un exemple d'image. Pour le remplir à zéro, nous voulons prendre chaque espace k, remplir les bords avec des zéros, puis prendre la transformation inverse:

%Zero fill
kzf = zeros(imageSize .* 2); %Generate a  492x600 empty array to put the result in 
kzf(end/4:3*end/4-1,end/4:3*end/4-1) = k; %Put k in the middle 
kzfwrong = zeros(imageSize .* 2); %Generate a  492x600 empty array to put the result in 
kzfwrong(end/4:3*end/4-1,end/4:3*end/4-1) = kwrong; %Put k in the middle 

%Show the differences again 
%Just for the sake of comparison, show the magnitude of both transforms: 
figure; subplot(2,1,1); 
imagesc(abs(kzf),[0 1e4]); colormap gray; axis equal; 
subplot(2,1,2); 
imagesc(abs(kzfwrong),[0 1e4]); colormap gray; axis equal;
%(The second argument to imagesc sets the colour axis to make the difference clear). 

À ce stade, le résultat est plutôt banal:

Une fois que nous prenons les back-transforms, nous pouvons voir que (correctement!) Les données sans remplissage fournissent une méthode sensée d'interpolation:

% Take the back transform and view 
Izf = fftshift(ifft2(ifftshift(kzf))); 
Izfwrong = ifft2(kzfwrong);

figure; subplot(1,3,1); 
imagesc(abs(Izf)); colormap gray; axis equal; 
title('Zero-filled image'); 
subplot(1,3,2); 
imagesc(abs(Izfwrong)); colormap gray; axis equal;
title('Incorrectly zero-filled image'); 
subplot(1,3,3); 
imagesc(I); colormap gray; axis equal; 
title('Original image'); 
set(gcf,'color','w'); 

Notez que la taille de l'image à zéro est le double de celle de l'original. On peut mettre à zéro plus d'un facteur deux dans chaque dimension, bien que cela n'augmente pas de manière arbitraire la taille d'une image.

Trucs, astuces, 3D et au-delà

L'exemple ci-dessus vaut pour les images 3D (souvent générées par les techniques d'imagerie médicale ou la microscopie confocale, par exemple), mais nécessite que fft2 soit remplacé par fftn(I, 3) , par exemple. En raison de la nature quelque peu lourde de l'écriture de fftshift(fft(fftshift(... plusieurs fois, il est assez courant de définir des fonctions telles que fft2c localement pour fournir localement une syntaxe plus facile, comme:

function y = fft2c(x)

y = fftshift(fft2(fftshift(x)));

Notez que la FFT est rapide, mais les grandes transformations multidimensionnelles de Fourier prendront du temps sur un ordinateur moderne. En outre, elle est intrinsèquement complexe: l’ampleur de l’espace k était indiquée ci-dessus, mais la phase est absolument vitale; les traductions dans le domaine de l'image sont équivalentes à une rampe de phase dans le domaine de Fourier. Il existe plusieurs opérations beaucoup plus complexes que l'on peut souhaiter effectuer dans le domaine de Fourier, telles que le filtrage de fréquences spatiales hautes ou basses (en le multipliant par un filtre) ou en masquant des points discrets correspondant au bruit. Il existe en conséquence une grande quantité de code généré par la communauté pour gérer les opérations de Fourier courantes disponibles sur le principal site de référentiel communautaire de Matlab, à savoir File Exchange .