MATLAB Language
Fourier Transforms och Inverse Fourier Transforms

Syntax

1. Y = fft (X)% beräknar FFT för Vector eller Matrix X med en standardomvandlingslängd på 256 (bekräftas för version)

2. Y = fft (X, n)% beräknar FFT för X med n som Transform Length, n måste vara ett 2-effektbaserat nummer. Om längden på X är mindre än n, kommer Matlab automatiskt att padda X med nollor så att längden (X) = n

3. Y = fft (X, n, dim)% beräknar FFT för X med n som transformeringslängd längs dimension dim (kan vara 1 eller 2 för horisontella respektive vertikala)

4. Y = fft2 (X)% Beräkna 2D FFT för X

5. Y = fftn (X, dim)% Beräkna den dim-dimensionella FFT av X, med avseende på vektorn med dimensioner dim.

6. y = ifft (X)% beräknar Inverse of FFT av X (som är en matris / vektor med siffror) med standard 256 Transform Length

7. y = ifft (X, n)% beräknar IFFT för X med n som Transform Length

8. y = ifft (X, n, dim)% beräknar IFFT för X med n som Transform Length over dimension dim (kan vara 1 eller 2 för horisontellt respektive vertikalt)

9. y = ifft (X, n, dim, 'symmetrisk')% Alternativet Symmetric gör att ifft behandlar X som konjugat symmetriskt längs den aktiva dimensionen. Det här alternativet är användbart när X inte exakt är konjugat symmetriskt, bara på grund av avrundningsfel.

10. y = ifft2 (X)% Beräkna den omvända 2D ft av X

11. y = ifftn (X, dim)% Beräkna den omvända dim-dimensionella fft av X.

parametrar

Anmärkningar

ifft(fft(X)) = X

Implementera en enkel Fourier Transform i Matlab

Fourier Transform är förmodligen den första lektionen i digital signalbehandling, applikationen finns överallt och är ett kraftfullt verktyg när det gäller att analysera data (i alla sektorer) eller signaler. Matlab har en uppsättning kraftfulla verktygslådor för Fourier Transform. I det här exemplet kommer vi att använda Fourier Transform för att analysera en grundläggande sinusvågsignal och generera vad som ibland kallas ett Periodogram med 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

Observera att Discrete Fourier Transform implementeras av Fast Fourier Transform (fft) i Matlab, båda ger samma resultat, men FFT är en snabb implementering av 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 ]')

Inverse Fourier Transforms

En av de största fördelarna med Fourier Transform är dess förmåga att vända tillbaka till Time Domain utan att förlora information. Låt oss betrakta samma signal som vi använde i föregående exempel:

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

Om vi öppnar F i Matlab, kommer vi att upptäcka att det är en matris med komplexa tal, en verklig del och en imaginär del. För att återhämta den ursprungliga Time Domain-signalen behöver vi per definition både Real (som representerar Magnitude variation) och Imaginary (som representerar fasvariation), så för att återvända till Time Domain kanske man helt enkelt vill:

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

Observera att TD returnerade skulle vara längd 256 eftersom vi ställde NFFT till 256, men längden på x är bara 64, så Matlab kommer att nollställa till slutet av TD-transformen. Så till exempel, om NFFT var 1024 och längden var 64, kommer TD tillbaka att vara 64 + 960 nollor. Observera också att på grund av flytande punktavrundning kan du få något som 3,1 * 10e-20 men för allmänt avsedd: För alla X, ifft (fft (X)) är lika med X till inom avrundningsfel.

Låt oss säga ett ögonblick att efter omvandlingen gjorde vi någonting och återstår bara den VERKLIGA delen av 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

Det betyder att vi tappar den imaginära delen av vår FFT, och därför förlorar vi information i den omvända processen. För att bevara originalet utan att tappa information bör du alltid behålla den imaginära delen av FFT med hjälp av imag och tillämpa dina funktioner på antingen båda eller den verkliga delen.

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')

Bilder och multidimensionella FT: er

Inom medicinsk avbildning, spektroskopi, bildbehandling, kryptografi och andra områden inom vetenskap och teknik är det ofta så att man vill beräkna flerdimensionella Fourier-omvandlingar av bilder. Detta är helt enkelt i Matlab: (flerdimensionella) bilder är ju bara n-dimensionella matriser, och Fourier-transformationer är linjära operatörer: en bara iterativt Fourier-transformeringar längs andra dimensioner. Matlab tillhandahåller fft2 och ifft2 att göra detta i 2-d eller fftn i n-dimensioner.

En möjlig fallgrop är att Fourier-transformationen av bilder vanligtvis visas "centrerad ordnad", dvs med ursprunget till k-space i mitten av bilden. Matlab tillhandahåller fftshift kommandot för att byta plats för DC-komponenterna i Fourier-transformen på lämpligt sätt. Denna beställningsnotation gör det väsentligt lättare att utföra vanliga bildbehandlingstekniker, varav en illustreras nedan.

Nollfyllning

Ett "snabbt och smutsigt" sätt att interpolera en liten bild till en större storlek är att Fourier-transformera den, padda Fourier-transformen med nollor och sedan ta den omvända transformen. Detta interpolerar effektivt mellan varje pixel med en sincformad basfunktion och används vanligtvis för att uppskala medicinsk bildinformation med låg upplösning. Låt oss börja med att ladda ett inbyggt bildexempel

%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

Vi kan nu få Fourier-transformen av I. För att illustrera vad fftshift gör, låt oss jämföra de två metoderna:

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

Vi har nu fått 2D FT för en exempelbild. För att fylla den noll, vill vi ta varje k-utrymme, stoppa kanterna med nollor och sedan ta tillbaka transformen:

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

Vid detta tillfälle är resultatet ganska obetydligt:

När vi sedan har tagit back-transforms kan vi se att (korrekt!) Nollfyllningsdata ger en förnuftig metod för interpolering:

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

Observera att den nollfyllda bildstorleken är dubbelt så stor som originalet. Man kan noll fylla med mer än en faktor två i varje dimension, även om det uppenbarligen inte ökar godtyckligt storleken på en bild.

Tips, tips, 3D och därefter

Ovanstående exempel gäller för 3D-bilder (som ofta genereras av medicinsk bildteknik eller konfokalmikroskopi, till exempel), men kräver till fft2 att fft2 ersätts av fftn(I, 3) . På grund av att det är något besvärligt att skriva fftshift(fft(fftshift(... flera gånger)) är det ganska vanligt att definiera funktioner som fft2c lokalt för att ge enklare syntax lokalt - som:

function y = fft2c(x)

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

Observera att FFT är snabbt, men stora, flerdimensionella Fourier-omvandlingar kommer fortfarande att ta tid på en modern dator. Det är dessutom inneboende komplex: storleken på k-rymden visades ovan, men fasen är absolut viktig; översättningar i bilddomänen motsvarar en fasrampa i Fourier-domänen. Det finns flera mycket mer komplicerade operationer som man kanske vill göra inom Fourier-domänen, till exempel att filtrera höga eller låga rumsfrekvenser (genom att multiplicera den med ett filter), eller maskera ut diskreta punkter som motsvarar brus. Det finns motsvarande en stor mängd communitygenererad kod för att hantera vanliga Fourier-operationer som finns tillgängliga på Matlabs huvudsortslagerplats, File Exchange .