Skip to content
Snippets Groups Projects
Commit bf174abf authored by Marina Kreme's avatar Marina Kreme
Browse files

unnecessary file deletion

parent ff79a416
No related branches found
No related tags found
No related merge requests found
Show whitespace changes
Inline Side-by-side
Showing
with 0 additions and 668 deletions
matlab/tfgm/scripts/combmul_norm.m deleted 100644 → 0
+ 0
− 145
View file @ ff79a416
function mul1mul2_norms = combmul_norm(areas_lim, t_shifts, f_shifts, win_type)
%This fonction computes the operator norm of the combination
%of two Gabor multipliers
% Inputs:
% - areas_lim: real number array
% - t_shifts, f_shifts: real number array
% - win_type: analysis windox type
% Outputs:
% - mul1mul2_norms:operators norms of two Gabor multiplier
%
% Author: Marina KREME
%%
pwd;
fig_dir ='combinaisonMult';
if ~exist('combinaisonMult','dir')
mkdir('combinaisonMult');
end
addpath('combinaisonMult')
%%
sig_len = 1024;
fs = 1;
win_len = 64;
hop = 1 ;
nbins = win_len * 2;
dgt_params = generate_dgt_parameters(win_type, win_len, hop, nbins, sig_len);
signal_params = generate_signal_parameters(fs, sig_len);
%% plot window
figure;
plot_win(dgt_params.win, signal_params.fs, signal_params.sig_len, dgt_params.win_type);
title([num2str(win_type),'\_window.png'])
saveas(gcf,fullfile(fig_dir,[num2str(win_type),'_window_L' num2str(sig_len), '.png']));
%% Generate rectangular mask
mask1 = generate_rectangular_mask(dgt_params.('nbins'), dgt_params.('hop'),....,
signal_params.('sig_len'), areas_lim.('t_lim'), areas_lim.('f_lim'));
[dgt, idgt]= get_stft_operators(dgt_params, signal_params);
mul1 = gen_gabmul_operator(dgt, idgt, mask1);
mul1mul2_norms = zeros(length(f_shifts),length(t_shifts));
%%
for i_t = 1:length(t_shifts)
dt = t_shifts(i_t);
for i_f = 1: length(f_shifts)
df = f_shifts(i_f);
mask2= generate_rectangular_mask(dgt_params.nbins, dgt_params.hop,....,
signal_params.sig_len, areas_lim.('t_lim')+dt, areas_lim.('f_lim')+df);
full_mask = or(mask1, mask2);
mul2 = gen_gabmul_operator(dgt, idgt, mask2);
ev = eigs(@(x)mul1(mul2(x)), signal_params.sig_len, 1);
mul1mul2_norms(i_f, i_t) = real(ev);
figure;
subplot(121)
plot_mask(full_mask, dgt_params.hop, dgt_params.nbins, signal_params.fs);
title({['Mask ' num2str(win_type) ],['dt = ' num2str(dt)],['df =',num2str(df)],['norm = ' num2str(mul1mul2_norms(i_f, i_t),'%.2e')]});
subplot(122)
mask_proj = dgt(idgt(double(full_mask)));
plot_spectrogram(mask_proj, dgt_params, signal_params, dgt);
title('dgt(idgt(mask))')
saveas(gcf,fullfile(fig_dir,['mask_' num2str(win_type) 'dt_' num2str(dt) 'df_',num2str(df),'.png']));
end
end
%%
figure;
step_t = t_shifts(2) - t_shifts(1);
step_f = f_shifts(2) - f_shifts(1);
extent = [t_shifts(1)-step_t/2, t_shifts(end)+step_t/2, f_shifts(1)-step_f/2, f_shifts(end)+step_f/2];
imagesc(real(log10(mul1mul2_norms)),'XData', extent(1:2), 'YData', extent(3:4),'CDataMapping','scaled');
colorbar()
xlabel('t shift')
ylabel('f shift')
title(win_type)
saveas(gcf,fullfile(fig_dir,['mul1mul2_norms_' num2str(win_type), '.png']));
%%
figure;
for i=1: length(t_shifts)
txt = ['dt =' num2str(t_shifts(i))];
semilogy(f_shifts, mul1mul2_norms(:, i), 'LineWidth',2.5,'DisplayName',txt);
hold on
xlabel('f shift')
title(win_type)
grid('on');
set(gca, 'FontSize', 15, 'fontName','Times');
axis tight;
saveas(gcf,fullfile(fig_dir,['mul1mul2_norms_' num2str(win_type), '_f.png']));
end
legend show;
%%
figure;
for i=1: length(f_shifts)
txt = ['df =' num2str(f_shifts(i))];
plot(t_shifts, mul1mul2_norms(i, :),'LineWidth',2.5 ,'DisplayName',txt);
hold on;
xlabel('t shift')
title(win_type)
grid('on');
set(gca, 'FontSize', 15, 'fontName','Times');
set(gca, 'YScale','log');
axis tight;
saveas(gcf,fullfile(fig_dir,['mul1mul2_norms_' num2str(win_type), '_t.png']));
end
hold off
legend show;
end
matlab/tfgm/scripts/compare_win.m deleted 100644 → 0
+ 0
− 93
View file @ ff79a416
clc; clear; close all;
%%
%Comparison of hann vs gauss window size
%%
pwd;
fig_dir ='fig_compare_win';
if ~exist('fig_compare_win','dir')
mkdir('fig_compare_win');
end
addpath('fig_compare_win')
%%
win_list = {{'gauss',128}, {'hann',128}, {'hann',256}};
sig_len = 16384;
fs = 8000;
dgt_params= struct();
for k=1:length(win_list)
win_type = win_list{k}{1};
win_len = win_list{k}{2};
hop = win_len/4;
nbins = win_len * 4;
dgt_params.([win_type, num2str(win_len)]) = generate_dgt_parameters(win_type, win_len, hop, nbins, sig_len);
end
%%
signal_params = generate_signal_parameters(fs, sig_len);
% %%
%
figure;
%set(gcf,'position',[1, 1 1100 400]);
subplot(221)
h = cell(3,1);
for k=1:length(win_list)
win_type = win_list{k}{1};
win_len = win_list{k}{2};
win = dgt_params.([win_type, num2str(win_len)]).win;
plot_win(win, signal_params.fs, sig_len, win_type);
h{k} = [num2str(win_type), ' - ',num2str(win_len)];
hold on;
end
xlim([-win_len / fs, win_len / fs]);
legend (h)
hold off
%%
dynrange=10;
for k=1:length(win_list)
subplot(2,2,k+1)
win_type = win_list{k}{1};
win_len = win_list{k}{2};
[dgt, idgt] = get_stft_operators( dgt_params.([win_type, num2str(win_len)]), signal_params);
M = dgt_params.([win_type, num2str(win_len)]).nbins/2+1;
N = sig_len/dgt_params.([win_type, num2str(win_len)]).hop;
mask = zeros(M,N);
gab_mul = gen_gabmul_operator(dgt, idgt, mask);
plot_ambiguity_function(dgt_params.([win_type, num2str(win_len)]).win,...,
dgt ,dgt_params.([win_type, num2str(win_len)]), signal_params,dynrange);
hold on;
title([num2str(win_type),' - ' num2str(win_len)])
ylim([0, 90])
end
subplot(2, 2, 2)
xlim([1.005, 1.045])
subplot(2, 2, 3)
xlim([0.015, 0.055])
subplot(2, 2, 4)
xlim([0.045, 0.085])
saveas(gcf,fullfile(fig_dir, 'compare_win_ambig_functions.pdf'));
matlab/tfgm/scripts/gabmul_eig_dgtvar.m deleted 100644 → 0
+ 0
− 151
View file @ ff79a416
clc; clear; close all
%%
%Study and comparison of EVD computation times obtained by random vs.
%eigs projection methods
%%
param_list = cell(4,1);
for i =0:4
sig_len = 256*4^i;
win_len = 8*2^i;
hop = 2*2^i;
nbins = 32*2^i;
param_list{i+1}= struct('sig_len',sig_len,'win_len',win_len,'hop',hop,'nbins',nbins);
end
fprintf("Parameters: \n");
disp(param_list{1});
fprintf("**************\n");
disp(param_list{2});
fprintf("**************\n");
disp(param_list{3});
fprintf("**************\n");
disp(param_list{4});
%%
areas_lim = struct('t_lim', [0.3, 0.7], 'f_lim', [0.1, 0.3]);
win_type = 'hann';
fs=1;
%% random eigs
tolerance = 1e-2;
proba = 1-1e-4;
%%
% figure directory
pwd;
fig_dir ='gabmul_eig_dgtvar';
if ~exist('gabmul_eig_dgtvar','dir')
mkdir('gabmul_eig_dgtvar');
end
addpath('gabmul_eig_dgtvar')
% initialisations
t_arrf = zeros(length(param_list),1);
t_rrf = zeros(length(param_list),1);
t_evdn = zeros(length(param_list),1);
t_eigs = zeros(length(param_list),1);
ranks = zeros(length(param_list),1);
%%
for i = 1: length(param_list)-1
%%
sig_len = param_list{i}.('sig_len');
fs=1;
win_len = param_list{i}.('win_len');
hop = param_list{i}.('hop');
nbins = param_list{i}.('nbins');
fprintf("****************************************\n");
fprintf("Signal length: %.f\n", sig_len);
%% dgt params, signals prams,plot window
dgt_params = generate_dgt_parameters(win_type, win_len, hop, nbins, sig_len);
signal_params = generate_signal_parameters(fs, sig_len);
% figures
% window
figure;
plot_win(dgt_params.win, signal_params.fs, dgt_params.win_type);
title([num2str(win_type),'_window.png'])
saveas(gcf,fullfile(fig_dir,[num2str(win_type),'_window_L' num2str(sig_len), '.png']));
%% mask, gabor multiplier
% mask
mask = generate_rectangular_mask(dgt_params.('nbins'), dgt_params.('hop'),....,
signal_params.('sig_len'),areas_lim.('t_lim'), areas_lim.('f_lim'));
%%
[dgt, idgt] = get_stft_operators(dgt_params, signal_params);
gab_mul = gen_gabmul_operator(dgt, idgt, mask);
% figure mask
figure;
plot_mask(mask, dgt_params.hop, dgt_params.nbins, signal_params.fs);
title('Mask')
saveas(gcf,fullfile(fig_dir,['mask_L_' num2str(sig_len), '.png']));
%% ambiguity function
figure;
dynrange=90;
plot_ambiguity_function(dgt_params.win, dgt, dgt_params, signal_params, dynrange)
title(['Ambiguity function - ', num2str(win_type)]);
saveas(gcf,fullfile(fig_dir,[ num2str(win_type) '_ambiguity_L_' num2str(sig_len), '.png']));
%% evd parameters
r = compute_r(sig_len, sig_len, proba);
%% compute evd
tic;
Q = adaptative_randomized_range_finder(gab_mul, sig_len, tolerance, r);
t_arrf(i) =toc;
tic;
Q_ = randomized_range_finder(gab_mul, sig_len, size(Q,2));
t_rrf(i) = toc;
tic;
res_evdn = EVD_nystrom(gab_mul, Q);
t_evdn(i) = toc;
tic;
res_eigs = EVD_eigs(gab_mul, sig_len, size(Q,2));
t_eigs(i) = toc;
%% set ranks
ranks(i) = size(Q,2);
%% print
fprintf('adaptive_randomized_range_finder: %.2f secondes\n',t_arrf(i));
fprintf('randomized_range_finder: %.2f secondes\n', t_rrf(i));
fprintf('evd_nystrom: %.2f secondes\n',t_evdn(i));
fprintf('adaptive_randomized_range_finder+evd_nystrom: %.2f secondes\n ',....,
t_arrf(i)+t_evdn(i));
fprintf('randomized_range_finder+evd_nystrom: %.2f secondes\n', t_rrf(i)+t_evdn(i));
fprintf('eigs: %.2f\n',t_eigs(i));
fprintf('rank: %.2f\n',ranks(i));
end
save('gabmul_eig_dgtvar.mat', 't_arrf','t_rrf','t_evdn','t_eigs','ranks','param_list');
matlab/tfgm/scripts/poc_gabmul_randsvd.m deleted 100644 → 0
+ 0
− 96
View file @ ff79a416
clc; clear; close all;
%%
pwd;
fig_dir ='fig_poc_gabmul_randsvd';
if ~exist('fig_poc_gabmul_randsvd','dir')
mkdir('fig_poc_gabmul_randsvd');
end
addpath('fig_poc_gabmul_randsvd')
%%
areas_lim = struct('t_lim',[0.1, 0.15], 'f_lim',[0.2, 0.25]);
win_type = 'hann';
sig_len = 8192;
fs = 1;
win_len = 512;
hop = 32 ;
nbins = win_len * 4;
dgt_params = generate_dgt_parameters(win_type, win_len, hop, nbins, sig_len);
%%
signal_params = generate_signal_parameters(fs, sig_len);
[dgt, idgt] = get_stft_operators(dgt_params, signal_params);
%% window
figure;
plot_win(dgt_params.win, signal_params.fs, signal_params.sig_len, dgt_params.win_type);
title([num2str(win_type),'\_window.png'])
%% mask -gabmul
mask = generate_rectangular_mask(dgt_params.nbins, dgt_params.hop,....,
signal_params.sig_len,areas_lim.t_lim, areas_lim.f_lim);
gab_mul = gen_gabmul_operator(dgt, idgt, mask);
fprintf('Gabor multiplier with shape (%.f %.f) \n', signal_params.sig_len,signal_params.sig_len );
%% figure mask
figure;
plot_mask(mask, dgt_params.hop, dgt_params.nbins, signal_params.fs);
title('Mask')
saveas(gcf,fullfile(fig_dir,['mask' num2str(sig_len), '.png']));
%% ambiguity function
figure;
dynrange=90;
plot_ambiguity_function(dgt_params.win, dgt, dgt_params,signal_params, dynrange);
title(['Ambiguity function - ', num2str(win_type)]);
saveas(gcf,fullfile(fig_dir,[ num2str(win_type) '_ambiguity_L_' num2str(sig_len), '.png']));
%% evd parameters
proba = 0.99;
tolerance =1e-3;
r = compute_r(sig_len, sig_len, proba);
%% compute evd
tic;
Q = adaptative_randomized_range_finder(gab_mul, sig_len, tolerance, r);
t_arrf =toc;
tic;
Q_ = randomized_range_finder(gab_mul, sig_len, size(Q,2));
t_rrf = toc;
tic;
res_evdn = EVD_nystrom(gab_mul, Q);
t_evdn = toc;
tic;
res_eigs = EVD_eigs(gab_mul, sig_len, size(Q,2));
t_eigs = toc;
%%
fprintf('adaptive_randomized_range_finder: %.2f secondes\n',t_arrf);
fprintf('randomized_range_finder: %.2f secondes\n', t_rrf);
fprintf('evd_nystrom: %.2f secondes\n',t_evdn);
fprintf('adaptive_randomized_range_finder + evd_nystrom: %.2f secondes\n ',....,
t_arrf+t_evdn);
fprintf('randomized_range_finder + evd_nystrom: %.2f secondes\n', t_rrf+t_evdn);
fprintf('eigs: %.2f secondes\n',t_eigs);
%%
figure;
semilogy(diag(res_evdn.D));
grid('on');
title('Rand SVD: eigenvalues');
saveas(gcf,fullfile(fig_dir,['eigenvalues_' num2str(win_type), '.png']));
matlab/tfgm/scripts/run_combmul.m deleted 100644 → 0
+ 0
− 20
View file @ ff79a416
clc; clear; close all;
%% test of spectral norm of the combination of two multipliers.
t_shifts = 0:0.1:0.7;
f_shifts = 0: 0.1:0.6;
areas_lim = struct('t_lim', [0.1, 0.2], 'f_lim', [0.2, 0.3]);
win_type = {'hann','gauss'};
%%
for i = 1:length(win_type)
%%
res = combmul_norm(areas_lim, t_shifts, f_shifts, win_type{i});
end
matlab/tfgm/scripts/run_show_rect_masks.m deleted 100644 → 0
+ 0
− 21
View file @ ff79a416
clc; clear; close all;
%%
areas_lim1 = {struct('t_lim', [0.1, 0.5], 'f_lim', [0.2, 0.3])};
areas_lim2 = {struct('t_lim', [0.1, 0.5], 'f_lim', [0.2, 0.3]),...,
struct('t_lim', [0.4, 0.8], 'f_lim', [0.5, 0.7])};
%%
win_type = {'hann','gauss'};
for i =1 : length(win_type)
%%
masks1 = show_rect_masks(areas_lim1, win_type{i});
masks2 = show_rect_masks(areas_lim2, win_type{i});
%%
end
matlab/tfgm/scripts/script_wins.m deleted 100644 → 0
+ 0
− 49
View file @ ff79a416
clc; clear; close all;
%%
sig_len = 16384;
fs = 8000;
signal_params = generate_signal_parameters(fs, sig_len);
settings = {struct('win_type','gauss','approx_win_len',128,'nbins',128*4,'hop',...,
128/4,'sig_len',sig_len), struct('win_type','gauss','approx_win_len',256,'nbins',256*4,'hop',...,
256/4,'sig_len',sig_len), struct('win_type','gauss','approx_win_len',512,'nbins',512*4,'hop',...,
512/4,'sig_len',sig_len),struct('win_type','hann','approx_win_len',256,'nbins',128*2,'hop',...,
128/8,'sig_len',sig_len), struct('win_type','hann','approx_win_len',512,'nbins',256*2,'hop',...,
256/8,'sig_len',sig_len), struct('win_type','hann','approx_win_len',1024,'nbins',512*2,'hop',...,
512/8,'sig_len',sig_len)};
%
%%
for k =1:length(settings)
params = settings{k};
dgt_params = generate_dgt_parameters(params.win_type, params.approx_win_len,...,
params.hop, params.nbins, sig_len);
[dgt, idgt] = get_stft_operators(dgt_params, signal_params);
m = zeros(params.nbins/2+1, sig_len/params.hop);
g = gen_gabmul_operator(dgt, idgt, m);
figure;
dynrange=30;
plot_ambiguity_function(dgt_params.win, dgt , dgt_params, signal_params, dynrange)
dx = 0.1;
switch params.win_type
case 'gauss'
xlim([1 - dx, 1 + dx])
case 'hann'
xlim([0.1 - dx, 0.1 + dx])
end
ylim([0, 100])
title([params.win_type, params.approx_win_len, num2str(std(dgt_params.win)) {} {}'])
end
matlab/tfgm/scripts/show_rect_masks.m deleted 100644 → 0
+ 0
− 93
View file @ ff79a416
function masks = show_rect_masks(areas_lim, win_type)
%%
% masks = show_rect_masks(areas_lim, win_type)
% Generate rectangular mask and compute its ambiguity function
%
%Inputs:
% - areas_lim: array- allow to select the rectangle
% - win_type: analysis window type (hann/gauss)
%Output:
% - masks: mask
%
%Author : Marina KREME
%%
pwd;
fig_dir ='fig_rect_masks';
if ~exist('fig_rect_masks','dir')
mkdir('fig_rect_masks');
end
addpath('fig_rect_masks')
%%
sig_len = 1024;
fs = 1;
win_len = 32;
hop = 1 ;
nbins = win_len * 2;
approx_win_len = win_len;
dgt_params = generate_dgt_parameters(win_type, approx_win_len, hop, nbins, sig_len);
signal_params = generate_signal_parameters(fs, sig_len);
[dgt, idgt] = get_stft_operators(dgt_params, signal_params);
% window
figure;
plot_win(dgt_params.win, signal_params.fs, dgt_params.win_type);
title([num2str(win_type),'\_window.png']);
%
n_areas = length(areas_lim);
if n_areas == 1
name = '1area';
else
name = [num2str(n_areas), '_areas'];
end
masks = [];
for i =1: n_areas
mask = generate_rectangular_mask(dgt_params.nbins, dgt_params.hop,....,
signal_params.sig_len,areas_lim{i}.t_lim, areas_lim{i}.f_lim);
masks =[masks, mask];
end
%%
full_mask = masks;
for i =1:n_areas
full_mask = or(full_mask,masks(i));
end
gab_mul = gen_gabmul_operator(dgt, idgt, full_mask);
% figure mask
figure;
plot_mask(masks, dgt_params.hop, dgt_params.nbins, signal_params.fs);
title('Mask')
saveas(gcf,fullfile(fig_dir,['mask' num2str(sig_len), '.png']));
% ambiguity function
figure;
dynrange=90;
plot_ambiguity_function(dgt_params.win,dgt, dgt_params, signal_params, dynrange)
title(['Ambiguity function - ', num2str(win_type)]);
saveas(gcf,fullfile(fig_dir,[ num2str(win_type) '_ambiguity_L_' num2str(sig_len), '.png']));
%
figure;
mask_proj = dgt(idgt(double(full_mask)));
plotdgtreal(mask_proj, dgt_params.hop, dgt_params.nbins, fs, dynrange);
title(['dgt(idgt(mask)) - ' num2str(win_type)]);
saveas(gcf,fullfile(fig_dir,[num2str(name) '_' num2str(win_type) '_' 'projected_mask.png.png']));
end
\ No newline at end of file
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment