LISTATO 1 ISTRUZIONI DI PROGRAMMA Appendice

(1)

Appendice

ISTRUZIONI DI PROGRAMMA

► LISTATO 1

Simulazione del metodo k-t BLAST su un immagine monodimensionale

solo per fattore di accelerazione 4

clear all close all clc

% Dimensione dell'immagine

N=60;

% Numero di immagini del fantoccio per la fase di training (deve essere un multiplo % di 4 per come verrà costruita l'immagine da campionare)

M=100;

% Creazione della matrice per il sottocampionamento nel k spazio con % fattore di sottocampionamento (1:4)

maschera(N,4*M)=0;

[maschera]=mask_create(N,4*M);

% Trasformazione della matrice nello spazio x-f

mascheraxt=N*ifft(maschera,[],1); mascheraxf=fft(mascheraxt,[],2)/(4*M); figure(1)

subplot(1,2,1); mesh (maschera(:,:));

title('Maschera usata per il sottocampionamento nello spazio k-t');

xlabel('Tempo'); ylabel('Vettore k'); subplot(1,2,2);

mesh (abs(mascheraxf(:,:)));

title('Maschera usata per il sottocampionamento nello spazio x-f'); xlabel('Frequanza');

(2)

% Creazione del fantoccio tenendo conto del fattore di campionamento (1:4) puppetxt=zeros(N,M); for i=1:M/4 for j=1:20+i puppetxt(j,i)=1; end end for i=M/4+1:2*M/4 for j=1:(20+M/4+1)+M/4-i puppetxt(j,i)=1; end end for i=2*M/4+1:3*M/4 for j=1:20-2*M/4+i puppetxt(j,i)=1; end end for i=3*M/4+1:M for j=1:(20+M/4+1)+(3*M/4+1)-i puppetxt(j,i)=1; end end

% Trasformazione dell'immagine nello spazio k-t

puppetxf=fft(puppetxt,[],2)/M; puppetkt=fft(puppetxt,[],1)/N;

%---Inizio fase di training---%

% Riduzione passa basso dell'immagine per simulare l'uso di solo alcune % bobine (riduzione secondo il solito fattore (1:4))

puppetkt_train=puppetkt; puppetkt_train(9:53,:)=0;

% Trasformazione dell'immagine acquisita in fase di training nello spazio x-f

puppetxt_train=N*ifft(puppetkt_train,[],1); puppetxf_train=fft(puppetxt_train,400,2)/M; figure(2)

subplot(1,2,1);

mesh(abs(puppetkt_train));

title('Successioni del fantoccio di training nello spazio k'); xlabel('Tempo');

ylabel('Vettore k'); subplot(1,2,2);

(3)

title('Successioni del fantoccio di training nello spazio x'); xlabel('Frequenza');

ylabel('Vettore x');

% Annullamento della continua che verrà poi ricavata in fase di sottocampionamento

puppetxf_train(:,1)=0;

puppetxf_train_s=sparse(puppetxf_train);

% Creazione della matrice di covarianza come matrice diagonale ricavata dal % modulo quadrato del fantoccio nello spazio xf

quadrato=abs(puppetxf_train_s).^2; diagonale=quadrato(:);

M2_xf=diag(diagonale);

%---Fine fase di training---%

% Creazione del fantoccio per la realizzazione del sottocampionameto creato % come periodicizzazione del fantoccio usato nella fase di training

appoggio=zeros(N,M*4);

for i=1:4

appoggio(:,(i-1)*M+1:i*M)=puppetkt(:,:);

end

% Sottocampionamento nello spazio k-t

aliased_puppetkt=maschera.*appoggio;

% Passaggio del fantoccio sottocampionato nello spazio x-t

aliased_puppetxt=N*ifft(aliased_puppetkt,[],1); aliased_puppetxf=fft(aliased_puppetxt,[],2)/(4*M); figure(4)

subplot(1,2,1);

mesh(abs(appoggio));

title('Successioni del fantoccio sottocampionato nello spazio k'); xlabel('Tempo');

ylabel('Vettorek'); subplot(1,2,2);

mesh(abs(aliased_puppetxt));

title('Successioni del fantoccio sottocampionato nello spazio x'); view([0,90]);

xlabel('Tempo'); ylabel('Vettorex');

(4)

% Calcolo del valore medio su sulle varie repliche sottocampionate

average_puppetkt=mean(aliased_puppetkt,2); average_puppetkt=sum(aliased_puppetkt,2)/M;;

% Definizione dello scarto per ogni replica temporale tra il valore assunto % ed il valore medio

for i=1:4*M

delta_puppetkt(:,i)=aliased_puppetkt(:,i)-average_puppetkt;

end

% Trasformazione dello scarto nello spazio x-f

delta_puppetxt=N*ifft(delta_puppetkt,[],1); delta_puppetxf=fft(delta_puppetxt,[],2)/(4*M);

% Trasformazione del valore medio nello spazio x-f

average_puppetxt=N*ifft(average_puppetkt,[],1);

%---Applicazione metodo k-t BLAST---%

% Applicazione della relazione della k-t BLAST

extimated_puppet=zeros(N,4*M); average=zeros(24000,1); average(1:60,1)=average_puppetxt; aliased_puppetxf=aliased_puppetxf(:); average=sparse(average); extimated_puppet=sparse(24000,24000); delta_puppetxf=sparse(delta_puppetxf(:)); for j=1:4*M for i=1:N unos=posizione(i,j,N,4*M); extimated_puppet(:,(i+(j-1)*N))= average+(M2_xf*unos'*pinv (unos*M2_xf*unos'))*delta_puppetxf(i+(j-1)*N); end end

%ora bisogna ricomporre le stime

a=sum(extimated_puppet,2); %la continua è presente in tutte le stime

a(1:N)=a(1:N)/(4*M*N); a(N+1:end)=a(N+1:end); b=reshape(a,N,4*M); c=4*M*ifft(full(b),[],2); figure mesh(real(c)) figure imagesc(abs(c)) figure

(5)

mesh(real(ifft(appoggio,[],1))); figure imagesc(abs(ifft(appoggio,[],1))); figure(5) subplot(2,2,1); mesh(abs(ifft(appoggio,[],1))); title('Fantoccio originale'); view([0,90]); xlabel('Tempo') ylabel('Vettore x'); subplot(2,2,2); mesh(abs(aliased_puppetkt));

title('Fantoccio sottocampionato nello spazio k'); xlabel('Tempo')

% mesh(abs(final_padded)); mesh(real(c))

title('Fantoccio ricostruito tramite k-t BLAST'); view([0,90]);

xlabel('Tempo') ylabel('Vettore x'); subplot(2,2,3);

mesh(abs(aliased_puppetxt));

title('Fantoccio sottocampionato nello spazio x'); view([0,90]);

xlabel('Tempo') ylabel('Vettore x');

(6)

►LISTATO 2

Simulazione metodo k-t BLAST su immagine bidimensionale

close all clear all load immagine_64.mat phantom=imvol_64; phantom=80*phantom/max(max(max(phantom))); %gaussian kernel Dim=[5 5]; FWHM = 3; sig = FWHM/sqrt(8*log(2)); [x2d,y2d] = meshgrid(-(Dim(2)-1)/2:(Dim(2)-1)/2,-(Dim(1)-1)/2:(Dim(1)-1)/2); gf = exp(-(x2d.*x2d + y2d.*y2d)/(2*sig*sig)); gf = gf/sum(sum(gf)); figure(1) bar3(gf,'r');

axis([0 Dim(1) 0 Dim(2) 0 max(gf(:))*1.2]) axis xy

%creazione maschere per l’attivazione

mask1=zeros(64,64,36); mask2=mask1; mask3=mask1; mask4=mask1; mask1(20:25,20:25,20)=1; mask2(40:45,40:45,20)=0; mask3(12:16,33:37,20)=0; mask4(25:29,12:16,20)=0; mask1(:,:,20)=filter2(gf,mask1(:,:,20)); mask2(:,:,20)=filter2(gf,mask2(:,:,20)); mask3(:,:,20)=filter2(gf,mask3(:,:,20)); mask4(:,:,20)=filter2(gf,mask4(:,:,20)); phases=80; Tr=3; T0=30; t_on=15;

(7)

[err,para]=create_para(phases,Tr,T0,t_on); figure(2) plot(para) [err,para]=convol_hemo(para); act_m1=0.02; act_m2=0.02; act_m3=0.01; act_m4=0.005; noise=0.33; phantom_series=zeros(64,64,36,phases); phantom_series1=zeros(64,64,36,phases); for i=1:phases, temp=phantom+act_m1*mask1.*phantom*para(i)+act_m2*mask2.*phantom*para(i)+.. act_m3*mask3.*phantom*para(i)+act_m4*mask4.*phantom*para(i)+ (noise*randn(64,64,36)+1); phantom_series(:,:,:,i)=temp; end; noise1=0; for i=1:phases, temp=phantom+act_m1*mask1.*phantom*para(i)+act_m2*mask2.*phantom*para(i)+.. act_m3*mask3.*phantom*para(i)+act_m4*mask4.*phantom*para(i)+ (noise1*randn(64,64,36)+1); phantom_series1(:,:,:,i)=temp; end;

puppetxyt1=squeeze(phantom_series1(:,:,20,:)); %serie di immagini senza rumore

fetta=squeeze(phantom_series(:,:,20,50)); figure(3)

imagesc(fetta);

puppetxyt=squeeze(phantom_series(:,:,20,:)); %serie delle mie immagini matr. fetta 2 % Dimensione dell'immagine

N=64;

% Numero di immagini del fantoccio per la fase di training (deve essere un multiplo % di 4 per come verrà costruita l'immagine da campionare)

(8)

maschera(N,M)=0;

[maschera]=mask_create4x(N,M); acc=4;

mascheraxt=N*ifft(maschera,[],1); mascheraxf=fft(mascheraxt,[],2)/M; figure(4)

subplot(1,2,1); mesh (maschera(:,:));

title('Maschera usata per il sottocampionamento nello spazio k-t'); xlabel('Tempo');

%% intensità dell'immagine 64x64x80

I1=sum(sum(sum(puppetxyt(:,:,:)))); I=I1/(N*N*M);

puppetxyf=fft(puppetxyt,[],3)/M;

puppetkt1=fft(puppetxyt,[],1)/N; % Kx, y ,t puppetkt2=fft(puppetkt1,[],2)/N; % Kx, Ky, t X=puppetkt2(:,:,50); %fetta al tempo 50: Kx, Ky

fettakt=squeeze(X);

Z1=puppetkt2(:,32,:); %array Kx-t per Ky=32

Z2=squeeze(Z1); figure(5) subplot(1,2,1) mesh(abs(fettakt)); title('fetta Kx-Ky'); subplot(1,2,2) mesh(abs(Z2)); title('fetta Kx-t');

%--- inizio fase di training ---%

(9)

puppetkt_train=puppetkt2; puppetkt_train(9:57,:,:)=0;

puppetxkt_train=N*ifft(puppetkt_train,[],1);% x, Ky , t puppetxyt_train=N*ifft(puppetxkt_train,[],2);% x, y , t puppetxyf_train=fft(puppetxyt_train,[],3)/M; % x, y , f fettaxyt_train=squeeze(puppetxyt_train(:,:,50)); fettaxyf_train=squeeze(puppetxyf_train(:,:,50)); figure(6) subplot(1,2,1); imagesc(abs(fettaxyt_train));

title('fetta dopo il filtraggio passa basso xyt'); xlabel('vettore x'); ylabel('vettore y'); subplot(1,2,2); imagesc(fetta); title('fetta originale'); xlabel('vettore x'); ylabel('vettore y'); figure(7) mesh(abs(fettaxyf_train));

title('fetta dopo il filtraggio passa basso xyf'); xlabel('vettore x'); ylabel('Vettore y'); % array x-t for i=1:N X4=puppetxyt_train(:,i,:); puppetxt_train=squeeze(X4); puppetxf_train=fft(puppetxt_train,80,2)/M;

% Annullamento della continua che verrà poi ricavata in fase di % sottocampionamento

puppetxf_train(:,1)=0;

quadrato=abs(puppetxf_train).^2; diagonale=quadrato(:);

M_xf(:,i)=diagonale;

end

(10)

% Sottocampionamento nello spazio k-t for i=1:N X7=puppetkt2(:,i,:); X8=squeeze(X7); aliased=maschera.*X8; aliased_puppetkt(:,i,:)=aliased; end aliased_puppetxkt=N*ifft(aliased_puppetkt,[],1); aliased_puppetxyt=N*ifft(aliased_puppetxkt,[],2); aliased_puppetxyf=fft(aliased_puppetxyt,[],3)/M; X9=aliased_puppetxyt(:,:,50); Y1=squeeze(X9); figure(9) imagesc(abs(Y1));

title('risultato del sottocampionamento su una fetta'); xlabel('vettore x');

ylabel('Vettore y');

% Calcolo del valore medio sulle varie repliche sottocampionate

for i=1:N Y2=aliased_puppetkt(:,i,:); Y3=squeeze(Y2); average=mean(Y3,2); average=sum(Y3,2)/M; average_puppetkt(:,i)=average; % Kx, Ky end average_puppetxk=N*ifft(average_puppetkt,[],1); average_puppetxy=N*ifft(average_puppetxk,[],2); % 64x64 figure(10) imagesc(abs(average_puppetxy));

title('fetta risultante dalla media temporale')

% Definizione dello scarto per ogni replica temporale tra il valore assunto % ed il valore medio for i=1:M X5=aliased_puppetkt(:,:,i); X6=squeeze(X5); for j=1:N delta(:,j)=X6(:,j)-average_puppetkt(:,j); end delta_puppetkt(:,:,i)=delta; end

(11)

delta_puppetxyt=N*ifft(delta_puppetxkt,[],2); delta_puppetxyf=fft(delta_puppetxyt,[],3)/M; Z5=delta_puppetxyt(:,:,50);

Z6=squeeze(Z5);

%---applicazione metodo K-t BLAST---%

extimated_puppet1=zeros(N,M); average1=zeros(5120,1);

extimated_puppet1=sparse(5120,5120);

for k=1:64

X6=delta_puppetxyf(:,k,:); %prendo una colonna per volta 64x80 X7=squeeze(X6);

delta_puppetxf=sparse(X7(:));

Y6=average_puppetxy(:,k); %ogni colonna è la media relativa a una Y7=squeeze(Y6); %fetta 64x80 average1(1:64,1)=Y7; average1=sparse(average1); M1=M_xf(:,k); M2=sparse(M1); M2_xf=diag(M2); for j=1:M for i=1:N unos=posizione_4x_80(i,j,N,M); extimated_puppet1(:,(i+(j-1)*N))=average1+(M2_xf*unos'*pinv (unos*M2_xf*unos'+0.33))*delta_puppetxf(i+(j-1)*N); end end

a=sum(extimated_puppet1,2); a(1:N)=a(1:N)/(M*N);

%la continua è presente in tutte le stime

a(N+1:end)=a(N+1:end); b=reshape(a,N,M); c=M*ifft(full(b),[],2); extimated_puppet(:,k,:)=c; end Z7=extimated_puppet(:,:,50); Z8=squeeze(Z7);

% sottraggo imm. vera da imm. ric. per ogni time frame per la zona attiva

S=acc*extimated_puppet(20:25,20:25,:)-puppetxyt(20:25,20:25,:); S1=acc*extimated_puppet(20:25,20:25,:)-puppetxyt1(20:25,20:25,:); Sq=abs(S).^2;

(12)

Sq1=abs(S1).^2; z_attiva=zeros(6,6);

for i=1:6 for j=1:6

Er=sum(Sq(i,j,:))/M; %errore nel tempo

z_attiva(i,j)=Er; end

end

Err1=sum(sum(sum(Sq1)))/(6*6*M); % calcolo errore sulle intensità,

Err=sum(sum(sum(Sq)))/(6*6*M); % solo per la zona attiva introducendo la normalizzazione figure(12) subplot(1,2,1); imagesc(abs(Z8)); subplot(1,2,2); imagesc(abs(squeeze(puppetxyt(:,1:30,50)))); figure(13)

plot(abs(squeeze(extimated_puppet(23:23,23:23,:)*acc))); %guardo un solo pixel

hold on % nel tempo all'interno della zona di attivazione

plot(squeeze(puppetxyt(23:23,23:23,:)),'r'); %normalizzo moltiplicando per il fattore di accelerazione

title('andamento intensità nel tempo, r=originale') figure(15)

(13)

►LISTATO 3

Simulazione caso reale di immagine celebrale

close all clear all load dati.mat phantom=V_serie; figure(1) mesh(phantom) matrix_tras=phantom'; immagine=reshape(matrix_tras,[64,64,100]); imm_50=squeeze(immagine(:,:,50)); figure(2) subplot(1,2,1) imagesc(imm_50) subplot(1,2,2) mesh(imm_50) % Dimensione dell'immagine N=64;

% Numero di immagini per la fase di training

M=100;

%intensità media immagine

I1=sum(sum(sum(immagine))); I=I1/(N*N*M);

%per vedere la zona di attivazione (cioè i pixel che si attivano),

%le relative coordinate e l'andamento nel tempo c'è l'apposito programma % ATTIVAZIONE.m

maschera(N,M)=0;

[maschera]=mask_create4x(N,M); acc=4;

mascheraxt=N*ifft(maschera,[],1); mascheraxf=fft(mascheraxt,[],2)/M;

(14)

figure(4) subplot(1,2,1); mesh (maschera(:,:));

title('Maschera usata per il sottocampionamento nello spazio k-t'); xlabel('Tempo');

%VARIANZA DEL RUMORE

for i=1:N for j=1:N imm_media(i,j)=sum(immagine(i,j,:))/M; end end for k=1:M imm_sott(:,:,k)=immagine(:,:,k)-imm_media(:,:); end zona=imm_sott(35:40,35:40,:); for i=1:6 for j=1:6 varianza((i-1)*6+j)=var(zona(i,j,:)); end end var_media=sum(varianza)/36;

%%rapporto segnale rumore SNR

DS=sqrt(varianza); SNR=I/DS;

immag_xyf=fft(immagine,[],3)/M;

immag_kt1=fft(immagine,[],1)/N; % Kx, y ,t immag_kt2=fft(immag_kt1,[],2)/N; % Kx, Ky, t fettakt=squeeze(immag_kt2(:,:,50));

Z1=squeeze(immag_kt2(:,32,:)); %array Kx-t per Ky=32

figure(5) subplot(1,2,1) mesh(abs(fettakt)); title('fetta Kx-Ky'); subplot(1,2,2) mesh(abs(Z1));

(15)

title('fetta Kx-t');

%---inizio fase di training--- %

immag_kt_train=immag_kt2; immag_kt_train(9:57,:,:)=0;

immag_xkt_train=N*ifft(immag_kt_train,[],1);% x, Ky , t immag_xyt_train=N*ifft(immag_xkt_train,[],2);% x, y , t immag_xyf_train=fft(immag_xyt_train,[],3)/M; % x, y , f fettaxyt_train=squeeze(immag_xyt_train(:,:,50)); fettaxyf_train=squeeze(immag_xyf_train(:,:,50)); figure(6) subplot(1,2,1); imagesc(abs(fettaxyt_train));

title('fetta dopo il filtraggio passa basso xyt'); xlabel('vettore x'); ylabel('vettore y'); subplot(1,2,2); imagesc(imm_50); title('fetta originale'); xlabel('vettore x'); ylabel('vettore y'); figure(7) mesh(abs(fettaxyf_train));

title('fetta dopo il filtraggio passa basso xyf'); xlabel('vettore x'); ylabel('Vettore y'); % array x-t for i=1:N X4=immag_xyt_train(:,i,:); immag_xt_train=squeeze(X4); immag_xf_train=fft(immag_xt_train,100,2)/M;

% Annullamento della continua che verrà poi ricavata in fase di sottocampionamento

immag_xf_train(:,1)=0;

quadrato=abs(immag_xf_train).^2; diagonale=quadrato(:);

(16)

end

%---fine fase di training ---%

% Sottocampionamento nello spazio k-t

for i=1:N X7=immag_kt2(:,i,:); X8=squeeze(X7); aliased=maschera.*X8; alias_imm_kt(:,i,:)=aliased; end alias_imm_xkt=N*ifft(alias_imm_kt,[],1); alias_imm_xyt=N*ifft(alias_imm_xkt,[],2); alias_imm_xyf=fft(alias_imm_xyt,[],3)/M; %64x64x100 figure(9) imagesc(abs(squeeze(alias_imm_xyt(:,:,50))); title('risultato del sottocampionamento su una fetta'); xlabel('vettore x');

ylabel('Vettore y');

% Calcolo del valore medio sulle varie repliche sottocampionate

for i=1:N Y2=alias_imm_kt(:,i,:); Y3=squeeze(Y2); average=mean(Y3,2); average=sum(Y3,2)/M; average_imm_kt(:,i)=average; % Kx, Ky end average_imm_xk=N*ifft(average_imm_kt,[],1); average_imm_xy=N*ifft(average_imm_xk,[],2); % 64x64 figure(10) imagesc(abs(average_imm_xy));

title('fetta risultante dalla media temporale')

% Definizione dello scarto per ogni replica temporale tra il valore assunto % ed il valore medio for i=1:M X5=alias_imm_kt(:,:,i); X6=squeeze(X5); for j=1:N delta(:,j)=X6(:,j)-average_imm_kt(:,j); end delta_imm_kt(:,:,i)=delta; end

(17)

delta_imm_xyt=N*ifft(delta_imm_xkt,[],2); delta_imm_xyf=fft(delta_imm_xyt,[],3)/M;

%---applicazione metodo K-t BLAST---%

extimated_imm1=zeros(N,M); average1=zeros(6400,1);

extimated_imm1=sparse(6400,6400);

for k=1:N

X6=delta_imm_xyf(:,k,:); %prendo una colonna per volta 64x100

X7=squeeze(X6);

delta_imm_xf=sparse(X7(:));

Y6=average_imm_xy(:,k); %ogni colonna è la media relativa a una

Y7=squeeze(Y6); %fetta 64x100 average1(1:64,1)=Y7; average1=sparse(average1); M1=M_xf(:,k); M2=sparse(M1); M2_xf=diag(M2); for j=1:M for i=1:N unos=posizione_4x_100(i,j,N,M); extimated_imm1(:,(i+(j-1)*N))=average1+(M2_xf*unos'*pinv (unos*M2_xf*unos'+varianza))*delta_imm_xf(i+(j-1)*N); end end

a=sum(extimated_imm1,2); a(1:N)=a(1:N)/(M*N);

%la continua è presente in tutte le stime

a(N+1:end)=a(N+1:end); b=reshape(a,N,M); c=M*ifft(full(b),[],2); extimated_imm(:,k,:)=c; end Z7=extimated_imm(:,:,50);

% sottraggo imm. vera da imm. ric. per ogni time frame

S=acc*extimated_imm(:,:,:)-immagine(:,:,:); Squad=abs(S).^2; E1=sum(sum(sum(Squad))); E=E1/(N*N*M); Err=sum(Squad(37,38,:))/M; figure(12) subplot(1,2,1); imagesc(abs(Z8));

(18)

subplot(1,2,2);

imagesc(abs(squeeze(immagine(:,:,50)))); figure(13)

plot(abs(squeeze(acc*extimated_imm(37:37,38:38,:)))); %guardo un solo pixel

hold on % nel tempo nella zona attiva

plot(squeeze(immagine(37:37,38:38,:)),'r'); title('andamento intensità nel tempo')

figure(14)