MATLAB Language
Fourier-transformaties en inverse Fourier-transformaties

Syntaxis

1. Y = fft (X)% berekent de FFT van Vector of Matrix X met een standaard transformatie lengte van 256 (te bevestigen voor versie)

2. Y = fft (X, n)% berekent de FFT van X met n als Transform Lengte, n moet een getal op basis van 2 vermogens zijn. Als de lengte van X kleiner is dan n, zal Matlab X automatisch met nullen vullen, zodat lengte (X) = n

3. Y = fft (X, n, dim)% berekent de FFT van X met n als Transform Lengte langs dimensies dim (kan respectievelijk 1 of 2 zijn voor horizontaal of verticaal)

4. Y = fft2 (X)% Bereken de 2D FFT van X

5. Y = fftn (X, dim)% Bereken de dim-dimensionale FFT van X, ten opzichte van de vector met dimensies dim.

6. y = ifft (X)% berekent de inverse van FFT van X (wat een matrix / vector van getallen is) met behulp van de standaard 256 transformatie lengte

7. y = ifft (X, n)% berekent de IFFT van X met n als Transform Lengte

8. y = ifft (X, n, dim)% berekent de IFFT van X met n als Transform Lengte over dim dim (kan respectievelijk 1 of 2 zijn voor horizontaal of verticaal)

9. y = ifft (X, n, dim, 'symmetrisch')% De optie Symmetrisch zorgt ervoor dat ifft X behandelt als geconjugeerd symmetrisch langs de actieve dimensie. Deze optie is handig wanneer X niet precies symmetrisch is geconjugeerd, alleen vanwege een afrondingsfout.

10. y = ifft2 (X)% Bereken de inverse 2D ft van X

11. y = ifftn (X, dim)% Bereken de inverse dim-dimensionale fft van X.

parameters

Opmerkingen

ifft(fft(X)) = X

Implementeer een eenvoudige Fourier Transform in Matlab

Fourier Transform is waarschijnlijk de eerste les in digitale signaalverwerking, de toepassing is overal en het is een krachtig hulpmiddel voor het analyseren van gegevens (in alle sectoren) of signalen. Matlab heeft een set krachtige toolboxen voor Fourier Transform. In dit voorbeeld zullen we Fourier Transform gebruiken om een basis-sinusgolfsignaal te analyseren en met behulp van FFT een zogenaamd periodogram te genereren:

%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

Merk op dat de Discrete Fourier Transform wordt geïmplementeerd door Fast Fourier Transform (fft) in Matlab, beide zullen hetzelfde resultaat opleveren, maar FFT is een snelle implementatie van 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-transformaties

Een van de grote voordelen van Fourier Transform is zijn vermogen om terug te keren naar het tijdsdomein zonder informatie te verliezen. Laten we hetzelfde signaal bekijken dat we in het vorige voorbeeld hebben gebruikt:

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

Als we F openen in Matlab, zullen we ontdekken dat het een matrix is van complexe getallen, een reëel deel en een denkbeeldig deel. Om het oorspronkelijke tijdsdomeinsignaal te herstellen, hebben we per definitie zowel de reële waarde (die de variatie in grootte nodig heeft) als de imaginaire (die de variatie in de fase vertegenwoordigt), dus om terug te keren naar het tijdsdomein, zou je gewoon willen kunnen:

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

Merk op dat TD dat wordt geretourneerd lengte 256 zou zijn, omdat we NFFT instellen op 256, maar de lengte van x is slechts 64, dus Matlab zal nullen vullen tot het einde van de TD-transformatie. Dus bijvoorbeeld als NFFT 1024 was en de lengte 64 was, dan is TD terug 64 + 960 nullen. Merk ook op dat als gevolg van afronding met drijvende komma, u misschien iets krijgt als 3.1 * 10e-20 maar voor algemene doeleinden: voor elke X is ifft (fft (X)) gelijk aan X binnen de afrondingsfout.

Laten we even zeggen dat we na de transformatie iets hebben gedaan en alleen het ECHTE gedeelte van de FFT hebben achtergelaten:

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

Dit betekent dat we het denkbeeldige deel van onze FFT verliezen en daarom verliezen we informatie in dit omgekeerde proces. Om het origineel te behouden zonder informatie te verliezen, moet u het imaginaire deel van de FFT altijd met imag en uw functies op beide of het reële deel toepassen.

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

Afbeeldingen en multidimensionale FT's

In medische beeldvorming, spectroscopie, beeldverwerking, cryptografie en andere gebieden van wetenschap en techniek is het vaak het geval dat men multidimensionale Fourier-transformaties van beelden wil berekenen. Dit is vrij eenvoudig in Matlab: (multidimensionale) afbeeldingen zijn tenslotte alleen n-dimensionale matrices, en Fourier-transformaties zijn lineaire operatoren: één is iteratief Fourier transformeert langs andere dimensies. Matlab biedt fft2 en ifft2 om dit in 2-d te doen, of fftn in n-dimensies.

Een mogelijke valkuil is dat de Fourier-transformatie van afbeeldingen meestal "gecentreerd geordend" wordt weergegeven, dwz met de oorsprong van k-ruimte in het midden van de afbeelding. Matlab biedt het fftshift commando om de locatie van de DC-componenten van de Fourier-transformatie op de juiste fftshift te verwisselen. Deze bestelnotatie maakt het aanzienlijk eenvoudiger om algemene beeldverwerkingstechnieken uit te voeren, waarvan er één hieronder wordt geïllustreerd.

Geen vulling

Een "snelle en vuile" manier om een klein beeld naar een groter formaat te interpoleren, is door Fourier te transformeren, de Fourier-transformatie met nullen op te vullen en vervolgens de inverse transformatie te nemen. Dit interpoleert effectief tussen elke pixel met een sinc vormige basisfunctie en wordt gewoonlijk gebruikt om medische beeldvormingsgegevens met lage resolutie op te schalen. Laten we beginnen met het laden van een voorbeeld van een ingebouwde afbeelding

%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

We kunnen nu de Fourier-transformatie van I verkrijgen. Om te illustreren wat fftshift doet, laten we de twee methoden vergelijken:

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

We hebben nu de 2D FT van een voorbeeldafbeelding verkregen. Om het nul te vullen, willen we elke k-spatie nemen, de randen opvullen met nullen en dan de achterwaartse transformatie nemen:

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

Op dit punt is het resultaat tamelijk onopvallend:

Als we vervolgens de back-transforms nemen, kunnen we zien dat (correct!) Nulvullende gegevens een verstandige methode voor interpolatie bieden:

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

Merk op dat de nulgevulde afbeeldingsgrootte het dubbele is van die van het origineel. Men kan nul vullen met meer dan een factor twee in elke dimensie, hoewel dit uiteraard niet willekeurig de grootte van een afbeelding vergroot.

Hints, tips, 3D en meer

Het bovenstaande voorbeeld geldt voor 3D-beelden (zoals vaak gegenereerd door bijvoorbeeld medische beeldvormingstechnieken of confocale microscopie), maar vereist bijvoorbeeld dat fft2 wordt vervangen door fftn(I, 3) . Vanwege de ietwat omslachtige aard van het schrijven van fftshift(fft(fftshift(... meerdere keren), is het vrij gebruikelijk om functies zoals fft2c lokaal te definiëren om lokaal een betere syntaxis te bieden - zoals:

function y = fft2c(x)

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

Merk op dat de FFT snel is, maar grote, multidimensionale Fourier-transformaties zullen nog steeds tijd kosten op een moderne computer. Het is bovendien inherent complex: de grootte van k-ruimte is hierboven weergegeven, maar de fase is absoluut essentieel; vertalingen in het beelddomein zijn equivalent aan een fasehelling in het Fourier-domein. Er zijn verschillende, veel complexere bewerkingen die men zou willen doen in het Fourier-domein, zoals het filteren van hoge of lage ruimtelijke frequenties (door het te vermenigvuldigen met een filter), of discrete punten maskeren die overeenkomen met ruis. Er is dienovereenkomstig een grote hoeveelheid door de gemeenschap gegenereerde code voor het verwerken van gebruikelijke Fourier-bewerkingen beschikbaar op Matlab's belangrijkste community-repositorysite, de File Exchange .