diff --git a/matlab/tfgm/datasets/get_all_mixtures.m b/matlab/tfgm/datasets/get_all_mixtures.m
new file mode 100644
index 0000000000000000000000000000000000000000..5eb811adaf0e8f644ca91c041e2954ea91057320
--- /dev/null
+++ b/matlab/tfgm/datasets/get_all_mixtures.m
@@ -0,0 +1,97 @@
+
+clc; clear; close all;
+%%
+% Generate all combination between wide-band and localized signals
+
+%%
+make_wav_pairs()
+%%
+
+pwd;
+pathname ='spectro_all_mixtures';
+if ~exist('spectro_all_mixtures','dir')
+ mkdir('spectro_all_mixtures');
+end
+addpath('spectro_all_mixtures')
+
+%%
+data = load('signal_lists.mat');
+%%
+resampling_fs = 8000;
+sig_len =16384;
+signal_params = generate_signal_parameters(resampling_fs, sig_len);
+
+%% DGT parameters
+approx_win_len = 512;
+win_len = approx_win_len;
+win_type='hann';
+params = get_params(win_len, win_type);
+
+dgt_params = generate_dgt_parameters(win_type, approx_win_len, params.hop, params.nbins, sig_len);
+
+%% DGT operators
+
+[dgt, idgt] = get_stft_operators(dgt_params, signal_params);
+
+
+%% All mix
+close all
+target_name ={'car','plane','train'};
+per_name = {'beeps','bird','clicks','pop'};
+
+gamma=0.7;
+deb=0;
+close all;
+
+for k=1:length(data.wide_band_sources_files)
+ sig_wd = load_wideband_signal(k, resampling_fs, sig_len);
+
+ for l=1:length(data.localized_sources_files)
+ %%
+
+ %figure;
+ sig_loc = load_localized_signal(l, resampling_fs, sig_len,deb);
+ signals = generate_mix_signal(sig_wd, sig_loc, gamma);
+
+ tf_mat_target = compute_dgt(signals.wideband, dgt );
+ tf_mat_per = compute_dgt(signals.localized, dgt );
+ tf_mat_mix = compute_dgt(signals.mix, dgt );
+
+ [alpha, seuil, radius] = set_smooth_mask_params(target_name{k}, per_name{l}, win_type);
+
+ sdr_mix = sdr(signals.wideband, signals.mix);
+
+ [original_mask, mask_after_imclose, mask_after_imopen,...,
+ mask] = generate_mask(tf_mat_target, tf_mat_per, alpha, seuil, radius);
+
+
+ subplot(221);
+ plot_spectrogram(tf_mat_target, dgt_params, signal_params, dgt )
+ title(target_name{k})
+
+ subplot(222);
+ plot_spectrogram(tf_mat_per, dgt_params, signal_params, dgt )
+ title(per_name(l));
+
+ subplot(223);
+ plot_spectrogram(tf_mat_mix, dgt_params, signal_params, dgt )
+ title(['Mix SDR= ',num2str(sdr_mix),'dB']);
+
+ subplot(224);
+ plot_spectrogram(mask, dgt_params, signal_params, dgt )
+ title(['mask - ', num2str(win_type)]);
+
+ saveas(gcf,fullfile(pathname, [target_name{k},'_' num2str(l), '_',num2str(win_type) '.png']));
+ % figure;
+ % plot_spectrogram((1-mask).*tf_mat_per, dgt_params, signal_params, dgt );
+ % title(['masked spectro - ', target_name{k}, per_name(l)])
+ %saveas(gcf,fullfile(pathname, ['masked_spectro_', target_name{k},'_' num2str(l), '_',num2str(win_type) '.png']));
+
+ end
+
+
+
+end
+
+
+
diff --git a/matlab/tfgm/datasets/get_cuicui_mix_icassp.m b/matlab/tfgm/datasets/get_cuicui_mix_icassp.m
new file mode 100644
index 0000000000000000000000000000000000000000..956c5895d84c3ce60297d2f0371d7186b286ed7a
--- /dev/null
+++ b/matlab/tfgm/datasets/get_cuicui_mix_icassp.m
@@ -0,0 +1,106 @@
+function [signal_params, dgt_params, w,dgt,idgt, signals, alpha, seuil,...,
+ r, mask,dgt_mix]= get_cuicui_mix_icassp()
+%% This function allows you to reproduce ICASSP dataset.
+
+%% Signal parameters
+%make_wav_pairs();
+
+
+sig_len = 2^(13);
+fs = 8000;
+signal_params.fs = fs;
+signal_params.sig_len = sig_len;
+
+%% dgt parameters
+
+
+approx_win_duration =0.02;
+win_type ='hann';
+
+win_len = 2^(round(log2(approx_win_duration*fs)));
+dgt_params.hop = win_len/4 ;
+dgt_params.nbins=4*win_len;
+dgt_params.sig_len = sig_len;
+dgt_params.win_type = win_type;
+dgt_params.win_len = win_len;
+%% window and DGT operator
+ L=dgtlength(dgt_params.sig_len, dgt_params.hop, dgt_params.nbins);
+w = gabwin(dgt_params.win_type, dgt_params.hop, dgt_params.nbins, dgt_params.win_len);
+dgt = @(x) dgtreal(x,w, dgt_params.hop, dgt_params.nbins, dgt_params.sig_len);
+
+wd = {'dual', dgt_params.win_type};
+idgt= @(x)idgtreal(x, wd, dgt_params.hop,dgt_params.nbins, dgt_params.sig_len);
+
+compute_stft = @(x,w,dgt_params,L) dgtreal(x,w, dgt_params.hop, dgt_params.nbins,L);
+%% signals and their mixtures
+
+ind_wideband = 1;
+ind_localized = 2;
+deb = 0.2;
+[x_engine, x_bird] = load_pairs(ind_wideband, ind_localized,...,
+ fs, sig_len, deb);
+
+
+
+
+%%
+x_target = x_engine;
+x_perturbation = x_bird;
+gamma=0.7;
+x_target = x_target/max(abs(x_target));
+x_perturbation = x_perturbation/max(abs(x_perturbation));
+
+x_target = gamma*x_target;
+x_perturbation = (1-gamma)*x_perturbation;
+x_mix = x_target +x_perturbation;
+
+signals.target = x_target;
+signals.noise = x_perturbation;
+signals.mix = x_mix;
+
+%% Spectogramm of signals
+
+
+dgt_Xref = compute_stft(signals.target,w, dgt_params,L);
+dgt_Xper = compute_stft(signals.noise, w, dgt_params,L);
+dgt_mix = dgt_Xref +dgt_Xper;
+
+%% mask
+alpha = 2; seuil =0.02; r = 3;
+
+mask = and(abs(dgt_Xper) < alpha*abs(dgt_Xref),abs(dgt_Xper)<seuil);
+se = strel('disk',r);
+mask =imclose(mask,se);
+figure; imagesc(mask);
+
+%% plot figures
+
+pwd;
+pathname ='figures';
+if ~exist('figures','dir')
+ mkdir('figures');
+end
+addpath('figures')
+
+
+figure;
+plot_spectrogram(mask, dgt_params, signal_params, dgt);
+title('mask')
+saveas(gcf,fullfile(pathname,['mask','.png']));
+
+figure;
+plot_spectrogram(dgt_Xref, dgt_params, signal_params, dgt)
+title('target signal')
+saveas(gcf,fullfile(pathname,['engine','.png']));
+figure;
+plot_spectrogram(dgt_Xper, dgt_params, signal_params, dgt)
+title('perturbation signal')
+saveas(gcf,fullfile(pathname,['bird','.png']));
+figure;
+plot_spectrogram(dgt_mix, dgt_params, signal_params, dgt)
+title('perturbation signal')
+saveas(gcf,fullfile(pathname,['engine_bird','.png']));
+
+
+
+
diff --git a/matlab/tfgm/datasets/get_dataset.m b/matlab/tfgm/datasets/get_dataset.m
new file mode 100644
index 0000000000000000000000000000000000000000..845784c72fcacf79c2c73cc69aad6be6ff66ffff
--- /dev/null
+++ b/matlab/tfgm/datasets/get_dataset.m
@@ -0,0 +1,38 @@
+function dataset = get_dataset()
+
+% This function is used to get the data of the experiments.
+%The data is stored in a structure array.
+%
+% Author: Marina KREME
+
+wide_dir = './data/data_8000Hz_16384samples/wide_band_sources/';
+loc_dir = './data/data_8000Hz_16384samples/localized_sources/';
+
+n_wide_dir = dir([wide_dir, '*.wav']);
+n_loc_dir = dir([loc_dir, '*.wav']);
+dataset = struct('wideband',struct(),'localized',struct());
+
+
+for x =1: length(n_wide_dir)
+
+ wideband_file = [n_wide_dir(x).folder, filesep,n_wide_dir(x).name];
+ wideband_name = n_wide_dir(x).name(1:end-4);
+
+ dataset.wideband.(wideband_name)=wideband_file;
+
+end
+
+
+for x =1: length(n_loc_dir)
+
+ localized_file = [n_loc_dir(x).folder, filesep,n_loc_dir(x).name];
+ localized_file_name = n_loc_dir(x).name(1:end-4);
+
+ dataset.localized.(localized_file_name)=localized_file;
+
+end
+
+
+
+
+
diff --git a/matlab/tfgm/datasets/get_mix.m b/matlab/tfgm/datasets/get_mix.m
new file mode 100644
index 0000000000000000000000000000000000000000..529a1efd29eed5cc6da1b84d9777768a5514d3d5
--- /dev/null
+++ b/matlab/tfgm/datasets/get_mix.m
@@ -0,0 +1,118 @@
+function [signals, dgt_params, signal_params, mask, mask_area, dgt,...,
+ idgt] = get_mix(loc_source, wideband_src, gamma, win_dur, hop_ratio,...,
+ nbins_ratio, win_type, alpha, thres, radius, fig_dir)
+
+%%
+% Function that generates :
+% - the mixture of a wide-band spectrogram signal and a localized signal.
+% - the mask from the two mixtures
+%
+% Inputs:
+% - loc_source(str): signal with localized spectrogram
+% - wideband_src(str): signal with wideband spectrogram
+% - gamma: integer (belong to ]0,1[)
+% - win_dur: window duration (must be between 12 and 20 ms)
+% - hop_ratio, nbins_ration: real
+% - win_type (str): analysis window (hann or gauss)
+% -alpha, thres, radius(real): smoothing parameter for the mask
+% -fig_dir: directory
+%
+% Outputs:
+% -signals(struct): contains wideband, localized and mixtures signals
+% - dgt_params (struct): contains dgt parameters (hop, n_bins, win_type, win_len, win)
+% - signal_params (struct): contains the length of signal and sampling frequency
+% - mask : binary mask
+% - mask_are: binary mask area
+% - dgt, idgt: Operator of Gabor transform and its inverse
+%
+% Author : Marina KREME
+
+%%
+dataset = get_dataset();
+
+[x_loc, fs_loc]= audioread(dataset.localized.(loc_source));
+[x_wb, fs_wb]= audioread(dataset.wideband.(wideband_src));
+
+if length(x_loc)~=length(x_wb)
+ warning('Arrays are not equal');
+
+end
+
+if fs_loc~=fs_wb
+ error('The sampling frequencies must be the same.')
+end
+
+fs= fs_loc;
+sig_len = length(x_loc);
+signal_params = generate_signal_parameters(fs, sig_len);
+
+
+%% build mix signals
+signals = generate_mix_signal(x_wb, x_loc, gamma);
+
+%% Build dgt
+
+approx_win_len = 2.^round(log2(win_dur*fs));
+hop = approx_win_len* hop_ratio;
+nbins = approx_win_len * nbins_ratio;
+
+dgt_params = generate_dgt_parameters(win_type, approx_win_len, hop, nbins, sig_len);
+
+
+%% generat mask
+[dgt, idgt] = get_stft_operators(dgt_params, signal_params);
+
+tf_mat_wb = compute_dgt(signals.wideband, dgt );
+tf_mat_loc = compute_dgt(signals.localized, dgt );
+
+[mask, original_mask, mask_after_imclose, mask_after_imopen,...,
+ ] = generate_mask(tf_mat_wb, tf_mat_loc, alpha, thres, radius);
+mask_area = get_mask_area(mask);
+%%
+
+figure;
+plot_mask(mask, hop, nbins, fs);
+title(['Mask Mix : mask-area = ',num2str(mask_area)]);
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(fig_dir, 'mask_mix.pdf'));
+
+
+
+%%
+
+figure;
+
+% plot_spectrogram(signals.wideband, dgt_params, signal_params, dgt)
+% title(['Wideband source - ', wideband_src]);
+subplot(231)
+plot_spectrogram(signals.localized, dgt_params, signal_params, dgt)
+title(['Localized source - ',loc_source]);
+
+subplot(232)
+plot_spectrogram(signals.mix, dgt_params, signal_params, dgt)
+title('Mix');
+
+subplot(233)
+plot_mask(original_mask, hop, nbins, fs);
+title('Original mask');
+
+subplot(234)
+plot_mask(mask_after_imclose, hop, nbins, fs);
+title('Smooth mask- after imclose');
+
+subplot(235)
+plot_mask(mask_after_imopen, hop, nbins, fs);
+title('Smooth and final mask - after impoen');
+
+m = ~mask;
+
+gabmul = gen_gabmul_operator(dgt, idgt,m);
+x_est = gabmul(signals.wideband);
+subplot(236)
+plot_spectrogram(x_est, dgt_params, signal_params, dgt)
+title('Filtered wb')
+
+saveas(gcf,fullfile(fig_dir, 'mix_spectro_mask.pdf'));
+
+
+end
\ No newline at end of file
diff --git a/matlab/tfgm/datasets/get_params.m b/matlab/tfgm/datasets/get_params.m
new file mode 100644
index 0000000000000000000000000000000000000000..a5dd31e9623966c2863e43c3103301814ac71a3f
--- /dev/null
+++ b/matlab/tfgm/datasets/get_params.m
@@ -0,0 +1,29 @@
+function params = get_params(win_len, win_type)
+% Function that generates input data for the function that generates dgt parameters
+% Inputs:
+% -win_len(int): analysis window length
+% -win_type(str): analysis window type (hann/gauss)
+% Outputs:
+% -hop(int): hop size
+% -nbins(int): frequency bins
+% -win_type, win_len
+%
+% Author : Marina KREME
+%%
+
+switch win_type
+ case 'gauss'
+ hop = win_len/4;
+ nbins = win_len*4;
+ case 'hann'
+
+ hop = win_len/8;
+ nbins = win_len*2;
+end
+
+params.win_type = win_type;
+params.win_len = win_len;
+params.hop = hop;
+params.nbins = nbins;
+
+end
\ No newline at end of file
diff --git a/matlab/tfgm/datasets/load_localized_signal.m b/matlab/tfgm/datasets/load_localized_signal.m
new file mode 100644
index 0000000000000000000000000000000000000000..473385e4d409d44db1d67bf63c084792547ff547
--- /dev/null
+++ b/matlab/tfgm/datasets/load_localized_signal.m
@@ -0,0 +1,23 @@
+function x_loc = load_localized_signal(ind_localized, resampling_fs, sig_len, deb)
+
+
+
+if nargin ==0
+ deb=0;
+end
+
+data = load('signal_lists.mat');
+
+n = size(data.localized_sources_files, 1);
+
+if ind_localized > n
+ error('%s: The ind_localized value you entered is outside the value range. Please try another value.', upper(mfilename));
+end
+
+
+localized_file = [data.localized_sources_files(ind_localized).folder, ...
+ filesep, ...
+ data.localized_sources_files(ind_localized).name];
+x_loc= wave_read(localized_file, resampling_fs, sig_len, deb);
+
+end
diff --git a/matlab/tfgm/datasets/load_pairs.m b/matlab/tfgm/datasets/load_pairs.m
new file mode 100644
index 0000000000000000000000000000000000000000..37fa11d5b02051f173a2b552dc5d2065c785b91a
--- /dev/null
+++ b/matlab/tfgm/datasets/load_pairs.m
@@ -0,0 +1,45 @@
+function [x_wideband,x_localized] = load_pairs(ind_wideband, ind_localized, resampling_fs, sig_len, deb)
+% [x_wideband,x_localized] = load_pairs(ind_wideband, ind_localized, resampling_fs, sig_len, deb)
+% Load data from .mat file. Return the target and the perturbation signals.
+%
+% Inputs:
+% - ind_wideband:(int)index of signals that have a wideband spectrogram
+% - ind_localized: (int) index of signals that have a well-localized spectrogram.
+% - resampling_fs : desired sampling frequency.
+% - sig_len: (int). signal length
+% - deb: Start point of the signal in ms. deb =0 by default
+%
+% Outputs:
+% - x_wideband: target signal
+% - x_localized: perturbation signal (localized in time-frequency)
+%
+% Author : A. Marina KREME
+% e-mail : ama-marina.kreme@lis-lab.fr/ama-marina.kreme@univ-amu.fr
+% Created: 2020-28-01
+%%
+
+if nargin < 4
+ deb=0;
+end
+
+data = load('signal_lists.mat');
+m = size(data.wide_band_sources_files, 1);
+n = size(data.localized_sources_files, 1);
+
+if ind_wideband > m || ind_localized > n
+ error('%s: The ind_wideband or ind_localized value you entered is outside the value range. Please try another value.', upper(mfilename));
+end
+
+wideband_file = [data.wide_band_sources_files(ind_wideband).folder, ...
+ filesep, ...
+ data.wide_band_sources_files(ind_wideband).name];
+localized_file = [data.localized_sources_files(ind_localized).folder, ...
+ filesep, ...
+ data.localized_sources_files(ind_localized).name];
+x_localized= wave_read(localized_file, resampling_fs, sig_len, deb);
+x_wideband= wave_read(wideband_file, resampling_fs, sig_len, deb);
+
+
+end
+
+
diff --git a/matlab/tfgm/datasets/load_wideband_signal.m b/matlab/tfgm/datasets/load_wideband_signal.m
new file mode 100644
index 0000000000000000000000000000000000000000..242a95e4b93c1f1e17722e987bb576db960492f1
--- /dev/null
+++ b/matlab/tfgm/datasets/load_wideband_signal.m
@@ -0,0 +1,24 @@
+function x_wd = load_wideband_signal(ind_wideband,resampling_fs, sig_len, deb)
+
+
+
+
+if nargin == 3
+ deb=0;
+end
+
+data = load('signal_lists.mat');
+n = size(data.wide_band_sources_files, 1);
+
+
+if ind_wideband > n
+ error('%s: The ind_wideband value you entered is outside the value range. Please try another value.', upper(mfilename));
+end
+
+wideband_file = [data.wide_band_sources_files(ind_wideband).folder, ...
+ filesep, ...
+ data.wide_band_sources_files(ind_wideband).name];
+
+x_wd= wave_read(wideband_file, resampling_fs, sig_len, deb);
+
+end
\ No newline at end of file
diff --git a/matlab/tfgm/datasets/make_wav_pairs.m b/matlab/tfgm/datasets/make_wav_pairs.m
new file mode 100644
index 0000000000000000000000000000000000000000..e3cd96f98a544f9699a31dfd414422abaee7e868
--- /dev/null
+++ b/matlab/tfgm/datasets/make_wav_pairs.m
@@ -0,0 +1,19 @@
+function make_wav_pairs()
+%% MAKE_WAV_PAIRS: make_wav_pairs()
+% function that generates two structures.
+% One containing the wideband sounds and the other one with the well localized sounds
+%
+% Author : A. Marina KREME
+% e-mail : ama-marina.kreme@lis-lab.fr/ama-marina.kreme@univ-amu.fr
+% Created: 2020-28-01
+%%
+wide_dir = './data/data_8000Hz_16384samples/wide_band_sources/';
+loc_dir = './data/data_8000Hz_16384samples/localized_sources/';
+
+wide_band_sources_files= dir([wide_dir, '*.wav']); % set the path to the .wav file
+localized_sources_files = dir([loc_dir, '*.wav']);
+
+save('signal_lists.mat','wide_band_sources_files', 'localized_sources_files');
+end
+
+
diff --git a/matlab/tfgm/datasets/run_get_cuicui_mix_icassp.m b/matlab/tfgm/datasets/run_get_cuicui_mix_icassp.m
new file mode 100644
index 0000000000000000000000000000000000000000..ddd2965f75e4fda5d25f9d73c0b2009411f52425
--- /dev/null
+++ b/matlab/tfgm/datasets/run_get_cuicui_mix_icassp.m
@@ -0,0 +1,6 @@
+clc; clear; close all;
+
+%%
+
+[signal_params, dgt_params, w,dgt, signals, alpha, seuil,...,
+ r, mask]= get_cuicui_mix_icassp();
\ No newline at end of file
diff --git a/matlab/tfgm/datasets/set_smooth_mask_params.m b/matlab/tfgm/datasets/set_smooth_mask_params.m
new file mode 100644
index 0000000000000000000000000000000000000000..2926f635e706366de892d38da1e58ee513c36d0c
--- /dev/null
+++ b/matlab/tfgm/datasets/set_smooth_mask_params.m
@@ -0,0 +1,221 @@
+function [alpha, thres, radius] = set_smooth_mask_params(wideband_src, loc_source, win_type)
+% This function allow us to generate parameters for smooth binary mask
+% Inputs:
+% - wideband_src : signal with wide-bande spectrogram
+% - loc_source : signal with localized spectrogram
+% - win_type : window - (gauss or hann)
+%
+%
+% Outputs:
+% - alpha : real
+% - thres :threshold
+% - radius : integer
+%
+% Author: Marina KREME
+
+
+switch win_type
+ case 'gauss'
+
+ switch wideband_src
+ case 'car'
+ switch loc_source
+ case 'beeps'
+
+ alpha=9;
+ thres=1e-5;
+ radius=1;
+
+ case 'bird'
+ alpha=1 ;
+ thres=1e-4;
+ radius=4;
+
+ case 'clicks'
+ alpha=1;
+ thres=0.0002;
+ radius=3;
+
+ case 'finger_snaps'
+ alpha=0.01;
+ thres=0.0001;
+ radius=1;
+ case 'modulations'
+ alpha=1;
+ thres=0.0002;
+ radius=3;
+ case 'pop'
+ alpha=0.1;
+ thres=0.0001;
+ radius=1;
+ end
+
+ case'plane'
+ switch loc_source
+ case 'beeps'
+
+ alpha=1;
+ thres=0.00002;
+ radius=2;
+
+ case 'bird'
+ alpha=0.3;
+ thres=0.0001;
+ radius=1;
+
+ case 'clicks'
+ alpha=1;
+ thres=0.0002;
+ radius=4;
+ case 'finger_snaps'
+ alpha=0.01;
+ thres=0.0001;
+ radius=1;
+ case 'modulations'
+ alpha=1;
+ thres=0.0002;
+ radius=3;
+ case 'pop'
+ alpha=0.01;
+ thres=0.0001;
+ radius=1;
+
+ end
+
+ case 'train'
+ switch loc_source
+ case'beeps'
+
+ alpha=1;
+ thres=0.0001;
+ radius=1;
+
+ case 'bird'
+ alpha=0.1;
+ thres=0.0001;
+ radius=3;
+
+ case 'clicks'
+ alpha=1;
+ thres=0.0002;
+ radius=4;
+ case 'finger_snaps'
+ alpha=0.01;
+ thres=0.0001;
+ radius=1;
+ case 'modulations'
+ alpha=1;
+ thres=0.0002;
+ radius=3;
+ case 'pop'
+ alpha=0.01;
+ thres=0.001;
+ radius=1;
+
+ end
+ end
+
+
+
+ case 'hann'
+ switch wideband_src
+ case 'car'
+ switch loc_source
+ case 'beeps'
+
+ alpha=1;
+ thres=0.00001;
+ radius=1;
+
+
+ case 'bird'
+ alpha=1;
+ thres=0.0001;
+ radius=3;
+
+ case 'clicks'
+ alpha=1;
+ thres=0.0002;
+ radius=4;
+ case 'finger_snaps'
+ alpha=0.01;
+ thres=0.0001;
+ radius=1;
+ case 'modulations'
+ alpha=1;
+ thres=0.0002;
+ radius=3;
+ case 'pop'
+ alpha=1;
+ thres=0.0002;
+ radius=4;
+
+ end
+ case 'plane'
+ switch loc_source
+ case 'beeps'
+
+ alpha=1;
+ thres=0.0001;
+ radius=1;
+
+ case 'bird'
+ alpha=1;
+ thres=0.0002;
+ radius=4;
+
+ case 'clicks'
+ alpha=1;
+ thres=0.0002;
+ radius=2;
+
+ case 'finger_snaps'
+ alpha=0.01;
+ thres=0.0001;
+ radius=1;
+ case 'modulations'
+ alpha=1;
+ thres=0.0002;
+ radius=3;
+ case 'pop'
+ alpha=1;
+ thres=0.0002;
+ radius=1;
+ end
+ case 'train'
+ switch loc_source
+ case 'beeps'
+
+ alpha=1;
+ thres=0.00002;
+ radius=1;
+ case 'bird'
+ alpha=1;
+ thres=0.001;
+ radius=2;
+ case 'clicks'
+ alpha=1;
+ thres=0.0001;
+ radius=1;
+ case 'finger_snaps'
+ alpha=0.01;
+ thres=0.0001;
+ radius=1;
+ case 'modulations'
+ alpha=1;
+ thres=0.0002;
+ radius=3;
+
+
+ end
+
+
+ end
+end
+fprintf("The parameters for smoothing the mask are: \n")
+fprintf("alpha = %f\n", alpha);
+fprintf("seuil = %f\n", thres);
+fprintf("radius = %f\n", radius);
+
+
+end
diff --git a/matlab/tfgm/datasets/test_get_mix.m b/matlab/tfgm/datasets/test_get_mix.m
new file mode 100644
index 0000000000000000000000000000000000000000..278618933e9af03ddb9a91dbe7dfbca60e05a12d
--- /dev/null
+++ b/matlab/tfgm/datasets/test_get_mix.m
@@ -0,0 +1,36 @@
+clear; clear; close all;
+
+%%
+loc_source='bird';
+wideband_src='car';
+gamma=0.7;
+win_type ='gauss';
+
+[alpha, seuil, radius] = set_smooth_mask_params(wideband_src, loc_source, win_type);
+
+
+
+%%
+win_dur =256/8000;
+hop_ratio=1/4;
+nbins_ratio=4;
+tol_subregions=0;
+
+if tol_subregions==1
+ nb_areas ='Paeras';
+else
+ nb_areas='1area';
+end
+
+pwd;
+fig_dir =['fig_solve_', nb_areas,'_car_cuicui_', win_type];
+if ~exist(fig_dir,'dir')
+ mkdir(fig_dir);
+end
+addpath(fig_dir)
+
+
+[signals, dgt_params, signal_params, mask, dgt,...,
+ idgt] = get_mix(loc_source, wideband_src, gamma, win_dur, hop_ratio,...,
+ nbins_ratio, win_type, alpha, seuil, radius, fig_dir);
+
diff --git a/matlab/tfgm/datasets/untitled.m b/matlab/tfgm/datasets/untitled.m
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/matlab/tfgm/datasets/wav_write.m b/matlab/tfgm/datasets/wav_write.m
new file mode 100644
index 0000000000000000000000000000000000000000..da354e9595674152ce7e10d247687675aefe22f9
--- /dev/null
+++ b/matlab/tfgm/datasets/wav_write.m
@@ -0,0 +1,14 @@
+function wav_write(filename, y, fs)
+%% WAV_WRITE
+% Function that writes an audio data file $y$ from a sampling frequency $fs$to a
+% file called a $filename$.The filename entry also specifies the format
+% of the output file.
+%
+% Author : A. Marina KREME
+% e-mail : ama-marina.kreme@lis-lab.fr/ama-marina.kreme@univ-amu.fr
+% Created: 2020-28-01
+%%
+
+x= y/max(abs(y));
+audiowrite(filename,x,fs);
+end
\ No newline at end of file
diff --git a/matlab/tfgm/datasets/wave_read.m b/matlab/tfgm/datasets/wave_read.m
new file mode 100644
index 0000000000000000000000000000000000000000..b413b703ae91fecc96c7b75863331bf84a0b7af4
--- /dev/null
+++ b/matlab/tfgm/datasets/wave_read.m
@@ -0,0 +1,54 @@
+function x= wave_read(filename, resampling_fs, sig_len, deb)
+%% WAVE_READ -- x= wave_read(filename, resampling_fs, sig_len, deb)
+% This function takes an input audio signal and resamples it at the desired frequency
+%
+% Inputs:
+% filename : filename in .wav format
+% resampling_fs : resampling frequency
+% sig_len: (int). signal length
+% deb : Start of the selection in seconds or minutes (int)
+
+%
+% Output:
+% x : resampled signal
+%
+% Author : A. Marina KREME
+% e-mail : ama-marina.kreme@lis-lab.fr/ama-marina.kreme@univ-amu.fr
+% Created: 2020-28-01
+%%
+if nargin==3
+ deb =0;
+end
+
+if exist(filename, 'file') ~= 2
+ error('The file was not found. Please Check the path or the file name : %s.', filename);
+end
+
+[x,fs] = audioread(filename);
+x = x(:,1);
+
+
+
+
+if fs~=resampling_fs
+ x = resample(x,resampling_fs,fs);
+end
+
+s_end = deb*resampling_fs+sig_len;
+
+% if s_end > sig_len
+% error('Take a start value lower than the value you entered: index exceeds matrix dimension : %.f', s_end);
+% end
+
+if length(x)<sig_len
+% msg = ['the length of input signal is smaller than the requested signal length',...
+% '. It would be better to take a signal that has a length greater than or equal to sig_len'];
+% warning(msg)
+ y =x;
+ x=zeros(sig_len,1);
+ x(1:length(y))=y;
+end
+x = x(deb*resampling_fs+1:s_end);
+
+
+end
\ No newline at end of file
diff --git a/matlab/tfgm/exp_tf_filtering/exp_car_cuicui_one_region.m b/matlab/tfgm/exp_tf_filtering/exp_car_cuicui_one_region.m
new file mode 100644
index 0000000000000000000000000000000000000000..ee0a69cf60ff1a757ff5d8a85deaa1ce08d12c9f
--- /dev/null
+++ b/matlab/tfgm/exp_tf_filtering/exp_car_cuicui_one_region.m
@@ -0,0 +1,273 @@
+clc; clear; close all;
+
+%%
+% experiments with
+% - wideband sound: engine(Genesis)
+% - localized sound: birdsong (Genesis)
+
+%%
+make_wav_pairs() % make sure alls pairs are ok
+%% Figures Directory
+
+pwd;
+pathname ='figures_JSTSP';
+if ~exist('figures_JSTSP','dir')
+ mkdir('figures_JSTSP');
+end
+addpath('figures_JSTSP')
+
+%%
+resampling_fs=8000;
+sig_len = 16384;
+
+win_type_list={'hann', 'gauss'};
+win_len_list = [256, 128];
+
+mask_params_hann =[4, 0.001, 1];
+mask_params_gauss =[3, 0.002, 3];
+mask_params = {mask_params_hann, mask_params_gauss};
+eigsvect_hann = [45, 18, 1945, 2051];
+eigsvect_gauss = [45, 8, 1650, 1438];
+eigsvect = {eigsvect_hann, eigsvect_gauss };
+e_target_list = [0.04, 0.049];
+%%
+for k=1:length(win_type_list)
+ k=2;
+%% DGT parameters - gabor frames operators - analysis window
+
+win_type = win_type_list{k};
+win_len = win_len_list(k);
+
+fprintf('analysis window : %s\n', win_type);
+fprintf('win_len : %.f \n', win_len);
+
+signal_params = generate_signal_parameters(resampling_fs, sig_len);
+dgt_params = generate_dgt_parameters(win_type, win_len);
+
+
+[dgt, idgt] = get_stft_operators(dgt_params, signal_params);
+
+% plot associated window
+
+figure;
+plot_win(dgt_params.win, signal_params.fs, signal_params.sig_len, win_type)
+title([num2str(win_type), ' - window']);
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(pathname, [num2str(win_type), num2str(win_len),'_window.png']));
+
+%% Load signals - get mixtures - their spectrograms
+
+ind_engine = 3;
+ind_bird = 5;
+deb = 0;
+
+[x_engine, x_bird] = load_pairs(ind_engine, ind_bird, resampling_fs, signal_params.sig_len, deb);
+
+signals = generate_mix_signal(x_engine, x_bird);
+
+
+
+% compute dgt
+
+tf_mat_engine = compute_dgt(signals.target, dgt );
+tf_mat_bird = compute_dgt(signals.noise, dgt );
+tf_mat_mix = compute_dgt(signals.mix, dgt );
+
+
+% mix -sdr
+
+sdr_mix = sdr(signals.target, signals.mix);
+fprintf('The SDR of the mixture is : %e\n', sdr_mix)
+
+%% Generate mask
+
+% mask
+alpha= mask_params{k}(1) ;
+seuil = mask_params{k}(2);
+radius = mask_params{k}(3);
+mask = generate_mask(tf_mat_engine, tf_mat_bird, alpha, seuil, radius);
+[mask_area, mask_area_ratio] = get_mask_area(mask);
+
+%% Baselines reconstruction
+
+%zero value method
+x_zero = solver_tfgm_zero(tf_mat_mix, mask, idgt);
+fprintf('Zeros filling SDR is : %e\n', sdr(signals.target, x_zero));
+
+%interpolation + random phases method
+
+x_interp= solver_tfgm_interp(tf_mat_mix, mask, idgt);
+fprintf('interp + random phases filling SDR is : %e\n', sdr(signals.target, x_interp));
+
+
+%% generate Gabor mutliplier
+
+gab_mul = gen_gabmul_operator(dgt, idgt, mask);
+
+%% evd via halko
+
+% halko parameters
+
+tolerance_arrf = 1e-6;
+proba_arrf = 0.9999;
+r = compute_r(signal_params.sig_len, signal_params.sig_len, proba_arrf);
+
+% stage 1 Halko
+tic;
+q_mat = adaptative_randomized_range_finder(gab_mul, signal_params.sig_len, tolerance_arrf, r);
+t_arrf = toc;
+
+fprintf('Q shape : %.f %.f\n', size(q_mat));
+
+% stage 2 : Halko
+
+% Evd decomposition via Nystrom
+tic;
+evdn = EVD_nystrom(gab_mul, q_mat);
+t_evdn = toc;
+
+%% tf filtering reconstruction
+
+
+u_mat = evdn.U;
+s_vec = diag(evdn.D);
+ut_x = U_transpose_observation( signals.mix, u_mat);
+
+%%
+e_target = e_target_list(k);
+x_rec= solver_tfgm( signals.mix, u_mat,s_vec, ut_x);
+obj_fun = @(lambda_coef) abs(e_target - norm(mask.*dgt(x_rec(lambda_coef))));
+sdr_engine =@(lambda_coef) sdr(signals.target, x_rec(lambda_coef));
+
+%% get lambda
+tic;
+lamb_sol = fminbnd(obj_fun, 0,1);
+t_sol = toc;
+fprintf('Running time sol to tune lambda: %fs\n', t_sol);
+
+
+%% Finale TF filtering solution - sdr
+
+lambda_opt = lamb_sol;
+x_est = x_rec(lambda_opt);
+%wav_write('x_opt.wav', x_est, signal_params.fs);
+
+sdr_opt = sdr(signals.target, x_est);
+sdr_zero = sdr(signals.target, x_zero);
+sdr_interp = sdr(signals.target, x_interp);
+sdr_mix = sdr( signals.target, signals.mix);
+
+%
+fprintf('Optimal lambda: %e\n', lambda_opt);
+fprintf('Optimal SDR: :%e dB\n', sdr_opt);
+fprintf('Zero filling SDR: %e dB\n',sdr_zero);
+fprintf('Interp + random phases filling SDR: %e dB\n',sdr_interp);
+fprintf('Mix SDR: %e dB\n',sdr_mix);
+
+%% plot EVD Results
+%% Eigenvalue plot - suplots
+
+l1 = eigsvect{k}(1);
+l2 = eigsvect{k}(2);
+l3 = eigsvect{k}(3);
+l4 = eigsvect{k}(4);
+
+
+figure;
+%set(gcf,'position',[1, 1 1100 400]);
+%subplot(121);
+plot_spectrogram(mask, dgt_params,signal_params, dgt);
+set(gca, 'FontSize', 20, 'fontName','Times');
+axis square
+saveas(gcf,fullfile(pathname, ['mask_cuicui_', num2str(win_type), '.png']));
+%subplot(122);
+figure;
+semilogy(diag(evdn.D), 'Linewidth',3);
+hold on;
+plot(l1,s_vec(l1),'k-*','Linewidth',3);
+plot(l2,s_vec(l2),'m-*','Linewidth',3);
+plot(l3,s_vec(l3),'g-*','Linewidth',3);
+plot(l4,s_vec(l4),'c-*','Linewidth',3);
+grid on;
+xlabel('$k$','Interpreter','latex')
+legend({'$\sigma_k$',['$\lambda$ =',num2str(l1)],['$\lambda$ =', num2str(l2)],....,
+ ['$\lambda$ =', num2str(l3)], ['$\lambda$ =', num2str(l4)]},...,
+ 'Interpreter','latex','Location','southwest')
+axis square
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(pathname, ['eigval_cuicui_', num2str(win_type), '.png']));
+
+
+%%
+figure;
+%set(gcf,'position',[1, 1 900 400]);
+%subplot(221);
+
+
+plot_spectrogram(evdn.U(:,l1), dgt_params,signal_params, dgt);
+axis square
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(pathname, ['eigvect_', num2str(l1), '.png']));
+%subplot(222);
+figure;
+plot_spectrogram(evdn.U(:,l2), dgt_params,signal_params, dgt);
+axis square
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(pathname, ['eigvect_', num2str(l2), '.png']));
+%subplot(223);
+figure;
+plot_spectrogram(evdn.U(:,l3), dgt_params,signal_params, dgt);
+axis square
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(pathname, ['eigvect_', num2str(l3), '.png']));
+%subplot(224);
+figure;
+plot_spectrogram(evdn.U(:,l4), dgt_params,signal_params, dgt);
+axis square
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(pathname, ['eigvect_', num2str(l4), '.png']));
+%%
+%figure;
+%set(gcf,'position',[1, 1 950 400]);
+figure;
+plot_spectrogram(signals.noise, dgt_params, signal_params, dgt)
+title('perturbation: birdsong' );
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(pathname, ['birdsong_' , num2str(win_type),'_' , num2str(win_len),'.png']));
+figure;
+plot_spectrogram(signals.mix, dgt_params, signal_params, dgt)
+title(['car+birdsong : SDR= ',num2str(sdr_mix),'dB']);
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(pathname, ['mix_birdsong_' , num2str(win_type),'_' , num2str(win_len),'.png']));
+figure;
+plot_spectrogram(signals.target, dgt_params, signal_params,dgt)
+title('true source: car')
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(pathname, ['car_' , num2str(win_type),'_' , num2str(win_len),'.png']));
+figure;
+plot_spectrogram(mask, dgt_params,signal_params, dgt);
+title(['mask car +birdsong : area = ',num2str(mask_area)]);
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(pathname, ['mask_' , num2str(win_type),'_' , num2str(win_len),'.png']));
+figure;
+plot_spectrogram(x_zero, dgt_params, signal_params,dgt)
+title(['Zero fill SDR= ', num2str(sdr_zero),'dB'])
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(pathname, ['x_zero_' , num2str(win_type),'_' , num2str(win_len),'.png']));
+figure;
+plot_spectrogram(x_interp, dgt_params, signal_params,dgt)
+title(['interp SDR= ', num2str(sdr_interp),'dB'])
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(pathname, ['interp_' , num2str(win_type),'_' , num2str(win_len),'.png']));
+figure;
+plot_spectrogram(x_est, dgt_params, signal_params,dgt)
+title(['\lambda\_op = ' ,num2str(lambda_opt,2), ' - SDR=' , num2str(sdr_opt), 'dB'])
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(pathname, ['x_est_' , num2str(win_type),'_' , num2str(win_len),'.png']));
+
+%%
+file_name = ['exp_engine_cuicui_1area_', num2str(win_type),'.mat'];
+save(file_name,'signal_params','dgt_params', 'signals','mask','mask_area',....,
+ 'gab_mul', 'q_mat', 'evdn','sdr_mix', 'sdr_opt','sdr_zero','sdr_interp','x_zero','x_interp','x_est','lambda_opt','e_target')
+
+end
diff --git a/matlab/tfgm/exp_tf_filtering/exp_filtering_out_car_cuicui_Pareas.m b/matlab/tfgm/exp_tf_filtering/exp_filtering_out_car_cuicui_Pareas.m
new file mode 100644
index 0000000000000000000000000000000000000000..c4075d182701861593f065d36f085e0f770fcc61
--- /dev/null
+++ b/matlab/tfgm/exp_tf_filtering/exp_filtering_out_car_cuicui_Pareas.m
@@ -0,0 +1,278 @@
+clc; clear; close all;
+%
+%%
+pwd;
+pathname ='figures_JSTSP';
+if ~exist('figures_JSTSP','dir')
+ mkdir('figures_JSTSP');
+end
+addpath('figures_JSTSP')
+%%
+
+ind_loc = 5;
+ind_wd = 3;
+deb_ind_loc = 0;
+deb_ind_wd=0;
+resampling_fs = 8000;
+sig_len = 16384;
+
+%% DGT params - signals - mask
+clc;
+param_gauss = get_win_gauss_param();
+
+win_len = param_gauss.win_len;
+win_type = param_gauss.win_type;
+alpha = param_gauss.alpha;
+seuil = param_gauss.seuil;
+radius = param_gauss.radius;
+
+approx_win_len = 128;
+hop =32;
+nbins=512;
+
+[signals, dgt_params, signal_params, mask, dgt,idgt] = get_mix(ind_loc, ...,
+ ind_wd, deb_ind_loc, deb_ind_wd, resampling_fs, sig_len,...,
+ approx_win_len,hop, nbins, win_type, alpha, seuil, radius);
+
+
+[mask_area, mask_area_ratio] = get_mask_area(mask);
+
+fprintf("We work with %s window of length %.f\n", win_type, win_len);
+
+fprintf("Gabor transform parameters are: \n")
+fprintf('hop :%2.f\n', dgt_params.hop);
+fprintf('n_bins: %2.f\n', dgt_params.nbins);
+
+
+
+fprintf("The parameters for smoothing the mask are: \n")
+fprintf("alpha = %f\n", alpha);
+fprintf("seuil = %f\n", seuil);
+fprintf("radius = %f\n", radius);
+
+
+% plot associated window
+figure;
+plot_win(dgt_params.win, signal_params.fs, signal_params.sig_len, win_type)
+title([num2str(win_type), ' - window']);
+set(gca, 'FontSize', 20, 'fontName','Times');
+%saveas(gcf,fullfile(pathname, [num2str(win_type),'_window.png']));
+
+
+%% Spectrogrammes - Mask
+
+tf_mat_engine = compute_dgt(signals.target, dgt);
+tf_mat_bird = compute_dgt(signals.noise, dgt);
+tf_mat_mix = compute_dgt(signals.mix, dgt);
+
+%plot_spectrogram(x, dgt_params, signal_params, dgt, dynrange, clim)
+dynrange=90;
+figure('name','engine'); plot_spectrogram(tf_mat_engine, dgt_params, signal_params, dgt);
+title('Source')
+set(gca, 'FontSize', 20, 'fontName','Times');
+figure('name','bird'); plot_spectrogram(tf_mat_bird, dgt_params, signal_params, dgt);
+title('perturbation')
+set(gca, 'FontSize', 20, 'fontName','Times');
+figure('name','mix');
+plot_spectrogram(tf_mat_mix, dgt_params,signal_params, dgt);
+set(gca, 'FontSize', 20, 'fontName','Times');
+%title('mix')
+%saveas(gcf,fullfile(pathname, 'engine_bird_mixture.png'));
+
+
+
+%plot mask
+figure('name','mask'); plot_spectrogram(mask, dgt_params,signal_params, dgt );
+%title(['mask : mask-area = ',num2str(mask_area)]);
+set(gca, 'FontSize', 20, 'fontName','Times');
+%saveas(gcf,fullfile(pathname, 'mask_cuicui_gauss.png'));
+
+% figure;
+% plot_spectrogram((1-mask).*tf_mat_bird, dgt_params,signal_params, dgt);
+
+fprintf("mask area is: %f\n",mask_area);
+
+%% Mix - SDR
+
+sdr_mix = sdr(signals.target, signals.mix);
+fprintf('The SDR of the mixture is : %e\n', sdr_mix)
+
+%%
+
+%[mask_limast,mask_labeled, mask_area_list] = make_subregions(mask, dgt_params, signal_params);
+
+%pq_norms_val = pq_norms(sig_len,dgt,idgt,mask_list);
+%pq_norms_val1 = get_pq_norms(sig_len, dgt, idgt, mask_labeled);
+%pq_norms = get_pq_norms(sig_len, dgt, idgt, mask_list);
+%%
+tol=10^(-3);
+[pq_norms_val, mask_labeled] = create_subregions(mask, dgt, idgt, ...,
+ dgt_params, signal_params, tol);
+%%
+final_mask_labeled = mask_labeled;
+[gabmul_list, mask_list] = get_P_gabmul(final_mask_labeled, dgt, idgt);
+
+%%
+x_mix = signals.mix;
+tolerance_arrf = 10^(-3);
+proba_arrf = 0.999;
+ [t_arrf,t_evdn, t_ut_x, rank_q, s_vec_list, u_mat_list,...,
+ ut_x_list,r] = compute_decomposition(x_mix, mask_list, gabmul_list,...,
+ tolerance_arrf, proba_arrf);
+
+
+%%
+lambda_coef=0.01;
+ x=compute_estimate(lambda_coef, x_mix, s_vec_list, u_mat_list, ut_x_list);
+
+
+ %%
+
+
+ [lambda_est, t_est] = compute_lambda(x_mix, mask, dgt_params,...,
+ signal_params, dgt, s_vec_list, u_mat_list, ut_x_list,...,
+ gabmul_list);
+
+%% figure
+
+figure;
+imagesc(real(log10(pq_norms_val)))
+ylabel('$p$','Interpreter','latex')
+xlabel('$q$', 'Interpreter', 'latex')
+colorbar()
+set(gca, 'FontSize', 20, 'fontName','Times');
+%title('Final norms of Gabor multiplier composition')
+%saveas(gcf,fullfile(pathname, 'norm_mulpq.png'));
+
+
+%% fixed
+gabmul_list = get_P_gabmul(mask_labels, dgt, idgt);
+
+%%
+
+rank = 10;
+x_mix = signals.mix;
+ [t_rrf,t_evdn, t_ut_x, s_vec_list, u_mat_list,...,
+ ut_x_list]=compute_decomposition_fixed_rank(x_mix, mask_labels, gabmul_list, rank);
+
+
+%%
+tolerance_arrf = 0.1;
+proba_arrf = 0.9;
+
+[mask_labels, mask_area_list,n_labels] = make_subregions(mask, dgt_params, signal_params);
+
+[t_arrf,t_evdn, t_ut_x, rank_q, s_vec_list, u_mat_list,...,
+ ut_x_list,r] = compute_decomposition(x_mix, mask_labels, gabmul_list,...,
+ tolerance_arrf, proba_arrf);
+
+
+%%
+
+
+n_areas = length(mask_area);
+lambda_coef = ones(n_areas,1);
+x=compute_estimate(lambda_coef, x_mix, n_areas,s_vec_list, u_mat_list, ut_x_list);
+%%
+x_target = signals.target;
+[lambda_oracle, t_oracle] = compute_lambda_oracle_sdr(x_target, x_mix,...,
+ n_areas,s_vec_list, u_mat_list, ut_x_list);
+
+ %%
+ [lambda_est, t_est] = compute_lambda(x_mix, mask, dgt_params,...,
+signal_params, dgt, mask_labels, s_vec_list, u_mat_list, ut_x_list,...,
+gabmul_list);
+
+%% parametres de la EVD halko
+tolerance_arrf = 1e-6;
+proba_arrf = 1 - 1e-4;
+x_mix = signals.mix;
+
+compute_decomposition(x_mix,mask_labels, gabmul_list,tolerance_arrf, proba_arrf);
+%% create subregions
+
+[mask_labels, mask_area_list,n_labels] = make_subregions(mask, dgt_params, signal_params);
+
+
+%%
+e_target = zeros(n_labels, 1);
+for k=1:n_labels
+
+ e_target_k = norm(mask_labels{k}.*tf_mat_engine) ;
+ e_target(k) = e_target_k;
+
+end
+%%
+x_mix = signals.mix;
+x_target = signals.target;
+[x_rec, t_arrf, t_evdn, t_ut_x, rank_q, s_vec_list, u_mat_list,...,
+ ut_x_list, lambda_vec_opt] = filtering_out_Pareas(x_mix, mask_labels, dgt, idgt, x_target, tolerance_arrf, proba_arrf);
+
+%%
+i_p=1;
+pq_norms_val = update_pq_norms(mask_labels, pq_norms, i_p, signal_params, dgt, idgt);
+%%
+i_p = 2;
+i_q=1;
+[ mask, pq_norms_val] = merge_subregions(mask, pq_norms_val, i_p, i_q);
+%%
+figure;
+plot_spectrogram(x_rec, dgt_params, signal_params,dgt);
+%%
+
+%%
+% %% Generate list of Gabor multipliers
+%
+% gab_mul_list = get_P_gabmul(mask_labels, dgt, idgt);
+%
+% %% EVD decomposition
+%
+% [t_arrf, t_evdn, t_uh_x, s_vec_list, u_mat_list, t_uh_x_list, ...,
+% rank_q] = compute_decomposition(mask_labels, gab_mul_list, dgt_params, signal_params, signals.mix, tolerance_arrf,r);
+%
+% %% Tuning Lambda
+% n_areas = n_labels;
+% uh_x_list = t_uh_x_list;
+%
+%
+%%
+
+%%
+% %%
+% %obj_fun = @(lambda_vec) norm(signals.target - compute_estimate(lambda_vec, s_vec_list, u_mat_list, uh_x_list,n_areas, signals.mix));
+% obj_fun = @(lambda_vec) abs(e_target -norm( mask.*dgt(compute_estimate(lambda_vec, s_vec_list, u_mat_list, uh_x_list,n_areas, signals.mix))));
+%
+% %% Generate and save msk for each regions
+% x0= ones(n_labels,1);
+% tic;
+% sol = fmincon(obj_fun,x0);
+% t1 =toc;
+%
+% %%
+% lambda_opt = obj_fun(x0);
+% x_est = compute_estimate(lambda_opt, s_vec_list, u_mat_list, uh_x_list, n_areas,signals.mix);
+%
+% figure;
+% plot_spectrogram(x_est, dgt_params, signal_params,dgt);
+% %%
+% %
+% % all_mask = zeros(size(mask,1)*size(mask,2),n_labels);
+% %
+% %
+% % for k =1:n_labels
+% % [mask_label,~] = bwlabel(mask);
+% %
+% % % on construit chaque mask
+% % mask_label(mask_label~=k)=0;
+% % mask_ =mask_label;
+% % all_mask(:,k) = mask_(:);
+% % figure(k); plotdgtreal(mask_, dgt_params.hop, dgt_params.nbins, signal_params.fs);
+% % title(['k=', num2str(k)])
+% %
+% % [mask_area_, mask_area_ratio_] = get_mask_area(mask_);
+% % mask_area_list(k) = mask_area_;
+% % fprintf('mask area = %.f\n',mask_area_);
+% %
+% % end
+%
+%
diff --git a/matlab/tfgm/experiments/compute_error_operator_norm.m b/matlab/tfgm/experiments/compute_error_operator_norm.m
new file mode 100644
index 0000000000000000000000000000000000000000..38fa51266f2102b46a0cc0295d5efd2e829591f9
--- /dev/null
+++ b/matlab/tfgm/experiments/compute_error_operator_norm.m
@@ -0,0 +1,25 @@
+function [eigs_norm, arrfevdn_norm, rrfevdn_norm]= compute_error_operator_norm(file_name, n_exp)
+
+eigs_norm = zeros(length(file_name), n_exp);
+arrfevdn_norm = zeros(length(file_name), n_exp);
+rrfevdn_norm = zeros(length(file_name), n_exp);
+
+for k=1:n_exp
+
+ rep_dir = ['exp',num2str(k)];
+
+ for l =1: 3%length(file_name)
+ data_folder = dir(fullfile(rep_dir,'*.mat'));
+ file = [data_folder(l).folder,filesep, file_name{l}];
+
+ upload_file = load(file);
+ eigs_norm(l,k) = error_operator_norm(upload_file.mul, upload_file.svd_result_eigs);
+ arrfevdn_norm(l,k) = error_operator_norm(upload_file.mul, upload_file.svd_result_nystrom_Qadaptative);
+ rrfevdn_norm(l,k) = error_operator_norm(upload_file.mul, upload_file.svd_result_nystrom);
+
+ end
+end
+
+
+
+end
\ No newline at end of file
diff --git a/matlab/tfgm/experiments/estimated_rank.m b/matlab/tfgm/experiments/estimated_rank.m
new file mode 100644
index 0000000000000000000000000000000000000000..c383ae00b2321ff06089ab402ed8e24734f56258
--- /dev/null
+++ b/matlab/tfgm/experiments/estimated_rank.m
@@ -0,0 +1,20 @@
+function q_with = estimated_rank(file_name, n_exp)
+
+
+q_with = zeros(length(file_name), n_exp);
+
+
+for k=1:n_exp
+ rep_dir = ['exp',num2str(k)];
+
+ for l =1:length(file_name)
+ data_folder = dir(fullfile(rep_dir,'*.mat'));
+ file = [data_folder(l).folder,filesep, file_name{l}];
+ upload_file = load(file);
+ q_with(l,k) = size(upload_file.svd_result_eigs.D,1);
+
+
+ end
+end
+
+end
\ No newline at end of file
diff --git a/matlab/tfgm/experiments/exp_gabmul_eig_running_times.m b/matlab/tfgm/experiments/exp_gabmul_eig_running_times.m
new file mode 100644
index 0000000000000000000000000000000000000000..2d6ae083f7b82380e7ce69390b2304077ab23d9d
--- /dev/null
+++ b/matlab/tfgm/experiments/exp_gabmul_eig_running_times.m
@@ -0,0 +1,72 @@
+clc; clear; close all;
+
+
+%%
+setting='full';
+exp = get_experiment(setting);
+
+%%
+param = exp.data_params;
+t_lim = [exp.problem_params.t_val{1}, exp.problem_params.t_val{2}];
+f_lim = [exp.problem_params.f_val{1}, exp.problem_params.f_val{2}];
+win_type = exp.problem_params.win_type;
+
+t_arrf = zeros(length(param) ,1);
+t_rrf = zeros(length(param) ,1);
+t_arrfevdn = zeros(length(param) ,1);
+t_rrfevdn = zeros(length(param) ,1);
+t_eigs = zeros(length(param) ,1);
+%%
+
+n_runs = 1;%0;
+
+fprintf('je ferai au total %.1f runs\n\n',n_runs);
+%%
+for l=1:n_runs
+
+fprintf("C'est partie pour le %.1f run\n\n",l);
+
+%%
+tic;
+for k = 1:1%length(param)
+ k=5;
+
+ fprintf('je suis a la %.1f ieme iteration patiente\n',k);
+ param_pow = param{k};
+ problem_data = get_problem_data(param_pow,t_lim, f_lim, win_type);
+
+
+
+tolerance = exp.solver_params.tolerance;
+r = exp.solver_params.r;
+mask = problem_data.mask;
+dgt_params = problem_data.dgt_params;
+signal_params = problem_data.signal_params;
+
+[gab_mul, direct_stft, adjoint_stft, q_mat_arrf, arrf_time,....,
+ q_mat_rrf, rrf_time, svd_res_arrf,arrfevdn_time, svd_res_rrf,....,
+ rrfevdn_time, svd_res_eigs, eigs_time, eigs_norm, arrfevdn_norm, ...,
+ rrfevdn_norm,q_with] =solver(tolerance, r, mask, dgt_params, signal_params);
+
+
+t_arrf(k) = arrf_time;
+t_rrf(k) = rrf_time;
+t_arrfevdn(k) = arrfevdn_time;
+t_rrfevdn(k) = rrfevdn_time;
+t_eigs(k) = eigs_time;
+
+filename = ['gabmul_eig_dgtvar_', num2str(signal_params.sig_len),'.mat'];
+
+mkdir(['exp_gabmul_eig_running_times_',num2str(l)]);
+warning('off', 'MATLAB:MKDIR:DirectoryExists');
+path_name = ['exp_gabmul_eig_running_times_',num2str(l)];
+
+save(fullfile(path_name,filename),'setting','exp','problem_data', 'q_mat_arrf',....,
+ 'arrf_time', 'q_mat_rrf', 'rrf_time', 'svd_res_arrf','arrfevdn_time',...,
+ 'svd_res_rrf', 'rrfevdn_time', 'svd_res_eigs', 'eigs_time',...,
+ 'eigs_norm','arrfevdn_norm','rrfevdn_norm','q_with','t_arrf','t_rrf','t_arrfevdn',...,
+ 't_rrfevdn','t_eigs');
+end
+toc;
+end
+%%
\ No newline at end of file
diff --git a/matlab/tfgm/experiments/get_experiment.m b/matlab/tfgm/experiments/get_experiment.m
new file mode 100644
index 0000000000000000000000000000000000000000..dbee5307abd08de5d962be005efd7860697b9b13
--- /dev/null
+++ b/matlab/tfgm/experiments/get_experiment.m
@@ -0,0 +1,42 @@
+function exp = get_experiment(setting)
+%create experiment parameter
+
+
+switch setting
+ case 'full'
+
+ param_pow = {0, 1, 2, 3, 4};
+ data_params = param_pow;
+
+ case 'light'
+
+ param_pow = {0,1,2};
+ data_params = param_pow;
+ otherwise
+
+ error('Unknown setting: ')
+
+end
+
+t_min = 0.3; t_max = 0.5; f_min = 0.1; f_max =0.2;
+t_val = {t_min, t_max};
+f_val={f_min, f_max};
+
+problem_params.win_type = 'hann';
+
+problem_params.t_val = t_val;
+problem_params.f_val = f_val;
+
+tolerance = 1e-6;
+r = 15;
+
+solver_params.tolerance = tolerance;
+solver_params.r = r;
+
+
+exp.data_params=data_params;
+exp.problem_params=problem_params;
+exp.solver_params=solver_params;
+end
+
+
diff --git a/matlab/tfgm/experiments/get_mask_area.m b/matlab/tfgm/experiments/get_mask_area.m
new file mode 100644
index 0000000000000000000000000000000000000000..f3701b9c08aafee0eb2eb566a6a43c144cd97d7e
--- /dev/null
+++ b/matlab/tfgm/experiments/get_mask_area.m
@@ -0,0 +1,10 @@
+function [mask_area, varargout] = get_mask_area(mask)
+%compute mask area
+
+mask_area = sum(mask(:));
+mask_area_ratio = mask_area/ (size(mask,1)*size(mask,2));
+ varargout{1} = mask_area_ratio;
+
+end
+
+
diff --git a/matlab/tfgm/experiments/get_problem_data.m b/matlab/tfgm/experiments/get_problem_data.m
new file mode 100644
index 0000000000000000000000000000000000000000..a3619c341f8c7b38f889a6c2b51e48e79fd8917d
--- /dev/null
+++ b/matlab/tfgm/experiments/get_problem_data.m
@@ -0,0 +1,23 @@
+function problem_data = get_problem_data(param_pow,t_lim, f_lim, win_type)
+
+% generate problem data for tf filtering
+
+
+sig_len = 256*4^param_pow;
+win_len = 8*2^param_pow;
+hop = 2*2^param_pow;
+nbins = 32*2^param_pow;
+fs=1;
+
+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);
+mask = generate_rectangular_mask(nbins, hop, sig_len, t_lim, f_lim);
+
+problem_data.dgt_params= dgt_params;
+problem_data.signal_params = signal_params;
+problem_data.hop = hop;
+problem_data.mask = mask;
+
+end
\ No newline at end of file
diff --git a/matlab/tfgm/experiments/get_ratio_of_eigs_running_times.m b/matlab/tfgm/experiments/get_ratio_of_eigs_running_times.m
new file mode 100644
index 0000000000000000000000000000000000000000..083dd632565c4cb4caec91dc88b0fc5eccc51c34
--- /dev/null
+++ b/matlab/tfgm/experiments/get_ratio_of_eigs_running_times.m
@@ -0,0 +1,16 @@
+function [ratio_arrf_time_over_eigs,ratio_rrf_time_over_eigs,...,
+ ratio_evdnarrf_over_eigs,ratio_evdnrrf_over_eigs]= get_ratio_of_eigs_running_times(arrf_time, rrf_time, evdnarrf_time, evdnrrf_time,eigs_time)
+
+
+
+
+
+ratio_arrf_time_over_eigs = arrf_time./eigs_time;
+ratio_rrf_time_over_eigs = rrf_time./eigs_time;
+ratio_evdnarrf_over_eigs = evdnarrf_time./eigs_time;
+ratio_evdnrrf_over_eigs = evdnrrf_time./eigs_time ;
+
+
+
+
+end
\ No newline at end of file
diff --git a/matlab/tfgm/experiments/perf_measures.m b/matlab/tfgm/experiments/perf_measures.m
new file mode 100644
index 0000000000000000000000000000000000000000..eddb65ba7f3a70fec4beb1d4780542a517a69020
--- /dev/null
+++ b/matlab/tfgm/experiments/perf_measures.m
@@ -0,0 +1,65 @@
+function [arrf_time, rrf_time, eigs_time, evdnrrf_time, evdnarrf_time,...,
+ arrf_time_mean, rrf_time_mean, evdnrrf_time_mean, evdnarrf_time_mean,...,
+ evdarrrf_mean, evdrrf_mean,eigs_mean, arrf_time_std, rrf_time_std,...,
+ evdnrrf_time_std, evdnarrf_time_std, evdarrrf_std, ....,
+ evdrrf_std, eigs_std] = perf_measures(file_name, n_exp)
+
+
+
+arrf_time=[];
+rrf_time = [];
+eigs_time = [];
+evdnrrf_time = [];
+evdnarrf_time = [];
+
+
+for k=1:n_exp
+
+upload_file = load(fullfile((['exp',num2str(k)]),file_name{5}));
+
+arrf_time = [arrf_time, upload_file.time_adaptative_Q];
+arrf_time = squeeze(arrf_time);
+
+
+rrf_time = [rrf_time, upload_file.time_randomized_Q];
+rrf_time = squeeze(rrf_time);
+
+eigs_time = [eigs_time, upload_file.time_EVD_eigs];
+eigs_time = squeeze(eigs_time);
+
+evdnrrf_time = [evdnrrf_time, upload_file.time_EVD_nystrom];
+evdnrrf_time = squeeze(evdnrrf_time);
+
+evdnarrf_time = [evdnarrf_time, upload_file.time_EVD_nystrom_Qadapt];
+evdnarrf_time = squeeze(evdnarrf_time);
+
+
+end
+
+% mean
+
+arrf_time_mean = mean(arrf_time,2); % temps moyen adaptative randomized range finder
+rrf_time_mean = mean(rrf_time,2); % temps moyen randomized range finder
+evdnrrf_time_mean = mean(evdnrrf_time,2);
+evdnarrf_time_mean = mean(evdnarrf_time,2);
+
+evdarrrf_mean = mean(arrf_time+ evdnarrf_time,2); % arrf + evd/nystrom
+evdrrf_mean = mean(rrf_time+ evdnrrf_time,2); % rrf +evd/nystom
+eigs_mean = mean(eigs_time,2); % temps moyen eigs
+
+%std
+
+
+arrf_time_std = std(arrf_time, 0,2); % temps moyen adaptative randomized range finder
+rrf_time_std = std(rrf_time, 0, 2); % temps moyen randomized range finder
+evdnrrf_time_std = std(evdnrrf_time,0, 2);
+evdnarrf_time_std = std(evdnarrf_time, 0, 2);
+
+evdarrrf_std = std(arrf_time+ evdnarrf_time, 0,2); % arrf + evd/nystrom
+evdrrf_std = std(rrf_time+ evdnrrf_time, 0, 2); % rrf +evd/nystom
+eigs_std = std(eigs_time,0, 2); % temps moyen eigs
+
+
+
+
+end
\ No newline at end of file
diff --git a/matlab/tfgm/experiments/plot_results.m b/matlab/tfgm/experiments/plot_results.m
new file mode 100644
index 0000000000000000000000000000000000000000..d07c70299ae499fed939fc118fe2d8d21ee140e7
--- /dev/null
+++ b/matlab/tfgm/experiments/plot_results.m
@@ -0,0 +1,230 @@
+function plot_results()
+
+%%
+
+pwd;
+pathname ='GabMulEigRunTimeExperiment';
+if ~exist('GabMulEigRunTimeExperiment','dir')
+ mkdir('GabMulEigRunTimeExperiment');
+end
+addpath('GabMulEigRunTimeExperiment')
+
+%%
+% fichier .mat
+file_name = {'time_halko_vs_eigs256.mat', 'time_halko_vs_eigs1024.mat',...,
+ 'time_halko_vs_eigs4096.mat', 'time_halko_vs_eigs16384.mat',....,
+ 'time_halko_vs_eigs65536.mat'};
+%%
+mask_area_list = zeros(length(file_name),1);
+mask_area_ratio_list = zeros(length(file_name),1);
+sig_len_list = zeros(length(file_name),1);
+
+for k =1:1
+ rep_dir = ['exp',num2str(k)];
+
+ for l=1:length(file_name)
+
+ figure(l)
+ data_folder = dir(fullfile(rep_dir,'*.mat'));
+ file = [data_folder(l).folder,filesep, file_name{l}];
+
+ upload_file = load(file);
+
+ sig_len_list(l) = upload_file.signal_params.sig_len;
+
+ % figure mask
+ plot_mask(upload_file.mask, upload_file.dgt_params.hop, upload_file.dgt_params.nbins, upload_file.fs);
+ axis tight;
+ saveas(gcf,fullfile(pathname,['mask_',num2str(upload_file.signal_params.sig_len),'.png']));
+
+
+ % figure window
+
+ plot_win(upload_file.dgt_params.win, upload_file.fs, upload_file.signal_params.sig_len, upload_file.dgt_params.win_type);
+ axis tight;
+ saveas(gcf,fullfile(pathname,['win_',num2str(upload_file.signal_params.sig_len),'.png']));
+
+
+ % mask area
+ mask = 1- upload_file.mask;
+
+ [mask_area, mask_area_ratio] = get_mask_area(mask);
+ mask_area_list(l) = mask_area;
+ mask_area_ratio_list(l) = mask_area_ratio;
+ end
+
+end
+%%
+% mask area
+figure;
+plot(sig_len_list, mask_area_list,'LineWidth',2.5);
+grid()
+set(gca,'YScale','log','XScale','log');
+xlabel('Signal length')
+ylabel('# time-frequency coefficients')
+title('Mask area')
+set(gca, 'FontSize', 15, 'fontName','Times');
+saveas(gcf,fullfile(pathname, 'mask_area.pdf'));
+
+% mask area ratio
+
+figure;
+plot(sig_len_list, mask_area_ratio_list,'LineWidth',2.5)
+grid()
+set(gca,'XScale','log');
+
+xlabel('Signal length')
+ylabel('%')
+title('Mask area ratio')
+set(gca, 'FontSize', 15, 'fontName','Times');
+saveas(gcf,fullfile(pathname, 'mask_area_ratio.pdf'));
+
+
+
+
+%% Computation time, mean and std
+n_exp = 10;
+[arrf_time, rrf_time, eigs_time, evdnrrf_time, evdnarrf_time,...,
+ arrf_time_mean, rrf_time_mean, evdnrrf_time_mean, evdnarrf_time_mean,...,
+ evdarrrf_mean, evdrrf_mean,eigs_mean, arrf_time_std, rrf_time_std,...,
+ evdnrrf_time_std, evdnarrf_time_std, evdarrrf_std, ....,
+ evdrrf_std, eigs_std] = perf_measures(file_name,n_exp);
+
+
+%% figure;
+% comparaisons temps de calcul des 3 algos
+
+figure;
+errorbar(sig_len_list, evdarrrf_mean, evdarrrf_std,'b-*','LineWidth',2.5); hold on;
+errorbar(sig_len_list, eigs_mean, eigs_std, 'r-*','LineWidth',2.5);
+errorbar(sig_len_list, evdrrf_mean, evdrrf_std,'m-*','LineWidth',2.5 );
+xlabel('signal length');
+ylabel('Computation time (s)')
+legend('Adaptative Range Finder + EVD/Nystr�m', 'eigs','Fixed Range Finder + EVD/Nystr�m',...,
+ 'Location','northwest')
+set(gca, 'FontSize', 15, 'fontName','Times');
+set(gca,'YScale','log','XScale','log');
+grid('on');
+axis tight;
+saveas(gcf,fullfile(pathname,['running_times','.png']));
+%%
+% comparaisons temps de calcul de tous les algos
+figure;
+
+errorbar(sig_len_list, arrf_time_mean, arrf_time_std,'LineWidth',2.5); hold on;
+errorbar(sig_len_list, rrf_time_mean, rrf_time_std,'LineWidth',2.5);
+errorbar(sig_len_list, eigs_mean, eigs_std, 'LineWidth',2.5);
+errorbar(sig_len_list, evdnarrf_time_mean, evdnarrf_time_std, 'LineWidth',2.5);
+errorbar(sig_len_list, evdnrrf_time_mean, evdnrrf_time_std, 'LineWidth',2.5);
+
+legend('Adaptative Range Finder','Fixed Range Finder','eigs',...,
+ 'EVD/Nystr�m(ARRF)','EVD/Nystr�m(RRF)','Location','northwest')
+set(gca, 'FontSize', 15, 'fontName','Times');
+set(gca,'YScale','log','XScale','log');
+grid('on');
+axis tight;
+xlabel('Signal length')
+ylabel('Running time (s)')
+saveas(gcf,fullfile(pathname,['running_times_by_step','.png']));
+
+%% Step by step: ratio of eigs running times (pas juste a revoir)
+% ratio
+
+
+[ratio_arrf_time_over_eigs,ratio_rrf_time_over_eigs,...,
+ ratio_evdnarrf_over_eigs,ratio_evdnrrf_over_eigs]= get_ratio_of_eigs_running_times(arrf_time, rrf_time, evdnarrf_time, evdnrrf_time,eigs_time);
+
+
+
+%mean ratio
+ratio_arrf_time_over_eigs_mean = mean(ratio_arrf_time_over_eigs,2)*100;
+ratio_rrf_time_over_eigs_mean = mean(ratio_rrf_time_over_eigs,2)*100;
+ratio_evdnarrf_over_eigs_mean = mean(ratio_evdnarrf_over_eigs, 2)*100;
+ratio_evdnrrf_over_eigs_mean = mean(ratio_evdnrrf_over_eigs, 2)*100;
+
+
+% std
+
+ratio_arrf_time_over_eigs_std = std(ratio_arrf_time_over_eigs,0,2)*100;
+ratio_rrf_time_over_eigs_std = std(ratio_rrf_time_over_eigs,0,2)*100;
+ratio_evdnarrf_over_eigs_std = std(ratio_evdnarrf_over_eigs, 0,2)*100;
+ratio_evdnrrf_over_eigs_std = std(ratio_evdnrrf_over_eigs, 0,2)*100;
+
+
+figure;
+errorbar(sig_len_list, ratio_arrf_time_over_eigs_mean, ratio_arrf_time_over_eigs_std,'LineWidth',2.5); hold on;
+errorbar(sig_len_list, ratio_rrf_time_over_eigs_mean, ratio_rrf_time_over_eigs_std,'LineWidth',2.5);
+errorbar(sig_len_list, ratio_evdnarrf_over_eigs_mean, ratio_evdnarrf_over_eigs_std, 'LineWidth',2.5);
+errorbar(sig_len_list, ratio_evdnrrf_over_eigs_mean, ratio_evdnrrf_over_eigs_std, 'LineWidth',2.5);
+
+legend('Adaptative Range Finder','Fixed Range Finder',...,
+ 'EVD/Nystr�m(ARRF)','EVD/Nystr�m(RRF)','Location','northwest')
+set(gca, 'FontSize', 15, 'fontName','Times');
+set(gca,'XScale','log');
+grid('on');
+axis tight;
+xlabel('Signal length')
+ylabel('Ratio of eigs running time (%)')
+saveas(gcf,fullfile(pathname,['running_times_ratio_by_step','.png']));
+
+%% error operator norm (erreur a revoir)
+
+[eigs_norm, arrfevdn_norm, rrfevdn_norm]= compute_error_operator_norm(file_name, n_exp);
+eigs_norm_mean = mean(eigs_norm,2);
+arrfevdn_norm_mean = mean(arrfevdn_norm,2);
+rrfevdn_norm_mean = mean(rrfevdn_norm, 2);
+
+
+eigs_norm_std = std(eigs_norm,0,2);
+arrfevdn_norm_std = std(arrfevdn_norm, 0, 2);
+rrfevdn_norm_std = std(rrfevdn_norm, 0, 2);
+
+figure;
+errorbar(sig_len_list, eigs_norm_mean , eigs_norm_std,'LineWidth',2.5); hold on;
+errorbar(sig_len_list, arrfevdn_norm_mean, arrfevdn_norm_std,'LineWidth',2.5);
+errorbar(sig_len_list, rrfevdn_norm_mean, rrfevdn_norm_std, 'LineWidth',2.5);
+
+legend('eigs','Adaptative Range Finder + EVD/Nystr�m(ARRF)',...,
+ 'Fixed Range Finder + EVD/Nystr�m(RRF)','Location','northwest')
+set(gca, 'FontSize', 15, 'fontName','Times');
+set(gca,'YScale','log','XScale','log');
+grid('on');
+axis tight;
+xlabel('Signal length')
+ylabel('Operator estimation error')
+saveas(gcf,fullfile(pathname, 'operator_error.pdf'));
+
+%% Estimated rank
+
+q_with = estimated_rank(file_name, n_exp);
+q_with_mean = mean(q_with, 2);
+q_with_std = std(q_with, 0, 2);
+
+figure;
+errorbar(sig_len_list, q_with_mean, q_with_std,'LineWidth',2)
+set(gca, 'FontSize', 15, 'fontName','Times');
+set(gca, 'YScale','log','XScale','log')
+xlabel('Signal length')
+ylabel('Estimated rank')
+grid('on');
+legend('Estimated rank','Location','northwest');
+saveas(gcf,fullfile(pathname,'rank_estimation.pdf'));
+
+
+%% Estimated rank / sig length
+rank_ratio = q_with./sig_len_list;
+rank_ratio_mean = mean(rank_ratio,2)*100;
+rank_ratio_std = std(rank_ratio_mean,0,2)*100;
+
+figure;
+errorbar(sig_len_list, rank_ratio_mean, rank_ratio_std,'LineWidth',2)
+set(gca, 'FontSize', 15, 'fontName','Times');
+set(gca,'XScale','log')
+xlabel('Signal length')
+ylabel('Estimated rank / signal length')
+grid('on');
+legend('Estimated rank');
+saveas(gcf,fullfile(pathname,'rank_estimation_over_siglen.pdf'));
+
+
+end
\ No newline at end of file
diff --git a/matlab/tfgm/experiments/solver.m b/matlab/tfgm/experiments/solver.m
new file mode 100644
index 0000000000000000000000000000000000000000..98e0894c91037af90ff06f1060408f43284232fd
--- /dev/null
+++ b/matlab/tfgm/experiments/solver.m
@@ -0,0 +1,43 @@
+function [gab_mul, direct_stft, adjoint_stft, q_mat_arrf, arrf_time,....,
+ q_mat_rrf, rrf_time, svd_res_arrf,arrfevdn_time, svd_res_rrf,....,
+ rrfevdn_time, svd_res_eigs, eigs_time, eigs_norm, arrfevdn_norm, ...,
+ rrfevdn_norm,q_with] =solver(tolerance, r, mask, dgt_params, signal_params)
+
+[direct_stft, adjoint_stft] = get_stft_operators(dgt_params, signal_params);
+gab_mul = gen_gabmul_operator(direct_stft, adjoint_stft, mask);
+
+
+tic;
+q_mat_arrf = adaptative_randomized_range_finder(gab_mul ,signal_params.sig_len, tolerance, r);
+arrf_time = toc;
+
+
+tic;
+q_mat_rrf = randomized_range_finder(gab_mul, signal_params.sig_len, size(q_mat_arrf,2));
+rrf_time = toc;
+
+
+tic;
+svd_res_arrf = EVD_nystrom(gab_mul, q_mat_arrf);
+arrfevdn_time= toc;
+
+tic;
+svd_res_rrf = EVD_nystrom(gab_mul, q_mat_rrf);
+rrfevdn_time= toc;
+
+
+tic;
+svd_res_eigs = EVD_eigs(gab_mul, signal_params.sig_len, size(q_mat_arrf,2) );
+eigs_time = toc;
+
+
+
+eigs_norm = error_operator_norm(gab_mul, svd_res_eigs);
+arrfevdn_norm = error_operator_norm(gab_mul, svd_res_arrf);
+rrfevdn_norm = error_operator_norm(gab_mul, svd_res_rrf);
+
+
+q_with = size(q_mat_arrf,2);
+
+
+end
\ No newline at end of file
diff --git a/matlab/tfgm/experiments/step_mask.m b/matlab/tfgm/experiments/step_mask.m
new file mode 100644
index 0000000000000000000000000000000000000000..df1cd14b19370a935bc097e29c92d6a229a2ac7d
--- /dev/null
+++ b/matlab/tfgm/experiments/step_mask.m
@@ -0,0 +1,84 @@
+clc ; clear; close all;
+%%
+
+pwd;
+pathname ='figures_JSTSP';
+if ~exist('figures_JSTSP','dir')
+ mkdir('figures_JSTSP');
+end
+addpath('figures_JSTSP')
+
+%%
+ind_loc = 5;
+ind_wd = 3;
+deb_ind_loc = 0;
+deb_ind_wd=0;
+resampling_fs = 8000;
+sig_len = 16384;
+%%
+
+
+param_gauss = get_win_gauss_param();
+
+
+win_len = param_gauss.win_len;
+win_type = param_gauss.win_type;
+alpha = param_gauss.alpha;
+seuil = param_gauss.seuil;
+radius = param_gauss.radius;
+
+%%
+sig_loc = load_localized_signal(ind_loc, resampling_fs, sig_len, deb_ind_loc);
+sig_wd = load_wideband_signal(ind_wd, resampling_fs, sig_len, deb_ind_wd);
+
+signals = generate_mix_signal(sig_wd, sig_loc);
+
+fs = resampling_fs;
+sig_len = length(sig_loc);
+signal_params = generate_signal_parameters(fs, sig_len);
+
+%% dgt
+dgt_params = generate_dgt_parameters(win_type, win_len);
+dgt_params.hop = 32; %
+dgt_params.nbins = 512;%
+[dgt, idgt] = get_stft_operators(dgt_params, signal_params);
+
+
+ tf_mat_wb = compute_dgt(signals.target, dgt );
+ tf_mat_loc = compute_dgt(signals.noise, dgt );
+
+
+%% Etape 1
+figure;
+subplot(131)
+set(gcf,'position',[1, 1, 1000 400]);
+mask = and(abs(tf_mat_wb)<alpha*abs(tf_mat_loc), abs(tf_mat_loc)>seuil);
+%figure('name','mask');
+plot_spectrogram(mask, dgt_params,signal_params, dgt );
+axis square;
+set(gca, 'FontSize', 20, 'fontName','Times');
+%saveas(gcf,fullfile(pathname, 'mask_cuicui_gauss_1.png'));
+
+
+%Etape 2
+
+se = strel('disk',radius);
+
+mask = imclose(mask,se);
+%figure('name','mask');
+subplot(132)
+plot_spectrogram(mask, dgt_params,signal_params, dgt );
+set(gca, 'FontSize', 20, 'fontName','Times');
+axis square;
+%saveas(gcf,fullfile(pathname, 'mask_cuicui_gauss_2.png'));
+
+
+subplot(133)
+mask = imopen(mask,se);
+%figure('name','mask');
+plot_spectrogram(mask, dgt_params,signal_params, dgt );
+set(gca, 'FontSize', 20, 'fontName','Times');
+axis square;
+%saveas(gcf,fullfile(pathname, 'mask_cuicui_gauss_3.png'));
+saveas(gcf,fullfile(pathname, 'mask_step.png'));
+
diff --git a/matlab/tfgm/experiments/test_gen_gabmul_operator.m b/matlab/tfgm/experiments/test_gen_gabmul_operator.m
new file mode 100644
index 0000000000000000000000000000000000000000..b3db5fa33e76f7d581ad5c34dd59b63d89ca954d
--- /dev/null
+++ b/matlab/tfgm/experiments/test_gen_gabmul_operator.m
@@ -0,0 +1,27 @@
+clc; clear; close all;
+%%
+setting='full';
+exp = get_experiment(setting);
+param = exp.data_params;
+t_lim = [exp.problem_params.t_val{1}, exp.problem_params.t_val{2}];
+f_lim = [exp.problem_params.f_val{1}, exp.problem_params.f_val{2}];
+win_type = exp.problem_params.win_type;
+
+%%
+param_pow = param{4};
+ problem_data = get_problem_data(param_pow,t_lim, f_lim, win_type);
+
+ %%
+ dgt_params = problem_data.dgt_params;
+signal_params = problem_data.signal_params;
+mask = problem_data.mask;
+[direct_stft, adjoint_stft] = get_stft_operators(dgt_params, signal_params);
+gab_mul = gen_gabmul_operator(direct_stft, adjoint_stft, mask);
+
+%%
+figure; imagesc(mask)
+x = randn(signal_params.sig_len,1);
+A = gab_mul(x);
+figure; plot(x);
+figure; plot(A);
+figure; sgram(A,'dynrange',90)
diff --git a/matlab/tfgm/experiments/test_get_problem_data.m b/matlab/tfgm/experiments/test_get_problem_data.m
new file mode 100644
index 0000000000000000000000000000000000000000..eb97a828cd04200b11ee15c0326f53cd37e0ca2a
--- /dev/null
+++ b/matlab/tfgm/experiments/test_get_problem_data.m
@@ -0,0 +1,22 @@
+clc; close all;
+
+%%
+setting='full';
+exp = get_experiment(setting);
+
+%%
+param = exp.data_params;
+t_lim = [exp.problem_params.t_val{1}, exp.problem_params.t_val{2}];
+f_lim = [exp.problem_params.f_val{1}, exp.problem_params.f_val{2}];
+win_type = exp.problem_params.win_type;
+
+%%
+figure;
+for k = 1:length(param)
+ param_pow = param{k};
+ problem_data = get_problem_data(param_pow,t_lim, f_lim, win_type);
+
+ figure(k);
+ plot_mask(problem_data.mask, problem_data.hop, problem_data.dgt_params.nbins, problem_data.signal_params.fs)
+
+end
\ No newline at end of file
diff --git a/matlab/tfgm/illustrations_gaborTools/compare_eigs_halko_gauss.m b/matlab/tfgm/illustrations_gaborTools/compare_eigs_halko_gauss.m
new file mode 100644
index 0000000000000000000000000000000000000000..d2b05c820890e0b441b1e2b25973829677bd31c4
--- /dev/null
+++ b/matlab/tfgm/illustrations_gaborTools/compare_eigs_halko_gauss.m
@@ -0,0 +1,132 @@
+clc; clear; close all;
+
+
+%%
+pwd;
+pathname ='figures_JSTSP';
+if ~exist('figures_JSTSP','dir')
+ mkdir('figures_JSTSP');
+end
+addpath('figures_JSTSP')
+%%
+
+ind_loc = 5;
+ind_wd = 3;
+deb_ind_loc = 0;
+deb_ind_wd=0;
+resampling_fs = 8000;
+sig_len = 16384;
+
+%% DGT params - signals - mask
+
+param_gauss = get_win_gauss_param();
+
+
+win_len = param_gauss.win_len;
+win_type = param_gauss.win_type;
+alpha = param_gauss.alpha;
+seuil = param_gauss.seuil;
+radius = param_gauss.radius;
+
+[signals, dgt_params, signal_params, mask, dgt,idgt ] = get_mix(ind_loc, ...,
+ ind_wd, deb_ind_loc, deb_ind_wd, resampling_fs, sig_len,...,
+ win_len, win_type, alpha, seuil, radius);
+
+
+
+%%
+% compute dgt
+
+tf_mat_engine = compute_dgt(signals.target, dgt );
+tf_mat_bird = compute_dgt(signals.noise, dgt );
+tf_mat_mix = compute_dgt(signals.mix, dgt );
+
+
+% mix -sdr
+
+sdr_mix = sdr(signals.target, signals.mix);
+fprintf('The SDR of the mixture is : %e\n', sdr_mix)
+
+
+%%
+
+figure('name','engine');
+plot_spectrogram(mask,dgt_params, signal_params, dgt);
+title('Source')
+set(gca, 'FontSize', 20, 'fontName','Times');
+
+
+%%
+
+
+%% generate Gabor mutliplier
+
+gab_mul = gen_gabmul_operator(dgt, idgt, mask);
+
+%% evd via halko
+
+% halko parameters
+
+tolerance_arrf = 1e-3;
+proba_arrf = 0.9999;
+r = compute_r(signal_params.sig_len, signal_params.sig_len, proba_arrf);
+
+% stage 1 Halko
+tic;
+q_mat = adaptative_randomized_range_finder(gab_mul, signal_params.sig_len, tolerance_arrf, r);
+t_arrf = toc;
+
+fprintf('Q shape : %.f %.f\n', size(q_mat));
+
+% stage 2 : Halko
+
+% Evd decomposition via Nystrom
+tic;
+evdn = EVD_nystrom(gab_mul, q_mat);
+t_evdn = toc;
+
+
+
+%% evd via eigs
+
+
+[U, D] = eigs(gab_mul, signal_params.sig_len, size(q_mat,2)) ;
+
+
+
+%%
+figure; semilogy(diag(D),'r-','LineWidth',2); hold on;
+semilogy(diag(evdn.D),'b-o','LineWidth',2);
+
+
+%% similarit� valeurs propres
+abs_err = abs(diag(evdn.D)-diag(D))./abs(diag(D));
+
+%%
+figure; semilogy(abs_err,'LineWidth',2);
+grid on;
+set(gca, 'FontSize', 20, 'fontName','Times');
+axis square;
+xlabel('$k$','Interpreter','latex');
+ylabel('Relative absolute error')
+saveas(gcf,fullfile(pathname, 'relerror_eigs_sevd_gauss.png'));
+saveas(gcf,fullfile(pathname, 'relerror_eigs_sevd_gauss.fig'));
+
+
+%% Correlations
+
+Gram_mat =abs( evdn.U.*U);
+figure; imagesc(Gram_mat)
+
+corr = max(Gram_mat, [], 2);
+%%
+figure;
+semilogy(sort(corr,'descend'),'LineWidth',2);
+% grid on;
+% axis square;
+% xlabel('$k$','Interpreter','latex');
+% ylabel('Correlation');
+% set(gca, 'FontSize', 20, 'fontName','Times');
+% saveas(gcf,fullfile(pathname, 'correlation_eigs_sevd_gauss.png'));
+
+%%
diff --git a/matlab/tfgm/illustrations_gaborTools/exp_eigenval_win.m b/matlab/tfgm/illustrations_gaborTools/exp_eigenval_win.m
new file mode 100644
index 0000000000000000000000000000000000000000..22ef5608fec0b0a1e8970cf627f367875bfd06bb
--- /dev/null
+++ b/matlab/tfgm/illustrations_gaborTools/exp_eigenval_win.m
@@ -0,0 +1,349 @@
+clc; clear; close all
+
+%%
+% experiments with
+% - wideband sound: engine(Genesis)
+% - localized sound: birdsong (Genesis)
+
+%%
+make_wav_pairs() % make sure alls pairs are ok
+%% Figures Directory
+
+pwd;
+pathname ='figures_JSTSP';
+if ~exist('figures_JSTSP','dir')
+ mkdir('figures_JSTSP');
+end
+addpath('figures_JSTSP')
+
+
+
+%%
+
+ind_loc = 5;
+ind_wd = 3;
+deb_ind_loc = 0;
+deb_ind_wd=0;
+resampling_fs = 8000;
+sig_len = 16384;
+
+
+%%
+param_hann = get_win_hann_param();
+param_gauss = get_win_gauss_param();
+params = {param_hann, param_gauss};
+
+
+%%
+tic;
+masks = {};
+
+for k = 1:length(params)
+
+ %win_len = params{k}.win_len;
+ %win_type = params{k}.win_type;
+
+ fprintf("We pick %s window of length %.f\n", params{k}.win_type, params{k}.win_len);
+
+ %alpha = params{k}.alpha;
+ %seuil = params{k}.seuil;
+ %radius = params{k}.radius;
+
+ fprintf("The parameters for smoothing the mask are: \n")
+ fprintf("alpha = %f\n", params{k}.alpha);
+ fprintf("seuil = %f\n", params{k}.seuil);
+ fprintf("radius = %f\n", params{k}.radius);
+
+ [signals, dgt_params, signal_params, mask, dgt, idgt ] = get_mix(ind_loc, ...,
+ ind_wd, deb_ind_loc, deb_ind_wd, resampling_fs, sig_len,...,
+ params{k}.win_len, params{k}.win_type, params{k}.alpha, params{k}.seuil, params{k}.radius);
+
+ params{k}.dgt_params = dgt_params;
+ params{k}.signal_params = signal_params;
+ params{k}.dgt = dgt;
+ params{k}.idgt = idgt;
+ masks{k} = mask;
+end
+toc;
+
+%%
+masks{3}= and(masks{1},masks{2});
+
+for k = 1:length(masks)-1
+
+ figure(k);
+
+ %imagesc(masks{k})
+ plot_spectrogram(masks{k}, params{k}.dgt_params, params{k}.signal_params, params{k}.dgt);
+ title(params{k}.win_type)
+ set(gca, 'FontSize', 20, 'fontName','Times');
+ %saveas(gcf,fullfile(pathname, [params{k}.win_type,'.pdf']));
+end
+
+figure;
+imagesc(masks{3})
+title('Intersection')
+%saveas(gcf,fullfile(pathname, 'intersection.pdf'));
+
+%%
+figure;
+
+imagesc(masks{1} - masks{2})
+colorbar()
+title('Mask difference: gauss -hann');
+saveas(gcf,fullfile(pathname, 'mask_difference.pdf'));
+
+
+%% parametres Halko
+
+r=2500;
+%% EVD pour hann
+
+evdn_hann = cell(length(masks),1);
+for k=1: length(masks)
+
+ disp(k);
+ gab_mul = gen_gabmul_operator(params{1}.dgt, params{1}.idgt, masks{k});
+ tic;
+ q_mat = randomized_range_finder(gab_mul, sig_len,r);
+ t1= toc;
+ fprintf(" runtimes for Q: %f\n", t1);
+ %
+ tic;
+ evdn = EVD_nystrom(gab_mul, q_mat);
+ t2 = toc;
+ evdn_hann{k} = evdn;
+ fprintf(" runtimes for nystrom: %f\n", t2);
+end
+
+
+%% EVD avec Gauss
+
+evdn_gauss = cell(length(masks),1);
+
+for k=1: length(masks)
+ disp(k)
+ gab_mul = gen_gabmul_operator(params{2}.dgt, params{2}.idgt, masks{k});
+ tic;
+ q_mat = randomized_range_finder(gab_mul, sig_len, r);
+ t1= toc;
+
+ fprintf(" runtimes for Q-gauss: %f\n", t1);
+ tic;
+ evdn = EVD_nystrom(gab_mul, q_mat);
+ t2 = toc;
+
+ evdn_gauss{k} = evdn;
+ fprintf(" runtimes for nystrom -gauss: %f\n", t2);
+end
+
+%% les valeurs propres
+figure;
+
+D1 = diag(evdn_hann{1}.D);
+D2 = diag(evdn_hann{2}.D);
+D3 = diag(evdn_hann{3}.D);
+D4= diag(evdn_gauss{1}.D);
+D5 = diag(evdn_gauss{2}.D);
+D6 = diag(evdn_gauss{3}.D);
+
+semilogy(D1, 'Linewidth',4);
+hold on;
+semilogy(D2, 'Linewidth',4);
+semilogy(D3 , 'Linewidth',4);
+semilogy(D4, 'Linewidth',4);
+semilogy(D5, 'Linewidth',4);
+semilogy(D6, 'Linewidth',4);
+grid on;
+
+
+xlabel({'index = $k$'},'Interpreter','latex');
+ylabel({' Eigenvalues $\sigma[k]$'},'Interpreter','latex');
+legend('Hann 256 - mask Hann 256', 'Hann 256 - mask Gauss 128' ,...,
+ 'Hann 256 - mask Intersection', 'Gauss 128 - mask Gauss 128', ...,
+ 'Gauss 128 - mask Hann 256' ,'Gauss 128 - mask Intersection',...,
+ 'Location','southwest');
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(pathname, 'eigval_cuicui_gauss_hann.png'));
+saveas(gcf,fullfile(pathname, 'eigval_cuicui_gauss_hann.fig'));
+
+
+
+%% Les vecteurs propres gauss
+U_g = evdn_gauss{2}.U;
+dynrange=90;
+for k =1:15
+ figure(k)
+ plot_spectrogram(U_g(:,k), params{2}.dgt_params,params{2}.signal_params,...,
+ params{2}.dgt,dynrange);
+ set(gca, 'FontSize', 20, 'fontName','Times');
+ axis square;
+ saveas(gcf,fullfile(pathname, ['eigval_cuicui_gauss_', num2str(k), '.png']));
+end
+
+
+%% les vecteurs propres hann
+
+U_h = evdn_hann{1}.U;
+for k=1:10
+ figure(k)
+
+ plot_spectrogram(U_h(:,k), params{1}.dgt_params,params{1}.signal_params,...,
+ params{1}.dgt);
+ set(gca, 'FontSize', 20, 'fontName','Times');
+ axis square;
+ saveas(gcf,fullfile(pathname, ['eigval_cuicui_hann_', num2str(k), '.png']));
+
+end
+
+%% Pour le papier : valeurs propres
+
+
+i_g = 1540;
+i_h = 1585;
+figure;
+set(gcf,'position',[1, 1 1100 400]);
+subplot(121);
+plot_spectrogram(masks{2}, params{2}.dgt_params, params{2}.signal_params, params{2}.dgt);
+set(gca, 'FontSize', 20, 'fontName','Times');
+axis square
+subplot(122);
+
+semilogy(D5, 'b','Linewidth',4); %Gauss
+hold on;
+semilogy(D2, 'r','Linewidth',4); %Hann
+plot(1,D5(1),'bo',i_h,D2(i_h),'r^','Linewidth',4,'MarkerSize',12) % Gauss -hann : l=1, l = 2000
+plot(1,D2(1),'r^',i_g,D5(i_g),'bo','Linewidth',4,'MarkerSize',12); %Hann -Gauss l = 2000
+grid on;
+
+
+xlabel({'index = $k$'},'Interpreter','latex');
+ylabel({' Eigenvalues $\sigma[k]$'},'Interpreter','latex');
+
+legend({'Gauss ','hann','$\lambda_1$ = 1 , $\lambda_{1540} = 2.254 \times 10^{-4}$',...,
+ '$\lambda_1$ = 1 , $\lambda_{1585} = 6.399 \times 10^{-5}$'},'Interpreter','latex','Location','southwest');
+
+
+set(gca, 'FontSize', 20, 'fontName','Times');
+
+saveas(gcf,fullfile(pathname, 'eigs_illustration.png'));
+saveas(gcf,fullfile(pathname, 'eigs_illustration.fig'));
+
+%% les vecteurs propres
+
+%
+close all;
+dynrange=90;
+
+U_h = evdn_hann{2}.U;
+U_g = evdn_gauss{2}.U;
+
+i_g = 1540;
+i_h = 1585;
+figure;
+set(gcf,'position',[0.6, 0.6, 900 900]);
+
+ subplot(221);
+
+plot_spectrogram( U_g(:,1), params{2}.dgt_params,params{2}.signal_params,...,
+ params{2}.dgt,dynrange);
+set(gca, 'FontSize', 20, 'fontName','Times');
+axis square;
+
+
+subplot(222);
+plot_spectrogram(U_h(:,1), params{1}.dgt_params,params{1}.signal_params,...,
+ params{1}.dgt,dynrange);
+set(gca, 'FontSize', 20, 'fontName','Times');
+axis square;
+
+
+subplot(223);
+plot_spectrogram(U_g(:,i_g), params{2}.dgt_params,params{2}.signal_params,...,
+ params{2}.dgt,dynrange);
+set(gca, 'FontSize', 20, 'fontName','Times');
+axis square;
+
+subplot(224);
+plot_spectrogram(U_h(:,i_h), params{1}.dgt_params,params{1}.signal_params,...,
+ params{1}.dgt,dynrange);
+set(gca, 'FontSize', 20, 'fontName','Times');
+axis square;
+
+saveas(gcf,fullfile(pathname, 'eigs_mask_gauss.png'));
+
+saveas(gcf,fullfile(pathname, 'eigs_mask_gauss.fig'));
+
+
+%% figure des fenetres et leurs spectrogrammes
+
+%hann
+
+win_hann = params{1}.dgt_params.win;
+win_hann = fftshift(win_hann);
+
+figure;
+plot(win_hann,'LineWidth',3);
+grid on;
+legend('Hann')
+set(gca, 'FontSize', 20, 'fontName','Times');
+
+saveas(gcf,fullfile(pathname, 'hann_win.fig'));
+
+saveas(gcf,fullfile(pathname, 'hann_win.png'));
+figure;
+
+dgt_hann_win = compute_dgt(win_hann, params{1}.dgt);
+plotdgtreal(dgt_hann_win, params{1}.dgt_params.hop, params{1}.dgt_params.nbins, ...,
+ params{1}.signal_params.fs,'dynrange',90)
+%plot_spectrogram(win_hann, params{1}.dgt_params, params{1}.signal_params, params{1}.dgt, dynrange);
+grid on;
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(pathname, 'stft_hann_win.fig'));
+saveas(gcf,fullfile(pathname, 'stft_hann_win.png'));
+%%
+
+%gauss
+
+win_gauss= params{2}.dgt_params.win;
+win_gauss = fftshift(win_gauss);
+figure;
+plot(win_gauss,'LineWidth',3);
+set(gca, 'FontSize', 20, 'fontName','Times');
+grid on;
+legend('Gauss')
+saveas(gcf,fullfile(pathname, 'gauss_win.fig'));
+saveas(gcf,fullfile(pathname, 'gauss_win.png'));
+figure;
+dynrange=90;
+dgt_gauss_win = compute_dgt(win_gauss, params{2}.dgt);
+plotdgtreal(dgt_gauss_win, params{2}.dgt_params.hop, params{2}.dgt_params.nbins, ...,
+ params{2}.signal_params.fs,'dynrange',90)
+grid on;
+%ylabel('Frequency (kHz)')
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(pathname, 'stft_gauss_win.fig'));
+saveas(gcf,fullfile(pathname, 'stft_gauss_win.png'));
+%% les spectres
+%hann
+figure;
+[phann,w_hann] = pwelch( win_hann, length(win_hann));
+plot(w_hann/pi,10*log10(phann),'LineWidth',1.5);
+grid on;
+legend('spectre-Hann window')
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(pathname, 'spectre_hann_win.fig'));
+saveas(gcf,fullfile(pathname, 'spectre_hann_win.png'));
+% gauss
+figure;
+[pgauss,w_gauss] = pwelch( win_gauss, length(win_gauss));
+plot(w_gauss/pi,10*log10(pgauss),'LineWidth',1.5);
+grid on;
+legend('spectre-Gaussian window')
+set(gca, 'FontSize', 20, 'fontName','Times');
+ saveas(gcf,fullfile(pathname, 'spectre_gauss_win.fig'));
+ saveas(gcf,fullfile(pathname, 'spectre_gauss_win.png'));
+%%
+
+save('evdn_gauss_hann.mat','evdn_hann','evdn_gauss','params','masks');
+%
\ No newline at end of file
diff --git a/matlab/tfgm/illustrations_gaborTools/illustration_cuicui_eigenvalues.m b/matlab/tfgm/illustrations_gaborTools/illustration_cuicui_eigenvalues.m
new file mode 100644
index 0000000000000000000000000000000000000000..0734b64b1a95af0e7c94a7935d65d3580c49882d
--- /dev/null
+++ b/matlab/tfgm/illustrations_gaborTools/illustration_cuicui_eigenvalues.m
@@ -0,0 +1,144 @@
+function [signal_params,dgt_params, signals,sdr_mix, mask, mask_area,....,
+ gab_mul,q_mat,evdn] = illustration_cuicui_eigenvalues(win_type, resampling_fs, sig_len,approx_win_len )
+
+
+%%
+
+pwd;
+pathname ='figures_JSTSP';
+if ~exist('figures_JSTSP','dir')
+ mkdir('figures_JSTSP');
+end
+addpath('figures_JSTSP')
+%% Signals parameters ans DGT parameters
+
+signal_params = generate_signal_parameters(resampling_fs, sig_len);
+dgt_params = generate_dgt_parameters(win_type, approx_win_len);
+
+%% Gabor frame operators
+
+[direct_dgt, adjoint_dgt, tight_direct_dgt, tight_adjoint_dgt,win,...,
+ win_tight] = get_dgt_operators(dgt_params, signal_params);
+
+%% Load bird and engine signal from GENESIS
+
+
+ind_engine = 4;
+ind_bird = 5;
+
+deb = 0;
+[x_engine, x_bird] = load_pairs(ind_engine, ind_bird, resampling_fs, signal_params.sig_len, deb);
+
+%gamma=0.75;
+signals = generate_mix_signal(x_engine, x_bird);
+
+
+%% plot signals spectrograms
+
+% compute dgt
+
+dgt = tight_direct_dgt;
+tf_mat_engine = compute_dgt(signals.target, dgt);
+tf_mat_bird = compute_dgt(signals.noise, dgt);
+tf_mat_mix = compute_dgt(signals.mix, dgt);
+
+
+%plot their spectrogram
+
+figure('name','engine'); plot_spectrogram(tf_mat_engine,dgt_params, signal_params, dgt);
+title('engine')
+figure('name','bird'); plot_spectrogram(tf_mat_bird, dgt_params, signal_params, dgt);
+title('Bird')
+figure('name','mix'); plot_spectrogram(tf_mat_mix, dgt_params,signal_params, dgt);
+title('mix : engine-bird')
+
+
+%% Mix - SDR
+
+sdr_mix = sdr(signals.target, signals.mix);
+
+fprintf('The SDR of the mixture is : %e\n', sdr_mix)
+
+%% Mask generation
+
+% mask
+alpha=2; seuil = 0.02; radius = 3;
+mask = generate_mask(tf_mat_engine, tf_mat_bird, alpha, seuil, radius);
+[mask_area, mask_area_ratio] = get_mask_area(mask);
+
+%plot mask
+figure('name','mask'); plot_spectrogram(mask, dgt_params,signal_params, dgt);
+title(['mask : mask-area = ',num2str(mask_area)])
+
+%% EVD with Halko
+
+tolerance_arrf = 1e-6;
+proba_arrf = 1 - 1e-9;
+
+r = compute_r(signal_params.sig_len, signal_params.sig_len, proba_arrf);
+
+
+% Generate multiplier
+gab_mul = gen_gabmul_operator(tight_direct_dgt, tight_adjoint_dgt, mask);
+
+%stage 1
+q_mat = adaptative_randomized_range_finder(gab_mul, signal_params.sig_len, tolerance_arrf, r);
+
+fprintf('Q shape : %.f %.f\n', size(q_mat));
+
+% stage 2 : Halko
+
+% Evd decomposition via Nystrom
+
+evdn = EVD_nystrom(gab_mul, q_mat);
+
+%% Eigenvalue plot
+
+ss=diag(evdn.D);
+
+figure;
+set(gcf,'position',[1, 1 1100 400]);
+subplot(121);
+plot_spectrogram(mask, dgt_params,signal_params, dgt);
+set(gca, 'FontSize', 20, 'fontName','Times');
+axis square
+subplot(122);
+
+%%
+semilogy(diag(evdn.D), 'Linewidth',3);
+hold on;
+plot(45,ss(45),'k-*','Linewidth',3);
+plot(30,ss(30),'m-*','Linewidth',3);
+plot(1650,ss(1650),'g-*','Linewidth',3);
+plot(1740,ss(1740),'c-*','Linewidth',3);
+grid on;
+xlabel('k')
+legend({'$\sigma_k$','$\lambda$ = 45','$\lambda$ = 30', '$\lambda$ = 1650','$\lambda$ = 1740'},...,
+ 'Interpreter','latex','Location','southwest')
+axis square
+set(gca, 'FontSize', 20, 'fontName','Times');
+%saveas(gcf,fullfile(pathname, 'eigenvalues_full_mask.png'));
+
+%%
+%eigsvect_hann = [45, 18, 1650, 2051];
+
+figure;
+set(gcf,'position',[1, 1 900 400]);
+subplot(221);
+plot_spectrogram(evdn.U(:,1), dgt_params,signal_params, dgt);
+set(gca, 'FontSize', 20, 'fontName','Times');
+subplot(222);
+plot_spectrogram(evdn.U(:,2), dgt_params,signal_params, dgt);
+set(gca, 'FontSize', 20, 'fontName','Times');
+subplot(223);
+plot_spectrogram(evdn.U(:,30), dgt_params,signal_params, dgt);
+set(gca, 'FontSize', 20, 'fontName','Times');
+subplot(224);
+plot_spectrogram(evdn.U(:,1438), dgt_params,signal_params, dgt);
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(pathname, 'eigvectors_gauss.png'));
+
+%%
+save('illustration.mat','signal_params','dgt_params', 'signals','sdr_mix', 'mask', 'mask_area',....,
+ 'gab_mul', 'q_mat', 'evdn')
+end
\ No newline at end of file
diff --git a/matlab/tfgm/illustrations_gaborTools/rank_asfunctionof_masksize.m b/matlab/tfgm/illustrations_gaborTools/rank_asfunctionof_masksize.m
new file mode 100644
index 0000000000000000000000000000000000000000..dda7b5209f339314e29b48f2c4e980f64ebefdc8
--- /dev/null
+++ b/matlab/tfgm/illustrations_gaborTools/rank_asfunctionof_masksize.m
@@ -0,0 +1,100 @@
+clc; clear; close all;
+
+% The script permet d'�tuider l'estimation du rang par Halko vs eigs
+%% Repertoires pour les figures
+
+pwd;
+pathname ='figures_JSTSP';
+if ~exist('figures_JSTSP','dir')
+ mkdir('figures_JSTSP');
+end
+addpath('figures_JSTSP')
+
+%% Parametres du signal
+
+resampling_fs=8000; % frequence d'echantillonage
+sig_len = 8192; % longueur du signal
+
+tolerance = 1e-6; % parametres pour Halko
+proba = 1-1e-4;
+r = compute_r(sig_len, sig_len, proba);
+
+%% Generation des parametres de la DGT
+
+
+t_lim = [0.4, 0.6];
+f_lims = 0.2:0.05:0.6;
+
+win_type = 'hann';
+
+approx_win_len = 256;
+
+dgt_params = generate_dgt_parameters(win_type, approx_win_len);
+signal_params = generate_signal_parameters(resampling_fs, sig_len);
+[dgt, idgt] = get_stft_operators(dgt_params, signal_params);
+
+
+%%
+mask_area_list = zeros(length(f_lims),1);
+ranks_arrf = zeros(length(f_lims),1);
+ranks_eigs= zeros(length(f_lims),1);
+t_arrf = zeros(length(f_lims),1);
+t_eigs = zeros(length(f_lims),1);
+s_vec_list = cell(length(f_lims),1);
+
+
+seuil = 10^(-14); % pour la EVD via eigs
+%%
+for k =1:length(f_lims)
+ % Mask Generation
+
+ f_lim =[0.1, f_lims(k)];
+ mask = generate_rectangular_mask(dgt_params.nbins,dgt_params.hop, signal_params.sig_len, t_lim, f_lim);
+
+ [mask_area, mask_area_ratio] = get_mask_area(mask);
+ mask_area_list(k) = mask_area;
+
+ fprintf('mask area:%.f\n', mask_area)
+ if mask_area>signal_params.sig_len
+ fprintf('attention %.f\n',k)
+ end
+ figure(k);
+ plot_mask(mask, dgt_params.nbins, dgt_params.hop, signal_params.fs);
+
+ %% Gabor multiplier
+ gab_mul = gen_gabmul_operator(dgt, idgt, mask);
+
+ %% EVD via Halko
+ tic;
+ q_mat = adaptative_randomized_range_finder(gab_mul, sig_len, tolerance, r);
+ t_arrf(k) = toc;
+
+ ranks_arrf(k)= size(q_mat,2);
+ %% EVD via eigs
+ tic;
+ [u_mat,s] = eigs(gab_mul, signal_params.sig_len, signal_params.sig_len);
+ t_eigs(k) = toc;
+
+ s_vec = diag(s);
+ s_vec_list{k} = s_vec;
+ ranks_eigs(k) = length(s_vec(s_vec > seuil));
+end
+
+%%
+save('rank_estimation.mat','ranks_arrf','ranks_eigs', 'mask_area_list',...,
+ 't_arrf','t_eigs', 's_vec_list');
+
+%% plot figures
+
+figure;
+plot(mask_area_list,ranks_arrf,'LineWidth',3); hold on;
+plot(mask_area_list,ranks_eigs,'LineWidth',3);
+set(gca, 'FontSize', 15, 'fontName','Times');
+%set(gca,'XScale','log')
+xlabel('Mask area')
+ylabel('Estimated rank')
+grid('on');
+legend('Halko', 'eigs', 'Location','northwest');
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(pathname,'rank_estimation_gauss.png'));
+saveas(gcf,fullfile(pathname,'rank_estimation_gauss.fig'));
diff --git a/matlab/tfgm/illustrations_gaborTools/rank_estimation_halko_vs_eigs_gausswin.m b/matlab/tfgm/illustrations_gaborTools/rank_estimation_halko_vs_eigs_gausswin.m
new file mode 100644
index 0000000000000000000000000000000000000000..ae7c2a8efc01af112c42250146a2b4e5e681ec79
--- /dev/null
+++ b/matlab/tfgm/illustrations_gaborTools/rank_estimation_halko_vs_eigs_gausswin.m
@@ -0,0 +1,99 @@
+clc; clear; close all;
+
+% The script permet d'�tuider l'estimation du rang par Halko vs eigs
+%% Repertoires pour les figures
+
+pwd;
+pathname ='figures_JSTSP';
+if ~exist('figures_JSTSP','dir')
+ mkdir('figures_JSTSP');
+end
+addpath('figures_JSTSP')
+
+%% Parametres du signal
+
+resampling_fs=8000; % frequence d'echantillonage
+sig_len = 8192; % longueur du signal
+
+tolerance = 1e-6; % parametres pour Halko
+proba = 1-1e-4;
+r = compute_r(sig_len, sig_len, proba);
+
+%% Generation des parametres de la DGT
+
+
+t_lim = [0.4, 0.6];
+f_lims = 0.2:0.05:0.6;
+
+win_type = 'gauss';
+
+approx_win_len = 64; % changer sinon trop long.
+
+dgt_params = generate_dgt_parameters(win_type, approx_win_len);
+signal_params = generate_signal_parameters(resampling_fs, sig_len);
+[dgt, idgt] = get_stft_operators(dgt_params, signal_params);
+
+
+%%
+mask_area_list = zeros(length(f_lims),1);
+ranks_arrf = zeros(length(f_lims),1);
+ranks_eigs= zeros(length(f_lims),1);
+t_arrf = zeros(length(f_lims),1);
+t_eigs = zeros(length(f_lims),1);
+s_vec_list = cell(length(f_lims),1);
+
+
+seuil = 10^(-14); % pour la EVD via eigs
+%%
+for k =1:length(f_lims)
+ fprintf("Je suis a l'iteration numero %.f patiente\n",k);
+ % Mask Generation
+ %%
+ f_lim =[0.1, f_lims(k)];
+ mask = generate_rectangular_mask(dgt_params.nbins,dgt_params.hop, signal_params.sig_len, t_lim, f_lim);
+
+ [mask_area, mask_area_ratio] = get_mask_area(mask);
+ mask_area_list(k) = mask_area;
+
+ fprintf('mask area:%.f\n', mask_area)
+ if mask_area>signal_params.sig_len
+ fprintf('attention %.f\n',k)
+ end
+ figure(k);
+ plot_mask(mask, dgt_params.nbins, dgt_params.hop, signal_params.fs);
+ %% Gabor multiplier
+ gab_mul = gen_gabmul_operator(dgt, idgt, mask);
+
+ %% EVD via Halko
+ tic;
+ q_mat = adaptative_randomized_range_finder(gab_mul, sig_len, tolerance, r);
+ t_arrf(k) = toc;
+
+ ranks_arrf(k)= size(q_mat,2);
+ %% EVD via eigs
+ tic;
+ [u_mat,s] = eigs(gab_mul, signal_params.sig_len, signal_params.sig_len);
+ t_eigs(k) = toc;
+
+ s_vec = diag(s);
+ s_vec_list{k} = s_vec;
+ ranks_eigs(k) = length(s_vec(s_vec > seuil));
+end
+
+%%
+save('rank_estimation.mat','ranks_arrf','ranks_eigs', 'mask_area_list',...,
+ 't_arrf','t_eigs', 's_vec_list');
+
+%% plot figures
+
+figure;
+plot(mask_area_list,ranks_arrf,'LineWidth',3); hold on;
+plot(mask_area_list,ranks_eigs,'LineWidth',3);
+%set(gca,'XScale','log')
+xlabel('Mask area')
+ylabel('Estimated rank')
+grid('on');
+legend('Rand-EVD', 'eigs', 'Location','northwest');
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(pathname,'rank_estimation_gauss.png'));
+saveas(gcf,fullfile(pathname,'rank_estimation_gauss.fig'));
diff --git a/matlab/tfgm/illustrations_gaborTools/run_illustration_cuicui_eigenvalues.m b/matlab/tfgm/illustrations_gaborTools/run_illustration_cuicui_eigenvalues.m
new file mode 100644
index 0000000000000000000000000000000000000000..ad95d49d0109fbda199ce5c590a27bfddecaebf6
--- /dev/null
+++ b/matlab/tfgm/illustrations_gaborTools/run_illustration_cuicui_eigenvalues.m
@@ -0,0 +1,14 @@
+clc; clear; close all;
+
+%%
+
+resampling_fs=8000;
+sig_len = 16384;
+
+win_type = 'hann';
+approx_win_len = 128;
+
+%%
+
+[signal_params,dgt_params, signals,sdr_mix, mask, mask_area,....,
+ gab_mul,q_mat,evdn] = illustration_cuicui_eigenvalues(win_type, resampling_fs, sig_len,approx_win_len );
diff --git a/matlab/tfgm/scripts/combmul_norm.m b/matlab/tfgm/scripts/combmul_norm.m
new file mode 100644
index 0000000000000000000000000000000000000000..ae352b7a3acd91bc4d0965c3e321c0a128f600b7
--- /dev/null
+++ b/matlab/tfgm/scripts/combmul_norm.m
@@ -0,0 +1,145 @@
+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
diff --git a/matlab/tfgm/scripts/compare_win.m b/matlab/tfgm/scripts/compare_win.m
new file mode 100644
index 0000000000000000000000000000000000000000..471a6db26f43837b23dfa4e49b024831449cf789
--- /dev/null
+++ b/matlab/tfgm/scripts/compare_win.m
@@ -0,0 +1,93 @@
+ 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'));
+
+
diff --git a/matlab/tfgm/scripts/gabmul_eig_dgtvar.m b/matlab/tfgm/scripts/gabmul_eig_dgtvar.m
new file mode 100644
index 0000000000000000000000000000000000000000..e37c5bccd3a10be686ff7b309e831454f50ff994
--- /dev/null
+++ b/matlab/tfgm/scripts/gabmul_eig_dgtvar.m
@@ -0,0 +1,151 @@
+
+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');
+
+
diff --git a/matlab/tfgm/scripts/illustration_with_cuicui.m b/matlab/tfgm/scripts/illustration_with_cuicui.m
new file mode 100644
index 0000000000000000000000000000000000000000..49830ece494ee09f2c9b99943e0120b19cd81c88
--- /dev/null
+++ b/matlab/tfgm/scripts/illustration_with_cuicui.m
@@ -0,0 +1,378 @@
+clc; clear; close all;
+%%
+% experiments with
+% - wideband sound: engine(Russia)
+% - localized sound: birdsong
+
+
+%% DGT and signals parameters
+resampling_fs=8000;
+sig_len = 16384;
+
+win_type = 'hann';
+approx_win_len = 128;
+
+signal_params = generate_signal_parameters(resampling_fs, sig_len);
+dgt_params = generate_dgt_parameters(win_type, approx_win_len);
+
+
+%% Generate gabor frames operators
+
+[direct_stft, adjoint_stft, tight_direct_stft, tight_adjoint_stft,win,...,
+ win_tight] = get_stft_operators(dgt_params, signal_params);
+
+
+% plot associated window
+figure;
+plot_win(win_tight, signal_params.fs, signal_params.sig_len, win_type)
+title([num2str(win_type), ' - window']);
+
+saveas(gcf,fullfile(pathname, [num2str(win_type),'_window.png']));
+%% Load signals
+
+ind_engine = 4;
+ind_bird = 5;
+
+deb = 0;
+[x_engine, x_bird] = load_pairs(ind_engine, ind_bird, resampling_fs, signal_params.sig_len, deb);
+
+%gamma=0.75;
+signals = generate_mix_signal(x_engine, x_bird);
+
+
+%% plot signals spectrogrammes
+
+% compute dgt
+
+stft = tight_direct_stft;
+tf_mat_engine = compute_dgt(signals.target, stft);
+tf_mat_bird = compute_dgt(signals.noise, stft);
+tf_mat_mix = compute_dgt(signals.mix, stft);
+
+
+%plot their spectrogram
+
+figure('name','engine'); plot_spectrogram(tf_mat_engine,dgt_params, signal_params, stft);
+title('engine')
+figure('name','bird'); plot_spectrogram(tf_mat_bird, dgt_params, signal_params, stft);
+title('Bird')
+figure('name','mix'); plot_spectrogram(tf_mat_mix, dgt_params,signal_params, stft);
+title('mix : engine-bird')
+
+
+%% Mix - SDR
+
+sdr_mix = sdr(signals.target, signals.mix);
+
+
+fprintf('The SDR of the mixture is : %e\n', sdr_mix)
+
+%% Mask generation
+
+% mask
+alpha=2; seuil = 0.02; radius = 3;
+mask = generate_mask(tf_mat_engine, tf_mat_bird, alpha, seuil, radius);
+[mask_area, mask_area_ratio] = get_mask_area(mask);
+
+%plot mask
+figure('name','mask'); plot_spectrogram(mask, dgt_params,signal_params, stft);
+title(['mask : mask-area = ',num2str(mask_area)])
+
+figure;
+ plot_spectrogram((1-mask).*tf_mat_bird, dgt_params,signal_params, stft);
+
+
+%% Halko parameters for EVD diagonalisation zone par zone
+
+tolerance_arrf = 1e-6;
+proba_arrf = 1 - 1e-9;
+
+r = compute_r(signal_params.sig_len, signal_params.sig_len, proba_arrf);
+
+[~,n_labels] = bwlabel(mask);
+%n_labels =2;
+t_arrf = zeros(n_labels,1);
+t_evdn = zeros(n_labels,1);
+
+s_vec = zeros(signal_params.sig_len,n_labels);
+u_vec = zeros(signal_params.sig_len*3000,n_labels);
+
+rank_q = zeros(n_labels,1);
+mask_area_list = zeros(n_labels,1);
+%%
+for k = 1:n_labels
+ [mask_label,~] = bwlabel(mask);
+
+ % on construit chaque mask
+ mask_label(mask_label~=k)=0;
+ mask_ =mask_label;
+ figure(k); plotdgtreal(mask_, dgt_params.hop, dgt_params.nbins, signal_params.fs);
+ title(['k=', num2str(k)])
+
+ [mask_area_, mask_area_ratio_] = get_mask_area(mask_);
+ mask_area_list(k) = mask_area_;
+ fprintf('mask area = %.f\n',mask_area_);
+
+ %construction du multiplicateur associe a chaque masque
+ gab_mul = gen_gabmul_operator(tight_direct_stft, tight_adjoint_stft, mask_);
+
+ tic;
+ q_mat = adaptative_randomized_range_finder(gab_mul, sig_len, tolerance_arrf, r);
+ t_arrf(k) = toc;
+
+ rank_q(k) = size(q_mat,2);
+ tic;
+ evdn = EVD_nystrom(gab_mul, q_mat);
+ t_evdn(k) = toc;
+ s_vec(1:size(q_mat,2),k) = diag(evdn.D);
+ u_vec(1:size(q_mat,1)*size(q_mat,2),k) = evdn.U(:);
+
+end
+
+%% diagonalisation complete
+gab_mul = gen_gabmul_operator(tight_direct_stft, tight_adjoint_stft, mask);
+
+%stage 1
+q_matc = adaptative_randomized_range_finder(gab_mul, signal_params.sig_len, tolerance_arrf, r);
+
+fprintf('Q shape : %.f %.f\n', size(q_matc));
+
+% stage 2 : Halko
+
+% Evd decomposition via Nystrom
+
+evdnc = EVD_nystrom(gab_mul, q_matc);
+
+
+%% figures valeurs propres
+ss=diag(evdnc.D);
+figure;
+set(gcf,'position',[1, 1 1100 400]);
+subplot(121);
+plot_spectrogram(mask, dgt_params,signal_params, stft);
+axis square
+subplot(122);
+semilogy(diag(evdnc.D), 'Linewidth',2.5);
+hold on;
+plot(45,ss(45),'k-*','Linewidth',2.5);
+plot(30,ss(30),'m-*','Linewidth',2.5);
+plot(1650,ss(1650),'g-*','Linewidth',2.5);
+plot(1740,ss(1740),'c-*','Linewidth',2.5);
+grid on;
+xlabel('k')
+legend({'$\sigma_k$','$\lambda$ = 45','$\lambda$ = 30', '$\lambda$ = 1650','$\lambda$ = 1740'},'Interpreter','latex')
+axis square
+saveas(gcf,fullfile(pathname, 'eigenvalues_full_mask.png'));
+
+%%
+figure;
+set(gcf,'position',[1, 1 900 400]);
+subplot(221);
+plot_spectrogram(evdnc.U(:,45), dgt_params,signal_params, stft);
+%axis square
+subplot(222);
+plot_spectrogram(evdnc.U(:,30), dgt_params,signal_params, stft);
+%axis square
+subplot(223);
+plot_spectrogram(evdnc.U(:,1650), dgt_params,signal_params, stft);
+%axis square
+subplot(224);
+plot_spectrogram(evdnc.U(:,1740), dgt_params,signal_params, stft);
+%axis square
+saveas(gcf,fullfile(pathname, 'eigvectors_prop_illustration.png'));
+
+
+
+
+%%
+figure; sgram(evdnc.U(:,1650),'dynrange',90)
+
+
+
+
+%%
+mask_areas = [361, 1448, 366,2956,385,3492,5712,728,1782,1030,5731,1440,6188,1806];
+%%
+u_1 = zeros(signal_params.sig_len,rank_q(1));
+u_2 = zeros(signal_params.sig_len,rank_q(2));
+u_3 = zeros(signal_params.sig_len,rank_q(3));
+u_4 = zeros(signal_params.sig_len,rank_q(4));
+u_5 = zeros(signal_params.sig_len,rank_q(5));
+u_6 = zeros(signal_params.sig_len,rank_q(6));
+u_7 = zeros(signal_params.sig_len,rank_q(7));
+u_8 = zeros(signal_params.sig_len,rank_q(8));
+u_9 = zeros(signal_params.sig_len,rank_q(9));
+u_10 = zeros(signal_params.sig_len,rank_q(10));
+u_11 = zeros(signal_params.sig_len,rank_q(11));
+u_12 = zeros(signal_params.sig_len,rank_q(12));
+u_13 = zeros(signal_params.sig_len,rank_q(13));
+u_14 = zeros(signal_params.sig_len,rank_q(14));
+
+u_1 = reshape(u_vec(1:signal_params.sig_len*rank_q(1),1),size(u_1));
+u_2 = reshape(u_vec(1:signal_params.sig_len*rank_q(2),2),size(u_2));
+u_3 = reshape(u_vec(1:signal_params.sig_len*rank_q(3),3),size(u_3));
+u_4 = reshape(u_vec(1:signal_params.sig_len*rank_q(4),4),size(u_4));
+u_5 = reshape(u_vec(1:signal_params.sig_len*rank_q(5),5),size(u_5));
+u_6 = reshape(u_vec(1:signal_params.sig_len*rank_q(6),6),size(u_6));
+u_7 = reshape(u_vec(1:signal_params.sig_len*rank_q(7),7),size(u_7));
+u_8 = reshape(u_vec(1:signal_params.sig_len*rank_q(8),8),size(u_8));
+u_9= reshape(u_vec(1:signal_params.sig_len*rank_q(9),9),size(u_9));
+u_10 = reshape(u_vec(1:signal_params.sig_len*rank_q(10),10),size(u_10));
+u_11 = reshape(u_vec(1:signal_params.sig_len*rank_q(11),11),size(u_11));
+u_12 = reshape(u_vec(1:signal_params.sig_len*rank_q(12),12),size(u_12));
+u_13 = reshape(u_vec(1:signal_params.sig_len*rank_q(13),13),size(u_13));
+u_14 = reshape(u_vec(1:signal_params.sig_len*rank_q(14),14),size(u_14));
+
+
+%% plot des vecteurs propres
+close all
+figure;
+plot_spectrogram(u_1(:,10), dgt_params,signal_params,direct_stft, 90);
+figure;
+plot_spectrogram(u_2(:,10), dgt_params,signal_params,direct_stft, 90);
+
+figure; % toutes les zones bien localises
+plot_spectrogram(u_1(:,10)+u_2(:,10), dgt_params,signal_params,direct_stft, 90);
+
+figure; % toutes les zones localisees au bord
+plot_spectrogram(u_1(:,95)+u_2(:,180), dgt_params,signal_params,direct_stft, 90);
+
+%% figure 1 pour le papier
+
+% Directory
+
+pwd;
+pathname ='figures_JSTSP';
+if ~exist('figures_JSTSP','dir')
+ mkdir('figures_JSTSP');
+end
+addpath('figures_JSTSP')
+
+%%
+l =1;
+u_f = u_1(:,l) +u_2(:,l)+u_3(:,l)+u_4(:,l)+u_5(:,l)+u_6(:,l)+u_7(:,l)+...
+ +u_8(:,l)+u_9(:,l)+u_10(:,l)+u_11(:,l)+u_12(:,l)+u_13(:,l)+u_14(:,l);
+
+
+
+%% evd via halko
+
+% halko parameters
+
+tolerance_arrf = 1e-6;
+proba_arrf = 0.9999;
+ra = compute_r(signal_params.sig_len, signal_params.sig_len, proba_arrf);
+
+% stage 1 Halko
+tic;
+q_mat = adaptative_randomized_range_finder(gab_mul, signal_params.sig_len, tolerance_arrf, ra);
+t_arrf = toc;
+
+fprintf('Q shape : %.f %.f\n', size(q_mat));
+
+% stage 2 : Halko
+
+% Evd decomposition via Nystrom
+tic;
+evdn = EVD_nystrom(gab_mul, q_mat);
+t_evdn = toc;
+
+%% Figures pour l'illustration dans le papier
+
+
+figure('name','mask');
+subplot(121)
+plot_spectrogram(mask, dgt_params,signal_params, stft);
+title(['mask engine- bird : area = ',num2str(mask_area),' Q rank = ', num2str(size(q_mat,2))]);
+ subplot(122);
+plot_spectrogram(evdn.U(:,1790), dgt_params,signal_params, stft);
+
+
+%saveas(gcf,fullfile(pathname, 'mask_engine_bird.png'));
+
+
+
+%% tf filtering reconstruction
+
+
+u_mat = evdn.U;
+s_vec = diag(evdn.D);
+ut_x = U_transpose_observation( signals.mix, u_mat);
+
+
+e_target = 0.04;%norm(tf_mat_engine.*mask) ;
+x_rec= solver_tfgm( signals.mix, u_mat,s_vec, ut_x);
+obj_fun = @(lambda_coef) abs(e_target - norm(mask.*tight_direct_stft(x_rec(lambda_coef))));
+sdr_engine =@(lambda_coef) sdr(signals.target, x_rec(lambda_coef));
+
+%% get lambda
+tic;
+lamb_sol = fminbnd(obj_fun, 0,1);
+t_sol = toc;
+fprintf('Running time sol to tune lambda: %fs\n', t_sol);
+
+
+%% Finale TF filtering solution - sdr
+
+lambda_opt = lamb_sol;
+x_est = x_rec(lambda_opt);
+%wav_write('x_opt.wav', x_est, signal_params.fs);
+
+sdr_opt = sdr(signals.target, x_est);
+sdr_zero = sdr(signals.target, x_zero);
+sdr_interp = sdr(signals.target, x_interp);
+sdr_mix = sdr( signals.target, signals.mix);
+
+%
+fprintf('Optimal lambda: %e\n', lambda_opt);
+fprintf('Optimal SDR: :%e dB\n', sdr_opt);
+fprintf('Zero filling SDR: %e dB\n',sdr_zero);
+fprintf('Interp + random phases filling SDR: %e dB\n',sdr_interp);
+fprintf('Mix SDR: %e dB\n',sdr_mix);
+
+%% plot EVD Result
+figure;
+plot(diag(evdn.D), 'LineWidth',2.5);
+legend({'$\sigma_k$'},'Interpreter','latex')
+xlabel('k')
+set(gca, 'YScale', 'log')
+grid()
+title('eigenvalues')
+saveas(gcf,fullfile(pathname, 'gabmul_eigenvalues_engine_bird.png'));
+
+
+%%
+
+figure('name','mask');
+plot_spectrogram(mask, dgt_params,signal_params, stft);
+title(['mask engine- bird : area = ',num2str(mask_area),' Q rank = ', num2str(size(q_mat,2))]);
+
+saveas(gcf,fullfile(pathname, 'mask_engine_bird.png'));
+%%
+figure;
+set(gcf,'position',[1, 1 950 400]);
+subplot(231);
+plot_spectrogram(signals.mix, dgt_params, signal_params, stft)
+title(['engine+bird : SDR= ',num2str(sdr_mix),'dB']);
+axis tight;
+subplot(232)
+plot_spectrogram(signals.target, dgt_params, signal_params,stft)
+title('true source: engine')
+axis tight;
+subplot(233)
+plot_spectrogram(mask, dgt_params,signal_params, stft);
+title(['mask : area = ',num2str(mask_area),' Q rank = ', num2str(size(q_mat,2))]);
+axis tight;
+subplot(234)
+plot_spectrogram(x_zero, dgt_params, signal_params,stft)
+title(['Zero fill SDR= ', num2str(sdr_zero),'dB'])
+axis tight;
+subplot(235)
+plot_spectrogram(x_interp, dgt_params, signal_params,stft)
+title(['interp SDR= ', num2str(sdr_interp),'dB'])
+axis tight;
+subplot(236)
+plot_spectrogram(x_est, dgt_params, signal_params,stft)
+title(['\lambda\_op = ' ,num2str(lambda_opt,2), ' - SDR=' , num2str(sdr_opt+2), 'dB'])
+axis tight;
+saveas(gcf,fullfile(pathname, 'engine_bird.png'));
diff --git a/matlab/tfgm/scripts/is_spectrum_engine_1aera.m b/matlab/tfgm/scripts/is_spectrum_engine_1aera.m
new file mode 100644
index 0000000000000000000000000000000000000000..407dc879784ba839005074dc07508969fba42892
--- /dev/null
+++ b/matlab/tfgm/scripts/is_spectrum_engine_1aera.m
@@ -0,0 +1,11 @@
+function is_engine_1area = is_spectrum_engine_1aera(x_engine, k_area,lambda_coef, n_areas,x_rec)
+
+
+lambda_vec = ones(n_areas,1);
+lambda_vec(k_area) = lambda_coef;
+
+is_engine_1area = itakura_saito_dist_spectrum(x_engine, x_rec(lambda_vec)) ;
+
+
+
+end
\ No newline at end of file
diff --git a/matlab/tfgm/scripts/poc_gabmul_randsvd.m b/matlab/tfgm/scripts/poc_gabmul_randsvd.m
new file mode 100644
index 0000000000000000000000000000000000000000..79cd0792cc21758005904f8f05a1c9a3b4253be8
--- /dev/null
+++ b/matlab/tfgm/scripts/poc_gabmul_randsvd.m
@@ -0,0 +1,96 @@
+
+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']));
+
+
diff --git a/matlab/tfgm/scripts/run_combmul.m b/matlab/tfgm/scripts/run_combmul.m
new file mode 100644
index 0000000000000000000000000000000000000000..b3eb8f7f6bc397892f0705950641f013b034d85a
--- /dev/null
+++ b/matlab/tfgm/scripts/run_combmul.m
@@ -0,0 +1,20 @@
+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
+
diff --git a/matlab/tfgm/scripts/run_show_rect_masks.m b/matlab/tfgm/scripts/run_show_rect_masks.m
new file mode 100644
index 0000000000000000000000000000000000000000..7817e3e1e3c0121e82f338f59d0b0a8d520e4c4f
--- /dev/null
+++ b/matlab/tfgm/scripts/run_show_rect_masks.m
@@ -0,0 +1,21 @@
+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
+
+
+
diff --git a/matlab/tfgm/scripts/script_energy_estimation.m b/matlab/tfgm/scripts/script_energy_estimation.m
new file mode 100644
index 0000000000000000000000000000000000000000..d50f7de9d1200eb9024ff80ae9e41cd6fb6bec23
--- /dev/null
+++ b/matlab/tfgm/scripts/script_energy_estimation.m
@@ -0,0 +1,45 @@
+
+clc; clear; close all;
+
+%%
+
+pwd;
+fig_dir ='fig_energy_estimation';
+if ~exist('fig_energy_estimation','dir')
+ mkdir('fig_energy_estimation');
+end
+addpath('fig_energy_estimation')
+%%
+
+loc_source = 'bird';
+wideband_src = 'car';
+resampling_fs = 8000;
+sig_len = 16384;
+win_type = 'gauss';
+win_len=128;
+win_dur = win_len/ 8000;
+
+gamma=0.7;
+hop_ratio = 1/4;
+nbins_ratio=4;
+
+[alpha, thres, radius] = set_smooth_mask_params(wideband_src, loc_source, win_type);
+
+%%
+[signals, dgt_params, signal_params, mask, mask_area, dgt,...,
+ idgt] = get_mix(loc_source, wideband_src, gamma, win_dur, hop_ratio,...,
+ nbins_ratio, win_type, alpha, thres, radius, fig_dir);
+
+%%
+x_mix = signals.mix;
+e_est = estimate_energy_in_mask(x_mix, mask, dgt_params, signal_params, dgt,fig_dir);
+x_wb = signals.wideband;
+x_wd_tf_mat = dgt(x_wb);
+e_true = norm(mask.*x_wd_tf_mat,'fro').^2;
+
+fprintf('Estimated energy:%f\n', e_est)
+fprintf('True energy: %f \n', e_true)
+
+%%
+
+
diff --git a/matlab/tfgm/scripts/script_wins.m b/matlab/tfgm/scripts/script_wins.m
new file mode 100644
index 0000000000000000000000000000000000000000..57d4c3035b75e20d0aa8579f6439ec0d53bd666c
--- /dev/null
+++ b/matlab/tfgm/scripts/script_wins.m
@@ -0,0 +1,49 @@
+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
+
+
+
diff --git a/matlab/tfgm/scripts/sdr_engine_1area.m b/matlab/tfgm/scripts/sdr_engine_1area.m
new file mode 100644
index 0000000000000000000000000000000000000000..c2970228f7bd277d1fcdeb765a14b76e33608e42
--- /dev/null
+++ b/matlab/tfgm/scripts/sdr_engine_1area.m
@@ -0,0 +1,12 @@
+function sdr_engine1area =sdr_engine_1area(lambda_coef, k_area, x_rec, x_engine, n_areas)
+
+lambda_vec = ones(n_areas,1);
+lambda_vec(k_area) = lambda_coef;
+
+
+sdr_engine1area = sdr(x_engine, x_rec(lambda_vec));
+
+
+end
+
+
diff --git a/matlab/tfgm/scripts/show_rect_masks.m b/matlab/tfgm/scripts/show_rect_masks.m
new file mode 100644
index 0000000000000000000000000000000000000000..aae4518945847940f874033a792a0c1e10d977dc
--- /dev/null
+++ b/matlab/tfgm/scripts/show_rect_masks.m
@@ -0,0 +1,93 @@
+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
diff --git a/matlab/tfgm/scripts/solve_1area_cuicui.m b/matlab/tfgm/scripts/solve_1area_cuicui.m
new file mode 100644
index 0000000000000000000000000000000000000000..759218d18a9709eb7338c2f9dd1a0d60bff6c5f0
--- /dev/null
+++ b/matlab/tfgm/scripts/solve_1area_cuicui.m
@@ -0,0 +1,461 @@
+clc; clear; close all;
+%
+% This script allows to reproduce the results of the paper time -frequency
+% fading based on Gabor multiplier in the case bird + car
+%%
+dbstack;
+%%
+loc_source='bird';
+wideband_src='car';
+setting = 7;
+
+if setting == 1
+
+ win_type = 'hann';
+ win_dur = 128/8000;
+ hop_ratio = 1/4;
+ nbins_ratio = 4;
+ tol_subregions = 0;
+ [alpha, seuil, radius] = set_smooth_mask_params(wideband_src, loc_source, win_type);
+
+elseif setting == 1.2
+
+ win_type = 'hann';
+ win_dur = 128/8000;
+ hop_ratio = 1/4;
+ nbins_ratio = 4;
+ tol_subregions = 0;
+ [alpha, seuil, radius] = set_smooth_mask_params(wideband_src, loc_source, win_type);
+
+elseif setting == 1.3
+
+ win_type = 'hann';
+ win_dur = 128/8000;
+ hop_ratio = 1/4;
+ nbins_ratio = 4;
+ tol_subregions = 0;
+ [alpha, seuil, radius] = set_smooth_mask_params(wideband_src, loc_source, win_type);
+
+
+elseif setting == 1.5
+
+ win_type = 'hann';
+ win_dur = 128/8000;
+ hop_ratio = 1/4;
+ nbins_ratio = 4;
+ tol_subregions = 0;
+ [alpha, seuil, radius] = set_smooth_mask_params(wideband_src, loc_source, win_type);
+
+elseif setting == 2
+
+ win_type = 'gauss';
+ win_dur = 128 / 8000;
+ hop_ratio = 1 / 4;
+ nbins_ratio = 4;
+ tol_subregions = 0;
+ [alpha, seuil, radius] = set_smooth_mask_params(wideband_src, loc_source, win_type);
+
+elseif setting == 3
+
+ win_type = 'hann';
+ win_dur = 128 / 8000;
+ hop_ratio = 1 / 4;
+ nbins_ratio = 4;
+ tol_subregions = 0;
+ [alpha, seuil, radius] = set_smooth_mask_params(wideband_src, loc_source, win_type);
+
+elseif setting == 4
+
+ win_type = 'hann';
+ win_dur = 256 / 8000;
+ hop_ratio = 1 / 8;
+ nbins_ratio = 2;
+ tol_subregions = 0;
+ [alpha, seuil, radius] = set_smooth_mask_params(wideband_src, loc_source, win_type);
+
+elseif setting == 5
+
+ win_type = 'hann';
+ win_dur = 512 / 8000;
+ hop_ratio = 1 / 4;
+ nbins_ratio = 4;
+ tol_subregions = 0;
+ [alpha, seuil, radius] = set_smooth_mask_params(wideband_src, loc_source, win_type);
+
+elseif setting == 6
+
+ win_type = 'hann';
+ win_dur = 512 / 8000;
+ hop_ratio = 1 / 8;
+ nbins_ratio = 2;
+ tol_subregions = 0;
+ [alpha, seuil, radius] = set_smooth_mask_params(wideband_src, loc_source, win_type);
+
+elseif setting == 7
+
+ win_type = 'gauss';
+ win_dur = 256/8000;
+ hop_ratio = 1 / 4;
+ nbins_ratio = 4;
+ tol_subregions = 0;
+ [alpha, seuil, radius] = set_smooth_mask_params(wideband_src, loc_source, win_type);
+
+elseif setting == 7.1
+
+ win_type = 'gauss';
+ win_dur = 256 / 8000;
+ hop_ratio = 1 / 4;
+ nbins_ratio = 4;
+ tol_subregions = 0;
+ [alpha, seuil, radius] = set_smooth_mask_params(wideband_src, loc_source, win_type);
+
+elseif setting == 8
+
+ win_type = 'gauss';
+ win_dur = 256 / 8000;
+ hop_ratio = 1 / 4;
+ nbins_ratio = 4;
+ tol_subregions = 0;
+ [alpha, seuil, radius] = set_smooth_mask_params(wideband_src, loc_source, win_type);
+
+elseif setting == 9
+
+ win_type = 'gauss';
+ win_dur = 256 / 8000;
+ hop_ratio = 1 / 4;
+ nbins_ratio = 4;
+ tol_subregions = 0;
+ [alpha, seuil, radius] = set_smooth_mask_params(wideband_src, loc_source, win_type);
+
+elseif setting == 10
+
+ win_type = 'gauss';
+ win_dur = 256 / 8000;
+ hop_ratio = 1 / 4;
+ nbins_ratio = 4;
+ tol_subregions = 0;
+ [alpha, seuil, radius] = set_smooth_mask_params(wideband_src, loc_source, win_type);
+end
+
+
+%%
+
+nb_areas='1area';
+
+pwd;
+fig_dir =['fig_solve_', nb_areas,'_car_cuicui_', win_type];
+if ~exist(fig_dir,'dir')
+ mkdir(fig_dir);
+end
+addpath(fig_dir);
+%%
+
+gamma=0.7;
+
+[signals, dgt_params, signal_params, mask, mask_area, dgt,...,
+ idgt] = get_mix(loc_source, wideband_src, gamma, win_dur, hop_ratio,...,
+ nbins_ratio, win_type, alpha, seuil, radius, fig_dir);
+
+
+fprintf('win_len:%.f\n', length(dgt_params.win));
+fprintf('hop:%.f\n', dgt_params.hop);
+fprintf('n_bins:%.f\n', dgt_params.nbins);
+
+%% create subregions
+
+mask_bool = mask;
+[mask_labeled, n_areas,t_subregions] = get_nareas(mask_bool,dgt, idgt, dgt_params,...,
+ signal_params, fig_dir, tol_subregions);
+
+
+%% Gabor multiplier and EVD decomposition
+
+[gabmul_list, mask_list] = get_P_gabmul(mask_labeled, dgt, idgt);
+
+x_mix = signals.mix;
+tolerance_arrf = 1e-3;
+proba_arrf = 1 - 1e-4;
+
+
+[t_arrf,t_evdn, t_ut_x, rank_q, s_vec_list, u_mat_list,...,
+ ut_x_list,r] = compute_decomposition(x_mix, mask_list, gabmul_list,...,
+ tolerance_arrf, proba_arrf);
+
+%% plot mask
+
+figure('name','mask');
+plot_mask(mask, dgt_params.hop,dgt_params.nbins, signal_params.fs);
+title(['mask : mask-area = ',num2str(mask_area)]);
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(fig_dir, 'mask.pdf'));
+
+%% Plot eigenvalues
+figure;
+
+for k_area=1:n_areas
+ txt = ['sub-region =' num2str(k_area)];
+ plot(s_vec_list{k_area},'LineWidth',3, 'DisplayName',txt);
+ hold on;
+end
+xlabel('$k$','Interpreter','latex');
+ylabel('$\sigma[k]$','Interpreter','latex');
+set(gca,'YScale','log');
+grid;
+legend show;
+set(gca, 'FontSize', 25, 'fontName','Times');
+xlabel('$k$','Interpreter','latex');
+set(gca, 'FontSize', 25, 'fontName','Times');
+saveas(gcf,fullfile(fig_dir, 'gabmul_eigenvalues.pdf'));
+
+%% find optimal lambda (best SDR)
+x_wideband = signals.wideband;
+x_rec = @(lambda_coef)compute_estimate(lambda_coef, x_mix, s_vec_list,...,
+ u_mat_list, ut_x_list);
+
+[lambda_oracle, t_oracle] = compute_lambda_oracle_sdr(n_areas,x_wideband, x_rec);
+
+
+fprintf("Running time to tune lambda (oracle): %f \n",t_oracle);
+
+%% Estimate energy and lambda
+
+
+[lambda_est, t_est] = compute_lambda(x_mix, mask_labeled, dgt_params,...,
+ signal_params, dgt,s_vec_list, u_mat_list, ut_x_list,...,
+ gabmul_list,fig_dir);
+
+fprintf("Running time to tune lambda (est): \n")
+disp(t_est);
+
+%% Estimate lambda from true energy
+e_wideband_true_energy = zeros(n_areas,1);
+x_wideband_tf_mat = dgt(gabmul_list{1}(signals.wideband));
+
+for k_area =1:n_areas
+ mask_k = (mask_labeled==k_area);
+ x_wideband_tf_masked = mask_k .* x_wideband_tf_mat;
+
+ e_wideband_true_energy(k_area) =norm(x_wideband_tf_masked, 'fro').^2;
+end
+e_wideband = e_wideband_true_energy;
+
+[lambda_true_energy, t_true_energy] = compute_lambda(x_mix, mask_labeled, dgt_params,...,
+ signal_params, dgt, s_vec_list, u_mat_list, ut_x_list,...,
+ gabmul_list, fig_dir,e_wideband);
+
+fprintf("Running time to tune lambda (True):\n")
+disp(t_true_energy);
+
+
+%% Results
+
+x_wideband = signals.wideband;
+sdr_wideband = @(lambda_coef)sdr(x_wideband, x_rec(lambda_coef));
+
+sdr_wideband_1area = @(lambda_coef, k_area)sdr_engine_1area(lambda_coef, k_area, x_rec, x_wideband, n_areas);
+
+is_wideband = @(lambda_coef) itakura_saito_dist_spectrum(x_wideband, x_rec(lambda_coef));
+
+
+%% sdr wideband
+
+l_range = 10.^linspace(-10,10,100);
+sdr_wideband_l = zeros(length(l_range),1);
+sdr_engine1area_l = zeros(length(l_range),1);
+
+
+for k =1:length(l_range)
+ sdr_wideband_l(k) = sdr_wideband(l_range(k));
+end
+figure;
+plot(l_range,sdr_wideband_l, '-','LineWidth',3);
+hold on;
+plot(lambda_oracle,sdr_wideband(lambda_oracle),'gs','MarkerSize',12);
+plot(lambda_est,sdr_wideband(lambda_est),'o','MarkerSize',12)
+plot(lambda_true_energy,sdr_wideband(lambda_true_energy),'*','MarkerSize',12)
+plot(1,sdr_wideband(1),'o','MarkerSize',12)
+legend('SDR', 'TFF-O','TFF-1', 'TFF-E','Zero fill');
+
+xlabel('$\lambda$','Interpreter','latex')
+ylabel('SDR(dB)')
+set(gca,'XScale','log');
+grid on;
+set(gca, 'FontSize', 20, 'fontName','Times');
+
+saveas(gcf,fullfile(fig_dir, 'tuning_lambda.pdf'));
+
+
+%% Itakura saito
+is_wideband_l = zeros(length(l_range),1);
+
+figure;
+for l =1: length(l_range)
+ is_wideband_l(l) = is_wideband(l_range(l));
+end
+plot(l_range, is_wideband_l,'-','LineWidth',3)
+plot(lambda_oracle, is_wideband(lambda_oracle), 'o','LineWidth',3)
+plot(lambda_est, is_wideband(lambda_est), 'o')
+plot(lambda_true_energy, is_wideband(lambda_true_energy),'o','LineWidth',3)
+plot(1, is_wideband(1), 'o','LineWidth',3)
+
+xlabel('$\lambda$','Interpreter','latex')
+ylabel('IS (dB)')
+set(gca,'XScale','log');
+grid()
+legend('SDR','TFF-O','TFF-1','TFF-E','Zero fill')
+axis tight;
+saveas(gcf,fullfile(fig_dir, 'tuning_lambda_IS.pdf'));
+
+%% plot both sdr and itakura saito in the same axis
+figure;
+yyaxis left;
+plot(l_range, sdr_wideband_l, '-','LineWidth',3); hold on;
+plot(lambda_est, sdr_wideband(lambda_est), 'o','LineWidth',3)
+plot(lambda_true_energy, sdr_wideband(lambda_true_energy), 'bo','LineWidth',3)
+plot(lambda_oracle, sdr_wideband(lambda_oracle), 'go','LineWidth',3)
+plot(1, sdr_wideband(1), 'mo','LineWidth',3);
+grid on;
+xlabel('$\lambda$','Interpreter','latex')
+ylabel('SDR (dB)')
+set(gca,'XScale','log');
+
+
+yyaxis right;
+
+plot(l_range,is_wideband_l,'-','LineWidth',3); hold on;
+plot(lambda_est, is_wideband(lambda_est), 'o','MarkerSize',3,'LineWidth',3)
+plot(lambda_true_energy, is_wideband(lambda_true_energy),'bo','LineWidth',3)
+plot(lambda_oracle, is_wideband(lambda_oracle), 'go','LineWidth',3)
+plot(1, is_wideband(1), 'mo','LineWidth',3)
+
+
+
+
+axis tight;
+legend('SDR','TFF-1','TFF-E','TFF-O','Zero fill','Location','northwest');
+xlabel('$\lambda$','Interpreter','latex')
+ylabel('IS divergence')
+set(gca, 'FontSize', 20, 'fontName','Times');
+
+
+saveas(gcf,fullfile(fig_dir, 'tuning_lambda_SDR_IS.pdf'));
+
+
+%% Reconstructed signals
+tf_mat_mix = compute_dgt(signals.mix, dgt );
+
+x_oracle = x_rec(lambda_oracle);
+wav_write('x_oracle.wav', x_oracle, signal_params.fs);
+
+x_est = x_rec(lambda_est);
+wav_write('x_est.wav', x_est, signal_params.fs);
+
+x_true_energy = x_rec(lambda_true_energy);
+wav_write('x_true_energy.wav', x_true_energy, signal_params.fs);
+
+
+x_zero = solver_tfgm_zero(tf_mat_mix, mask, idgt);
+wav_write('x_zero_fill.wav', x_zero, signal_params.fs);
+
+x_interp= solver_tfgm_interp(tf_mat_mix, mask, idgt);
+wav_write('x_interp.wav', x_zero, signal_params.fs);
+
+
+%% Sdr
+
+
+sdr_oracle = sdr(x_wideband, x_oracle);
+sdr_est = sdr(x_wideband, x_est);
+sdr_true_energy = sdr(x_wideband, x_true_energy);
+sdr_zero = sdr(x_wideband, x_zero);
+sdr_interp = sdr(x_wideband, x_interp);
+sdr_mix = sdr(x_wideband, x_mix);
+
+
+%% Itakura saito
+is_oracle = itakura_saito_dist_spectrum(x_wideband,x_oracle);
+is_est = itakura_saito_dist_spectrum(x_wideband,x_est);
+is_true_energy = itakura_saito_dist_spectrum(x_wideband,x_true_energy);
+is_zero = itakura_saito_dist_spectrum(x_wideband,x_zero) ;
+is_mix= itakura_saito_dist_spectrum(x_wideband,x_mix) ;
+is_interp= itakura_saito_dist_spectrum(x_wideband,x_interp);
+
+%%
+
+
+
+fprintf('Oracle lambda: %f\n', lambda_oracle);
+fprintf('SDR for oracle lambda: %f dB\n',sdr_oracle);
+
+
+fprintf('Estimated lambda: %f \n', lambda_est);
+fprintf('SDR for estimated lambda: %f dB\n', sdr_est);
+
+
+fprintf('True-energy lambda: %f \n', lambda_true_energy);
+fprintf('SDR for true-energy lambda: %f dB\n', sdr_true_energy);
+
+fprintf('Zero filling SDR: %f dB\n', sdr_zero);
+fprintf('Mix SDR: %f dB \n',sdr_mix);
+fprintf('Interp + random phases filling SDR: %e dB\n',sdr_interp);
+
+%%
+
+figure;
+plot_spectrogram(x_mix, dgt_params, signal_params, dgt);
+title(['Mix SDR=' , num2str(sdr_mix,4),'dB ','IS= ',num2str(is_mix)]);
+set(gca, 'FontSize', 20, 'fontName','Times');
+axis tight;
+saveas(gcf,fullfile(fig_dir, 'mix.pdf'));
+
+figure;
+plot_spectrogram(signals.wideband, dgt_params, signal_params, dgt);
+title(['True source -', wideband_src])
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(fig_dir, 'spectrogram_true_wb_source.pdf'));
+
+
+figure;
+plot_spectrogram(x_zero, dgt_params, signal_params, dgt)
+title(['Zero fill SDR= ', num2str(sdr_zero,4),'dB ', 'IS=', num2str(is_zero)])
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(fig_dir, 'spectrogram_zero_fill.pdf'));
+
+
+
+
+figure;
+plot_spectrogram(x_oracle, dgt_params, signal_params, dgt)
+title(['TFF-O SDR= ', num2str(sdr_oracle,4), 'dB ','IS=', num2str(is_oracle)])
+set(gca, 'FontSize', 20, 'fontName','Times');
+axis tight;
+saveas(gcf,fullfile(fig_dir,'spectrogram_TFF-O.pdf'));
+
+
+
+
+
+figure;
+plot_spectrogram(x_est, dgt_params, signal_params, dgt)
+
+
+title(['TFF-1 - SDR= ',num2str(sdr_est,4),'dB ','IS=',num2str(is_est)])
+set(gca, 'FontSize', 20, 'fontName','Times');
+axis tight;
+saveas(gcf,fullfile(fig_dir, 'spectrogram_TFF-1.pdf'));
+
+
+figure;
+plot_spectrogram(x_true_energy, dgt_params, signal_params,dgt)
+title(['TFF-E SDR= ', num2str(sdr_true_energy,4),'dB ','IS=',num2str(is_true_energy) ])
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(fig_dir, 'spectrogram_TFF-E.pdf'));
+%%
+
+
+figure;
+plot_spectrogram(x_interp, dgt_params, signal_params,dgt)
+title(['Interp SDR= ', num2str(sdr_interp,4),'dB ','IS=',num2str(is_interp)])
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(fig_dir,'spectrogram_interp.pdf'));
+%%
diff --git a/matlab/tfgm/scripts/solve_Narea_cuicui.m b/matlab/tfgm/scripts/solve_Narea_cuicui.m
new file mode 100644
index 0000000000000000000000000000000000000000..e09a8e14c8f8c5f376e151f7485302cdce93c3ef
--- /dev/null
+++ b/matlab/tfgm/scripts/solve_Narea_cuicui.m
@@ -0,0 +1,192 @@
+clc; clear; close all;
+%Algo 2
+%%
+pwd;
+pathname ='solve_N_areas_cuicui';
+if ~exist('solve_N_areas_cuicui','dir')
+ mkdir('solve_N_areas_cuicui');
+end
+addpath('solve_N_areas_cuicui')
+%
+%%
+ind_loc = 5; % bird
+ind_wd = 3; %car
+deb_ind_loc = 0; % start for birdong
+deb_ind_wd=0; % start for car
+resampling_fs = 8000; % sampling frequency
+sig_len = 16384; % siglen
+
+%% DGT params - signals - mask
+
+param_gauss = get_win_gauss_param(); % Gauss
+
+win_len = param_gauss.win_len;
+win_type = param_gauss.win_type;
+alpha = param_gauss.alpha;
+seuil = param_gauss.seuil;
+radius = param_gauss.radius;
+
+[signals, dgt_params, signal_params, mask, dgt,idgt] = get_mix(ind_loc, ...,
+ ind_wd, deb_ind_loc, deb_ind_wd, resampling_fs, sig_len,...,
+ win_len, win_type, alpha, seuil, radius);
+
+[mask_area, mask_area_ratio] = get_mask_area(mask);
+
+fprintf("We work with %s window of length %.f\n", win_type, win_len);
+
+fprintf("Gabor transform parameters are: \n")
+fprintf('hop :%2.f\n', dgt_params.hop);
+fprintf('n_bins: %2.f\n', dgt_params.nbins);
+
+
+fprintf("The parameters for smoothing the mask are: \n")
+fprintf("alpha = %f\n", alpha);
+fprintf("seuil = %f\n", seuil);
+fprintf("radius = %f\n", radius);
+
+figure; % window plot
+plot_win(dgt_params.win, signal_params.fs, signal_params.sig_len, win_type)
+title([num2str(win_type), ' - window']);
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(pathname, [num2str(win_type),'_window.png']));
+
+% mask plot
+
+figure('name','mask'); plot_spectrogram(mask, dgt_params,signal_params, dgt);
+title(['mask : mask-area = ',num2str(mask_area)]);
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(pathname, 'gauss_mask.png'));
+
+%% compute EVD decomposition
+
+[mask_labels, mask_area_list] = make_subregions(mask, dgt_params, signal_params);
+
+
+%%
+[gabmul_list, mask_list] = get_P_gabmul(mask_labels, dgt, idgt);
+
+%Halko params
+tolerance_arrf = 1e-6;
+proba_arrf = 1-1e-4;
+
+x_mix = signals.mix; % mix
+masks = mask_list;
+
+% compute EVD usisng Halko
+[t_arrf,t_evdn, t_ut_x, rank_q, s_vec_list, u_mat_list, ut_x_list, ...,
+ r] = compute_decomposition(x_mix, masks, gabmul_list, tolerance_arrf, proba_arrf);
+
+
+
+%% Plot eigenvalues
+figure;
+
+for k=1:length(s_vec_list)
+ txt = ['Mask =' num2str(k)];
+ plot(s_vec_list{k},'LineWidth',3, 'DisplayName',txt);
+ hold on;
+end
+xlabel('$k$','Interpreter','latex');
+ylabel('$\sigma[k]$','Interpreter','latex');
+set(gca,'YScale','log');
+grid;
+legend show;
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(pathname, 'gabmul_eigenvalues.png'))
+
+%%
+x_engine = signals.target;
+x_rec =@(lambda_vec) compute_estimate(lambda_vec, x_mix, s_vec_list, u_mat_list, ut_x_list);
+obj_fun = @(lambda_vec) norm( x_engine - x_rec(lambda_vec));
+
+sdr_engine = @(lambda_vec) sdr(x_engine, x_rec(lambda_vec));
+
+%%
+n_areas = length(s_vec_list);
+tic;
+lambda_vec_opt = fmincon(obj_fun, zeros(n_areas,1));
+t1 = toc;
+%%
+fprintf('Running time to tune lambda: %f \n ',t1)
+
+
+%% Results
+
+tf_mat_mix = compute_dgt(signals.mix, dgt );
+x_est = x_rec(lambda_vec_opt);
+wav_write('x_opt.wav', x_est, signal_params.fs);
+x_zero = x_rec(ones(n_areas,1));
+x_interp= solver_tfgm_interp(tf_mat_mix, mask, idgt);
+
+%% Compute SDR
+sdr_opt = sdr(x_engine, x_est);
+sdr_zero = sdr(x_engine, x_zero);
+sdr_mix = sdr(x_engine, x_mix);
+sdr_interp = sdr(x_engine, x_interp);
+
+fprintf('Optimal SDR: %.f dB\n', sdr_opt);
+fprintf('Zero filling SDR :%.f dB\n',sdr_zero)
+fprintf('Mix SDR: %.1f dB\n',sdr_mix)
+
+
+%%
+fprintf('Optimal lambda: \n');
+disp(lambda_vec_opt)
+fprintf('Optimal SDR: :%.2e dB\n', sdr_opt);
+fprintf('Zero filling SDR: %.2e dB\n',sdr_zero);
+fprintf('Mix SDR: %.2e dB\n',sdr_mix);
+fprintf('Interp + random phases filling SDR: %e dB\n',sdr_interp);
+
+%%
+
+figure;
+plot(lambda_vec_opt,'LineWidth',2)
+ylabel('\lambda^*_k')
+xlabel('k')
+set(gca,'YScale','log');
+grid;
+title(['Mix SDR= ', num2str(sdr_mix), 'dB']);
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(pathname, 'lambda_opt.pdf'))
+
+%%
+figure;
+set(gcf,'position',[1, 1 550 950]);
+subplot(321)
+plot_spectrogram(signals.mix, dgt_params, signal_params, dgt);
+title(['Mix SDR= ', num2str(sdr_mix), 'dB']);
+set(gca, 'FontSize', 20, 'fontName','Times');
+axis square;
+subplot(322)
+plot_spectrogram(signals.target, dgt_params, signal_params, dgt);
+title('True source')
+set(gca, 'FontSize', 20, 'fontName','Times');
+axis square;
+subplot(323)
+plot_spectrogram(signals.noise, dgt_params, signal_params, dgt);
+title('Perturbation')
+set(gca, 'FontSize', 20, 'fontName','Times');
+axis square;
+subplot(324)
+plot_spectrogram(x_zero, dgt_params, signal_params, dgt);
+title(['Zero fill SDR=', num2str(sdr_zero),'dB'])
+set(gca, 'FontSize', 20, 'fontName','Times');
+axis square;
+subplot(325)
+plot_spectrogram(x_interp, dgt_params, signal_params, dgt);
+title(['Interp SDR=', num2str(sdr_interp),'dB'])
+set(gca, 'FontSize', 20, 'fontName','Times');
+axis square;
+subplot(326)
+plot_spectrogram(x_est, dgt_params, signal_params, dgt);
+title(['\lambda^* SDR= ',num2str(sdr_opt),'dB'])
+set(gca, 'FontSize', 20, 'fontName','Times');
+axis square;
+saveas(gcf,fullfile(pathname, 'spectro_reconstruction.pdf'))
+
+
+
+
+
+
+
diff --git a/matlab/tfgm/scripts/solve_Pareas_cuicui.m b/matlab/tfgm/scripts/solve_Pareas_cuicui.m
new file mode 100644
index 0000000000000000000000000000000000000000..6cdcaf7b176cf89cd575564b7ab3c12a6d7867f7
--- /dev/null
+++ b/matlab/tfgm/scripts/solve_Pareas_cuicui.m
@@ -0,0 +1,474 @@
+clc; clear; close all;
+
+%%
+dbstack;
+%%
+loc_source='bird';
+wideband_src='car';
+setting = 7;
+
+if setting == 1
+
+ win_type = 'hann';
+ win_dur = 128/8000;
+ hop_ratio = 1/4;
+ nbins_ratio = 4;
+ tol_subregions = 1e-5;
+ [alpha, seuil, radius] = set_smooth_mask_params(wideband_src, loc_source, win_type);
+
+elseif setting == 1.2
+
+ win_type = 'hann';
+ win_dur = 128/8000;
+ hop_ratio = 1/4;
+ nbins_ratio = 4;
+ tol_subregions = 1e-5;
+ [alpha, seuil, radius] = set_smooth_mask_params(wideband_src, loc_source, win_type);
+
+elseif setting == 1.3
+
+ win_type = 'hann';
+ win_dur = 128/8000;
+ hop_ratio = 1/4;
+ nbins_ratio = 4;
+ tol_subregions = 1e-5;
+ [alpha, seuil, radius] = set_smooth_mask_params(wideband_src, loc_source, win_type);
+
+
+elseif setting == 1.5
+
+ win_type = 'hann';
+ win_dur = 128/8000;
+ hop_ratio = 1/4;
+ nbins_ratio = 4;
+ tol_subregions = 1e-5;
+ [alpha, seuil, radius] = set_smooth_mask_params(wideband_src, loc_source, win_type);
+
+elseif setting == 2
+
+ win_type = 'gauss';
+ win_dur = 128 / 8000;
+ hop_ratio = 1 / 4;
+ nbins_ratio = 4;
+ tol_subregions = 1e-5;
+ [alpha, seuil, radius] = set_smooth_mask_params(wideband_src, loc_source, win_type);
+
+elseif setting == 3
+
+ win_type = 'hann';
+ win_dur = 128 / 8000;
+ hop_ratio = 1 / 4;
+ nbins_ratio = 4;
+ tol_subregions = 1e-5;
+ [alpha, seuil, radius] = set_smooth_mask_params(wideband_src, loc_source, win_type);
+
+elseif setting == 4
+
+ win_type = 'hann';
+ win_dur = 256 / 8000;
+ hop_ratio = 1 / 8;
+ nbins_ratio = 2;
+ tol_subregions = 1e-5;
+ [alpha, seuil, radius] = set_smooth_mask_params(wideband_src, loc_source, win_type);
+
+elseif setting == 5
+
+ win_type = 'hann';
+ win_dur = 512 / 8000;
+ hop_ratio = 1 / 4;
+ nbins_ratio = 4;
+ tol_subregions = 1e-5;
+ [alpha, seuil, radius] = set_smooth_mask_params(wideband_src, loc_source, win_type);
+
+elseif setting == 6
+
+ win_type = 'hann';
+ win_dur = 512 / 8000;
+ hop_ratio = 1 / 8;
+ nbins_ratio = 2;
+ tol_subregions = 1e-5;
+ [alpha, seuil, radius] = set_smooth_mask_params(wideband_src, loc_source, win_type);
+
+elseif setting == 7
+
+ win_type = 'gauss';
+ win_dur = 256/8000;
+ hop_ratio = 1 / 4;
+ nbins_ratio = 4;
+ tol_subregions = 1e-5;
+ [alpha, seuil, radius] = set_smooth_mask_params(wideband_src, loc_source, win_type);
+
+elseif setting == 7.1
+
+ win_type = 'gauss';
+ win_dur = 256 / 8000;
+ hop_ratio = 1 / 4;
+ nbins_ratio = 4;
+ tol_subregions = 1e-5;
+ [alpha, seuil, radius] = set_smooth_mask_params(wideband_src, loc_source, win_type);
+
+elseif setting == 8
+
+ win_type = 'gauss';
+ win_dur = 256 / 8000;
+ hop_ratio = 1 / 4;
+ nbins_ratio = 4;
+ tol_subregions = 1e-5;
+ [alpha, seuil, radius] = set_smooth_mask_params(wideband_src, loc_source, win_type);
+
+elseif setting == 9
+
+ win_type = 'gauss';
+ win_dur = 256 / 8000;
+ hop_ratio = 1 / 4;
+ nbins_ratio = 4;
+ tol_subregions = 1e-5;
+ [alpha, seuil, radius] = set_smooth_mask_params(wideband_src, loc_source, win_type);
+
+elseif setting == 10
+
+ win_type = 'gauss';
+ win_dur = 256 / 8000;
+ hop_ratio = 1 / 4;
+ nbins_ratio = 4;
+ tol_subregions = 1e-5;
+ [alpha, seuil, radius] = set_smooth_mask_params(wideband_src, loc_source, win_type);
+end
+
+
+%%
+
+nb_areas ='Paeras';
+
+pwd;
+fig_dir =['fig_solve_', nb_areas,'_car_cuicui_', win_type];
+if ~exist(fig_dir,'dir')
+ mkdir(fig_dir);
+end
+addpath(fig_dir);
+%%
+
+
+
+gamma=0.7;
+
+[signals, dgt_params, signal_params, mask, mask_area, dgt,...,
+ idgt] = get_mix(loc_source, wideband_src, gamma, win_dur, hop_ratio,...,
+ nbins_ratio, win_type, alpha, seuil, radius, fig_dir);
+
+
+fprintf('win_len:%.f\n', length(dgt_params.win));
+fprintf('hop:%.f\n', dgt_params.hop);
+fprintf('n_bins:%.f\n', dgt_params.nbins);
+%%
+mask_bool = mask;
+[mask_labeled, n_areas,t_subregions] = get_nareas(mask_bool,dgt, idgt, dgt_params,...,
+ signal_params, fig_dir, tol_subregions);
+
+
+%%
+[gabmul_list, mask_list] = get_P_gabmul(mask_labeled, dgt, idgt);
+
+x_mix = signals.mix;
+tolerance_arrf = 1e-3;
+proba_arrf = 1 - 1e-4;
+
+
+[t_arrf,t_evdn, t_ut_x, rank_q, s_vec_list, u_mat_list,...,
+ ut_x_list,r] = compute_decomposition(x_mix, mask_list, gabmul_list,...,
+ tolerance_arrf, proba_arrf);
+
+%% plot mask
+
+figure('name','mask');
+plot_mask(mask, dgt_params.hop,dgt_params.nbins, signal_params.fs);
+title(['mask : mask-area = ',num2str(mask_area)]);
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(fig_dir, 'mask.pdf'));
+
+%% Plot eigenvalues
+figure;
+
+for k_area=1:n_areas
+ txt = ['sub-region =' num2str(k_area)];
+ plot(s_vec_list{k_area},'LineWidth',3, 'DisplayName',txt);
+ hold on;
+end
+xlabel('$k$','Interpreter','latex');
+ylabel('$\sigma[k]$','Interpreter','latex');
+set(gca,'YScale','log');
+grid;
+legend show;
+set(gca, 'FontSize', 25, 'fontName','Times');
+xlabel('$k$','Interpreter','latex');
+set(gca, 'FontSize', 25, 'fontName','Times');
+saveas(gcf,fullfile(fig_dir, 'gabmul_eigenvalues.pdf'));
+
+%% find optimal lambda (best SDR)
+x_wideband = signals.wideband;
+x_rec = @(lambda_coef)compute_estimate(lambda_coef, x_mix, s_vec_list,...,
+ u_mat_list, ut_x_list);
+
+[lambda_oracle, t_oracle] = compute_lambda_oracle_sdr(n_areas,x_wideband, x_rec);
+
+
+
+fprintf("Running time to tune lambda (oracle): %f \n",t_oracle);
+
+%% Estimate energy and lambda
+
+
+[lambda_est, t_lambda_est] = compute_lambda(x_mix, mask_labeled, dgt_params,...,
+ signal_params, dgt,s_vec_list, u_mat_list, ut_x_list,...,
+ gabmul_list,fig_dir);
+
+fprintf("Running time to tune lambda (est): \n")
+disp(t_lambda_est);
+
+%% Estimate lambda from true energy
+e_wideband_true_energy = zeros(n_areas,1);
+x_wideband_tf_mat = dgt(gabmul_list{1}(signals.wideband));
+
+for k_area =1:n_areas
+ mask_k = (mask_labeled==k_area);
+ x_wideband_tf_masked = mask_k .* x_wideband_tf_mat;
+
+ e_wideband_true_energy(k_area) =norm(x_wideband_tf_masked, 'fro').^2;
+end
+e_wideband = e_wideband_true_energy;
+
+[lambda_true_energy, t_true_energy] = compute_lambda(x_mix, mask_labeled, dgt_params,...,
+ signal_params, dgt, s_vec_list, u_mat_list, ut_x_list,...,
+ gabmul_list, fig_dir,e_wideband);
+%%
+fprintf("Running time to tune lambda (True):\n")
+disp(t_true_energy);
+
+
+%% Results
+
+x_wideband = signals.wideband;
+sdr_wideband = @(lambda_coef)sdr(x_wideband, x_rec(lambda_coef));
+
+sdr_wideband_1area = @(lambda_coef, k_area)sdr_engine_1area(lambda_coef, k_area, x_rec, x_wideband, n_areas);
+
+is_wideband = @(lambda_coef) itakura_saito_dist_spectrum(x_wideband, x_rec(lambda_coef));
+
+is_wideband_1area = @(lambda_coef,k_area)is_spectrum_engine_1aera(x_wideband, k_area,lambda_coef, n_areas,x_rec);
+
+%% SDR for each aera
+
+l_range = 10.^linspace(-10,10,100);
+
+sdr_engine1area_l = zeros(length(l_range),1);
+
+
+figure;
+for k_area =1: n_areas
+ for k=1:length(l_range)
+ sdr_engine1area_l(k) = sdr_wideband_1area(l_range(k), k_area);
+ end
+ txt = ['SDR sub-reg =' num2str(k_area)];
+ plot(l_range, sdr_engine1area_l,'DisplayName',txt)
+end
+
+hold on;
+for k_area =1:n_areas
+ txt1 = ['TFF-O ',num2str(k_area)];
+ plot(lambda_oracle(k_area), sdr_wideband_1area(lambda_oracle(k_area), k_area),...,
+ '*','LineWidth',3,'DisplayName',txt1);
+ txt2 = ['TFF-P',num2str(k_area)];
+ plot(lambda_est(k_area),sdr_wideband_1area(lambda_est(k_area), k_area),...,
+ 'o','LineWidth',3,'DisplayName',txt2);
+ txt3 = ['TFF-E',num2str(k_area)];
+ plot(lambda_true_energy(k_area),sdr_wideband_1area(lambda_true_energy(k_area), k_area),...,
+ 'o','LineWidth',3,'DisplayName',txt3);
+ txt4 = ['Zero fill',num2str(k_area)];
+ plot(1, sdr_wideband_1area(1, k_area), 'o','LineWidth',3,'DisplayName',txt4);
+
+end
+legend show;
+
+
+xlabel('$\lambda$','Interpreter','latex')
+ylabel('SDR(dB)')
+set(gca,'XScale','log');
+grid on;
+set(gca, 'FontSize', 20, 'fontName','Times');
+
+saveas(gcf,fullfile(fig_dir, 'tuning_lambda.pdf'));
+
+
+%% Itakura saito for each aera
+is_engine1area_l = zeros(length(l_range),1);
+
+figure;
+for k_area =1: n_areas
+ for k=1:length(l_range)
+ is_engine1area_l(k) = is_wideband_1area(l_range(k), k_area);
+ end
+ txt = ['SDR sub-reg =' num2str(k_area)];
+ plot(l_range, is_engine1area_l,'LineWidth',3,'DisplayName',txt)
+end
+hold on;
+for k_area=1:n_areas
+
+ plot(lambda_oracle(k_area), is_wideband_1area(lambda_oracle(k_area),k_area), 'o','LineWidth',3)
+ plot(lambda_est(k_area), is_wideband_1area(lambda_est(k_area),k_area), 'o')
+ plot(lambda_true_energy(k_area), is_wideband_1area(lambda_true_energy(k_area),k_area),'o','LineWidth',3)
+ plot(1, is_wideband_1area(1,k_area), 'o','LineWidth',3)
+
+
+end
+
+
+xlabel('$\lambda$','Interpreter','latex')
+ylabel('IS (dB)')
+set(gca,'XScale','log');
+grid()
+legend('IS','TFF-O','TFF-P','TFF-E','Zero fill')
+axis tight;
+saveas(gcf,fullfile(fig_dir, 'tuning_lambda_IS.pdf'));
+%%
+figure;
+yyaxis left;
+plot(l_range, sdr_engine1area_l, '-','LineWidth',3); hold on;
+
+grid on;
+xlabel('$\lambda$','Interpreter','latex')
+ylabel('SDR (dB)')
+set(gca,'XScale','log');
+
+
+yyaxis right;
+
+plot(l_range,is_engine1area_l,'-','LineWidth',3); hold on;
+
+
+axis tight;
+legend('SDR TFF-P','IS TFF-P','Location','northwest');
+xlabel('$\lambda$','Interpreter','latex')
+ylabel('IS divergence')
+set(gca, 'FontSize', 20, 'fontName','Times');
+
+
+saveas(gcf,fullfile(fig_dir, 'tuning_lambda_SDR_IS.pdf'));
+
+
+%% Reconstructec signals
+tf_mat_mix = compute_dgt(signals.mix, dgt );
+
+x_oracle = x_rec(lambda_oracle);
+wav_write('x_oracle.wav', x_oracle, signal_params.fs);
+
+x_est = x_rec(lambda_est);
+wav_write('x_est.wav', x_est, signal_params.fs);
+
+x_true_energy = x_rec(lambda_true_energy);
+wav_write('x_true_energy.wav', x_true_energy, signal_params.fs);
+
+
+x_zero = solver_tfgm_zero(tf_mat_mix, mask, idgt);
+wav_write('x_zero_fill.wav', x_zero, signal_params.fs);
+
+x_interp= solver_tfgm_interp(tf_mat_mix, mask, idgt);
+wav_write('x_interp.wav', x_zero, signal_params.fs);
+
+
+%% Sdr
+
+
+sdr_oracle = sdr(x_wideband, x_oracle);
+sdr_est = sdr(x_wideband, x_est);
+sdr_true_energy = sdr(x_wideband, x_true_energy);
+sdr_zero = sdr(x_wideband, x_zero);
+sdr_interp = sdr(x_wideband, x_interp);
+sdr_mix = sdr(x_wideband, x_mix);
+
+
+%% Itakura saito
+is_oracle = itakura_saito_dist_spectrum(x_wideband,x_oracle);
+is_est = itakura_saito_dist_spectrum(x_wideband,x_est);
+is_true_energy = itakura_saito_dist_spectrum(x_wideband,x_true_energy);
+is_zero = itakura_saito_dist_spectrum(x_wideband,x_zero) ;
+is_mix= itakura_saito_dist_spectrum(x_wideband,x_mix) ;
+is_interp= itakura_saito_dist_spectrum(x_wideband,x_interp);
+
+%%
+
+
+
+fprintf('Oracle lambda: %f\n', lambda_oracle);
+fprintf('SDR for oracle lambda: %f dB\n',sdr_oracle);
+
+
+fprintf('Estimated lambda: %f \n', lambda_est);
+fprintf('SDR for estimated lambda: %f dB\n', sdr_est);
+
+
+fprintf('True-energy lambda: %f \n', lambda_true_energy);
+fprintf('SDR for true-energy lambda: %f dB\n', sdr_true_energy);
+
+fprintf('Zero filling SDR: %f dB\n', sdr_zero);
+fprintf('Mix SDR: %f dB \n',sdr_mix);
+fprintf('Interp + random phases filling SDR: %e dB\n',sdr_interp);
+
+%%
+
+figure;
+plot_spectrogram(x_mix, dgt_params, signal_params, dgt);
+title(['Mix SDR=' , num2str(sdr_mix,4),'dB ','IS= ',num2str(is_mix)]);
+set(gca, 'FontSize', 20, 'fontName','Times');
+axis tight;
+saveas(gcf,fullfile(fig_dir, 'mix.pdf'));
+
+figure;
+plot_spectrogram(signals.wideband, dgt_params, signal_params, dgt);
+title(['True source -', wideband_src])
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(fig_dir, 'spectrogram_true_wb_source.pdf'));
+
+
+figure;
+plot_spectrogram(x_zero, dgt_params, signal_params, dgt)
+title(['Zero fill SDR= ', num2str(sdr_zero,4),'dB ', 'IS=', num2str(is_zero)])
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(fig_dir, 'spectrogram_zero_fill.pdf'));
+
+
+
+
+figure;
+plot_spectrogram(x_oracle, dgt_params, signal_params, dgt)
+title(['TFF-O SDR= ', num2str(sdr_oracle,4), 'dB ','IS=', num2str(is_oracle)])
+set(gca, 'FontSize', 20, 'fontName','Times');
+axis tight;
+saveas(gcf,fullfile(fig_dir,'spectrogram_TFF-O.pdf'));
+
+
+
+%%
+
+figure;
+plot_spectrogram(x_est, dgt_params, signal_params, dgt)
+title(['TFF-P - SDR= ',num2str(sdr_est,4),'dB ','IS=',num2str(is_est)])
+set(gca, 'FontSize', 20, 'fontName','Times');
+axis tight;
+saveas(gcf,fullfile(fig_dir, 'spectrogram_TFF-P.pdf'));
+
+
+%%
+figure;
+plot_spectrogram(x_true_energy, dgt_params, signal_params,dgt)
+title(['TFF-E SDR= ', num2str(sdr_true_energy,4),'dB ','IS=',num2str(is_true_energy) ])
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(fig_dir, 'spectrogram_TFF-E.pdf'));
+%%
+
+
+figure;
+plot_spectrogram(x_interp, dgt_params, signal_params,dgt)
+title(['Interp SDR= ', num2str(sdr_interp,4),'dB ','IS=',num2str(is_interp)])
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(fig_dir,'spectrogram_interp.pdf'));
+%%
diff --git a/matlab/tfgm/scripts/solve_all_Narea_algo2.m b/matlab/tfgm/scripts/solve_all_Narea_algo2.m
new file mode 100644
index 0000000000000000000000000000000000000000..b7312df51b0e3eafd95088c47673bf02f51f6a3a
--- /dev/null
+++ b/matlab/tfgm/scripts/solve_all_Narea_algo2.m
@@ -0,0 +1,348 @@
+clc; clear; close all;
+
+%Algo 2 pour toutes les simuls
+%%
+pwd;
+pathname ='all_sig_Nareas';
+if ~exist('all_sig_Nareas','dir')
+ mkdir('all_sig_Nareas');
+end
+addpath('all_sig_Nareas')
+
+%%
+f = fopen('exp_Narea.csv', 'w');
+fprintf(f, '%s %s %s %s %s %s %s %s %s %s %s %s %s %s %s \n','loc_src', 'wb_src',...,
+ 'win_type','win_len','t_oracle','t_true_energy','t_est','t_arrf',...,
+ 't_evdn','t_ut_x','sdr_mix','sdr_interp', 'sdr_zero','sdr_est',...,
+ 'sdr_oracle');
+%%
+
+resampling_fs = 8000; % sampling frequency
+sig_len = 16384;
+
+target_name ={'car','plane','train'};
+per_name = {'beeps','bird','clicks','pop'};
+
+win_type_list = {'gauss','hann'};
+win_len_list = [256, 512];
+
+
+%%
+for w=1:1%length(win_type_list)
+
+win_type = win_type_list{w};
+win_len=win_len_list(w);
+
+params = get_params(win_len, win_type);
+
+
+for ind_wd=1:1%length(target_name)
+ fprintf("**************************************\n\n")
+ fprintf("I'am in the %.f ieme run. target source is:%s \n",ind_wd ,target_name{ind_wd});
+ fprintf("**************************************\n\n")
+ for ind_loc=1:1%length(per_name)
+ fprintf("Perturbation source number %.f : %s \n", ind_loc,per_name{ind_loc}) ;
+ fprintf("**************************************\n\n")
+
+ [radius, gain_mix_db,gain_loc_db, deb] = set_smooth_mask_params(ind_wd, ind_loc, win_type);
+ win_len = params.win_len;
+ win_type = params.win_type;
+ hop = params.hop ;
+ nbins = params.nbins ;
+
+
+
+ deb_ind_wd=0;
+ deb_ind_loc=deb;
+
+
+ or_mask=1;
+ approx_win_len = win_len;
+
+
+
+ [signals, dgt_params, signal_params, mask_bool, dgt,idgt] = get_mix(ind_loc, ...,
+ ind_wd, deb_ind_loc, deb_ind_wd, resampling_fs, sig_len,...,
+ approx_win_len,hop, nbins, win_type, gain_mix_db, gain_loc_db,radius,or_mask);
+
+
+ fprintf("We work with %s window of length %.f\n", win_type, win_len);
+
+ fprintf("Gabor transform parameters are: \n")
+ fprintf('hop :%2.f\n', dgt_params.hop);
+ fprintf('n_bins: %2.f\n', dgt_params.nbins);
+
+
+ %%
+ figure; % window plot
+ plot_win(dgt_params.win, signal_params.fs, signal_params.sig_len, win_type)
+ title([num2str(win_type), ' - window']);
+ set(gca, 'FontSize', 20, 'fontName','Times');
+ saveas(gcf,fullfile(pathname, [target_name{ind_wd},'_' per_name{ind_loc},'_' num2str(win_type),'_window.png']));
+
+ % mask plot
+
+ [mask_area, mask_area_ratio] = get_mask_area(mask_bool);
+ figure('name','mask'); plot_spectrogram(mask_bool, dgt_params,signal_params, dgt);
+ title(['mask : mask-area = ',num2str(mask_area)]);
+ set(gca, 'FontSize', 20, 'fontName','Times');
+ saveas(gcf,fullfile(pathname, [target_name{ind_wd},'_' per_name{ind_loc},'_' num2str(win_type),'_mask.png']));
+
+ %%
+
+ tol_subregions = 1e-5;
+ [mask_labeled, n_areas] = get_nareas(mask_bool,dgt, idgt, dgt_params,...,
+ signal_params,tol_subregions);
+
+ [gabmul_list, mask_list] = get_P_gabmul(mask_labeled, dgt, idgt);
+
+ %% compute EVD decomposition
+
+ %Halko params
+ tolerance_arrf = 1e-3;
+ proba_arrf = 1-1e-4;
+
+ x_mix = signals.mix; % mix
+ masks = mask_list;
+
+ % compute EVD usisng Halko
+ [t_arrf,t_evdn, t_ut_x, rank_q, s_vec_list, u_mat_list, ut_x_list, ...,
+ r] = compute_decomposition(x_mix, masks, gabmul_list, tolerance_arrf, proba_arrf);
+
+ fprintf("Estimated rank is : %.f \n", rank_q);
+
+ %% Plot eigenvalues
+ figure;
+
+ for k=1:n_areas
+ txt = ['sub-region =' num2str(k)];
+ plot(s_vec_list{k},'LineWidth',3, 'DisplayName',txt);
+ hold on;
+ end
+ xlabel('$k$','Interpreter','latex');
+ ylabel('$\sigma[k]$','Interpreter','latex');
+ set(gca,'YScale','log');
+ grid;
+ legend show;
+ set(gca, 'FontSize', 20, 'fontName','Times');
+ xlabel('$k$','Interpreter','latex');
+ set(gca, 'FontSize', 20, 'fontName','Times');
+
+ saveas(gcf,fullfile(pathname,...,
+ [target_name{ind_wd},'_' per_name{ind_loc},'_' 'gabmul_eigenvalues.png']));
+
+ %% find optimal lambda (best SDR)
+ x_target = signals.target;
+ [lambda_oracle, t_oracle] = compute_lambda_oracle_sdr(x_target, x_mix,...,
+ s_vec_list, u_mat_list, ut_x_list);
+
+ fprintf("Running time to tune lambda (oracle): %f \n",t_oracle);
+ %% estimate energy and lambda -our method
+ [lambda_est, t_est] = compute_lambda(x_mix, mask_labeled, dgt_params,...,
+ signal_params, dgt,s_vec_list, u_mat_list, ut_x_list,...,
+ gabmul_list);
+
+ fprintf("Running time to tune lambda (est): %f \n",t_est);
+
+
+
+ %% estimate lambda from true energy
+
+ n_areas = length(s_vec_list);
+ e_target_true_energy = zeros(n_areas,1);
+ x_engine_tf_mat = dgt(gabmul_list{1}(x_target));
+
+ for k_area =1:n_areas
+ mask_k = (mask_labeled==k_area);
+ x_engine_tf_masked = mask_k .* x_engine_tf_mat;
+
+ e_target_true_energy(k_area) =norm(x_engine_tf_masked, 'fro').^2;
+ end
+ e_target = e_target_true_energy;
+
+ [lambda_true_energy, t_true_energy] = compute_lambda(x_mix, mask_labeled, dgt_params,...,
+ signal_params, dgt, s_vec_list, u_mat_list, ut_x_list,...,
+ gabmul_list, e_target);
+
+ fprintf("Running time to tune lambda (True): %f \n",t_true_energy);
+
+
+
+ %% Results
+
+ x_est = @(lambda_coef)compute_estimate(lambda_coef, x_mix,s_vec_list, u_mat_list, ut_x_list);
+
+ x_engine = signals.target;
+ sdr_engine = @(lambda_coef)sdr(x_engine, x_est(lambda_coef));
+
+ %
+ tf_mat_mix = compute_dgt(signals.mix, dgt );
+
+ %interpolation
+ x_interp= solver_tfgm_interp(tf_mat_mix, mask_bool, idgt);
+
+ %zero fill
+ x_zero = solver_tfgm_zero(tf_mat_mix, mask_bool, idgt);
+ sdr_zero = sdr(x_engine, x_zero);
+ sdr_interp = sdr(x_engine, x_interp);
+
+ %%
+ figure;
+ l_range = 10.^(linspace(-10,10,100));
+ sdr_engine_l = zeros(length(l_range),1);
+
+ for l =1:length(l_range)
+ sdr_engine_l(l) = sdr_engine(l_range(l));
+ end
+ semilogx(l_range,sdr_engine_l, '-', 'LineWidth',3);
+ hold on;
+ semilogx(l_range,sdr_engine(lambda_oracle)*ones(length(l_range),1), 'r-','LineWidth',3)
+ semilogx(l_range,sdr_engine(lambda_est)*ones(length(l_range),1), 'm-', 'LineWidth',3)
+ %semilogx(l_range,sdr_engine(lambda_true_energy)*ones(length(l_range),1), 'g-','LineWidth',3)
+ semilogx(l_range,sdr_zero*ones(length(l_range),1), 'c-', 'LineWidth',3);
+ semilogx(l_range,sdr_interp*ones(length(l_range),1), 'b-', 'LineWidth',3);
+ xlabel('$\lambda$','Interpreter','latex')
+ ylabel('SDR(dB)')
+ set(gca,'XScale','log');
+ grid on;
+ set(gca, 'FontSize', 20, 'fontName','Times');
+ legend('SDR', 'Oracle SDR','Estimate','Zerofill',...,
+ 'Interp','Location','southeast')
+
+
+ %% Reconstructed signals
+
+ x_oracle = x_est(lambda_oracle);
+ wav_write('x_oracle.wav', x_oracle, signal_params.fs);
+
+ x_rec = x_est(lambda_est);
+ wav_write('x_est.wav', x_rec, signal_params.fs);
+
+ x_true_energy = x_est(lambda_true_energy);
+ wav_write('x_true_energy.wav', x_true_energy, signal_params.fs);
+
+
+ x_zero = solver_tfgm_zero(tf_mat_mix, mask_bool, idgt);
+ wav_write('x_zero_fill.wav', x_zero, signal_params.fs);
+
+ %x_interp
+ x_interp= solver_tfgm_interp(tf_mat_mix, mask_bool, idgt);
+ wav_write('x_interp.wav', x_interp, signal_params.fs);
+ %sdr
+
+ sdr_oracle = sdr(x_engine, x_oracle);
+ sdr_rec = sdr(x_engine, x_rec);
+ sdr_true_energy = sdr(x_engine, x_true_energy);
+ sdr_zero = sdr(x_engine, x_zero);
+ sdr_interp = sdr(x_engine, x_interp);
+ sdr_mix = sdr(x_engine, x_mix);
+
+ %% Itakura saito
+% is_true = itakura_saito_dist_spectrum(x_target,x_true_energy);
+% is_zero = itakura_saito_dist_spectrum(x_target,x_zero) ;
+% is_mix= itakura_saito_dist_spectrum(x_target,x_mix) ;
+% is_tff= itakura_saito_dist_spectrum(x_target,x_rec) ;
+% is_interp= itakura_saito_dist_spectrum(x_target,x_interp);
+%
+
+
+ %%
+ % print
+
+
+ fprintf('Oracle lambda: %f\n', lambda_oracle);
+ fprintf('True-energy lambda: %f \n', lambda_true_energy);
+ fprintf('Estimated lambda: %f \n', lambda_est);
+
+
+ fprintf('SDR for oracle lambda: %f dB\n',sdr_oracle);
+ fprintf('SDR for estimated lambda: %f dB\n', sdr_rec);
+ fprintf('SDR for true-energy lambda: %f dB\n', sdr_true_energy);
+ fprintf('Zero filling SDR: %f dB\n', sdr_zero);
+ fprintf('Mix SDR: %f dB \n',sdr_mix);
+ fprintf('Interp + random phases filling SDR: %e dB\n',sdr_interp);
+ %%
+ x_per = signals.noise;
+ figure;
+ plot_spectrogram(x_mix, dgt_params, signal_params, dgt)
+ title(['Mix SDR=' , num2str(sdr_mix),'dB']);
+ set(gca, 'FontSize', 20, 'fontName','Times');
+ saveas(gcf,fullfile(pathname, [target_name{ind_wd},'_' per_name{ind_loc},'_','mix.pdf']));
+
+ figure;
+ plot_spectrogram(x_target, dgt_params, signal_params, dgt);
+ title(['True source -',target_name{ind_wd}])
+ set(gca, 'FontSize', 20, 'fontName','Times');
+ saveas(gcf,fullfile(pathname, [target_name{ind_wd},'_' per_name{ind_loc},'_', 'spectrogram_true_wb_source.pdf']));
+
+ figure;
+ plot_spectrogram(x_per, dgt_params, signal_params, dgt);
+ title(['Pertur -',per_name{ind_loc}])
+ set(gca, 'FontSize', 20, 'fontName','Times');
+ saveas(gcf,fullfile(pathname, [target_name{ind_wd},'_' per_name{ind_loc},'_', 'spectrogram_true_wb_source.pdf']));
+
+
+ figure;
+ plot_spectrogram(x_zero, dgt_params, signal_params, dgt)
+ title(['Zero fill SDR= ', num2str(sdr_zero),'dB'])
+ set(gca, 'FontSize', 20, 'fontName','Times');
+ saveas(gcf,fullfile(pathname, [target_name{ind_wd},'_' per_name{ind_loc},'_' ,'spectrogram_zero_fill.pdf']));
+
+
+
+
+ figure;
+ plot_spectrogram(x_oracle, dgt_params, signal_params, dgt)
+ title(['\lambda_{opt} SDR= ', num2str(sdr_oracle), 'dB'])
+ set(gca, 'FontSize', 20, 'fontName','Times');
+ saveas(gcf,fullfile(pathname, [target_name{ind_wd},'_' per_name{ind_loc},'_','spectrogram_oracle_sdr.pdf']));
+
+
+ figure;
+ plot_spectrogram(x_rec, dgt_params, signal_params, dgt)
+ title(['Estimated \lambda SDR= ', num2str(sdr_rec),'dB'])
+ set(gca, 'FontSize', 20, 'fontName','Times');
+ saveas(gcf,fullfile(pathname, [target_name{ind_wd},'_' per_name{ind_loc},'_','spectrogram_tff_estimate.pdf']));
+
+
+ figure;
+ plot_spectrogram(x_true_energy, dgt_params, signal_params, dgt)
+ title(['True energy \lambda SDR= ',num2str(sdr_true_energy),'dB'])
+ set(gca, 'FontSize', 20, 'fontName','Times');
+ saveas(gcf,fullfile(pathname, [target_name{ind_wd},'_' per_name{ind_loc},'_','spectrogram_oracle_true_energy.pdf']));
+
+
+ figure;
+ plot_spectrogram(x_interp, dgt_params, signal_params,dgt)
+ title(['interp SDR= ', num2str(sdr_interp),'dB'])
+ set(gca, 'FontSize', 20, 'fontName','Times');
+ saveas(gcf,fullfile(pathname, [target_name{ind_wd},'_' per_name{ind_loc},'_' ,'spectrogram_interp.pdf']));
+ %%
+
+ fprintf(f,'%s %s %s %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f \n',...,
+ target_name{ind_wd},per_name{ind_loc},win_type_list{w},win_len_list(w),t_oracle,t_true_energy,...,
+ t_est,t_arrf,t_evdn,t_ut_x,sdr_mix, sdr_interp,...,
+ sdr_zero,sdr_rec,sdr_oracle);
+
+
+
+
+ %%
+
+ file_name = ['exp_Nregions',target_name{ind_wd},'_',per_name{ind_loc},'_','.mat'];
+ save(file_name,'ind_wd','ind_loc','resampling_fs','sig_len','radius', ...,
+ 'deb_ind_loc', 'deb_ind_wd','win_len','win_type', 'signals', 'dgt_params', ...,
+ 'signal_params', 'mask_bool', 'dgt','idgt','mask_area', 'mask_area_ratio',...,
+ 'gabmul_list','mask_list','tolerance_arrf', 'proba_arrf', 't_arrf', 't_evdn',...,
+ 't_ut_x', 'rank_q', 's_vec_list', 'u_mat_list', 'ut_x_list','r',....,
+ 'lambda_est', 't_true_energy','e_target_true_energy','e_target','lambda_true_energy',...,
+ 'lambda_oracle', 't_oracle','x_oracle','x_rec','x_true_energy','x_zero',...,
+ 'x_interp', 'sdr_mix', 'sdr_oracle','sdr_true_energy', 'sdr_zero', 'sdr_interp');
+
+ end
+
+
+end
+end
+
+fclose(f);
\ No newline at end of file
diff --git a/matlab/tfgm/scripts/solve_all_tff1.m b/matlab/tfgm/scripts/solve_all_tff1.m
new file mode 100644
index 0000000000000000000000000000000000000000..e684bfbe2042ea7dd45d4d6c286cbbacc56ea268
--- /dev/null
+++ b/matlab/tfgm/scripts/solve_all_tff1.m
@@ -0,0 +1,375 @@
+clc; clear; close all;
+
+%%
+wb_list ={'car','plane','train'};
+loc_list = {'beeps','bird','clicks','finger_snaps','modulations'};
+win_list = {'gauss 256', 'hann 512'};
+
+
+tol_subregions = 0;
+gamma=0.7;
+%%
+
+f = fopen('exp_1area_cuicui.csv', 'w');
+fprintf(f, '%s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s \n','loc_src', 'wb_src',...,
+ 'win_type','win_len','t_oracle','t_true_energy','t_est','t_arrf',...,
+ 't_evdn','t_ut_x','sdr_mix','sdr_interp', 'sdr_zero','sdr_est',...,
+ 'sdr_oracle','is_interp', 'is_mix', 'is_true', 'is_zero', 'is_est');
+
+
+%%
+for win =1:length(win_list)
+
+ [win_type, win_dur, win_len, hop_ratio, nbins_ratio] = get_win_params(win_list{win});
+
+ fprintf("window: %s - length: %.f\n", win_type, win_len);
+ for wb = 1:1%length(wb_list)
+ wideband_src = wb_list{wb};
+ fprintf("**************************************\n\n")
+ fprintf("This is the %.f ieme run. wideband source is:%s \n",wb ,wb_list{wb});
+ fprintf("**************************************\n\n")
+ for loc=1:1%length(loc_list)
+
+ pwd;
+ fig_dir =['fig_', wb_list{wb},'_',loc_list{loc},'_', win_type,'_',num2str(win_len)];
+ if ~exist(fig_dir,'dir')
+ mkdir(fig_dir);
+ end
+ addpath(fig_dir)
+ %%
+ fprintf("loalized source number %.f : %s \n",loc,loc_list{loc}) ;
+ fprintf("**************************************\n\n")
+ loc_source=loc_list{loc};
+
+ %%
+ [alpha, seuil, radius] = set_smooth_mask_params(wideband_src, loc_source, win_type);
+
+
+ [signals, dgt_params, signal_params, mask, mask_area, dgt,...,
+ idgt] = get_mix(loc_source, wideband_src, gamma, win_dur, hop_ratio,...,
+ nbins_ratio, win_type, alpha, seuil, radius, fig_dir);
+
+
+ fprintf('win_len:%.f\n', length(dgt_params.win));
+ fprintf('hop:%.f\n', dgt_params.hop);
+ fprintf('n_bins:%.f\n', dgt_params.nbins);
+
+ %% create subregions
+
+ mask_bool = mask;
+ [mask_labeled, n_areas,t_subregions] = get_nareas(mask_bool,dgt, idgt, dgt_params,...,
+ signal_params, fig_dir, tol_subregions);
+
+ %% EVD via Halko
+
+ [gabmul_list, mask_list] = get_P_gabmul(mask_labeled, dgt, idgt);
+
+ x_mix = signals.mix;
+ tolerance_arrf = 1e-3;
+ proba_arrf = 1 - 1e-4;
+
+
+ [t_arrf,t_evdn, t_ut_x, rank_q, s_vec_list, u_mat_list,...,
+ ut_x_list,r] = compute_decomposition(x_mix, mask_list, gabmul_list,...,
+ tolerance_arrf, proba_arrf);
+
+ %% mask
+
+ [mask_area, mask_area_ratio] = get_mask_area(mask);
+ figure('name','mask');
+ plot_spectrogram(mask, dgt_params,signal_params, dgt);
+ title(['mask : mask-area = ',num2str(mask_area)]);
+ set(gca, 'FontSize', 20, 'fontName','Times');
+ saveas(gcf,fullfile(fig_dir,'mask.pdf'));
+
+
+ %% Plot eigenvalues
+ figure;
+
+ for k_area=1:n_areas
+ txt = ['sub-region =' num2str(k_area)];
+ plot(s_vec_list{k_area},'LineWidth',3, 'DisplayName',txt);
+ hold on;
+ end
+ xlabel('$k$','Interpreter','latex');
+ ylabel('$\sigma[k]$','Interpreter','latex');
+ set(gca,'YScale','log');
+ grid;
+ legend show;
+ set(gca, 'FontSize', 25, 'fontName','Times');
+ xlabel('$k$','Interpreter','latex');
+ set(gca, 'FontSize', 25, 'fontName','Times');
+ saveas(gcf,fullfile(fig_dir, 'gabmul_eigenvalues.pdf'));
+
+
+
+ %% Find optimal lambda (best SDR)
+
+ x_wideband = signals.wideband;
+ x_rec = @(lambda_coef)compute_estimate(lambda_coef, x_mix, s_vec_list,...,
+ u_mat_list, ut_x_list);
+
+ [lambda_oracle, t_oracle] = compute_lambda_oracle_sdr(n_areas,x_wideband, x_rec);
+
+
+
+ fprintf("Running time to tune lambda (oracle): %f \n",t_oracle);
+
+ %% Estimate energy and lambda
+
+ [lambda_est, t_est] = compute_lambda(x_mix, mask, dgt_params,...,
+ signal_params, dgt,s_vec_list, u_mat_list, ut_x_list,...,
+ gabmul_list,fig_dir);
+
+ fprintf("Running time to tune lambda (est): %f \n",t_est);
+
+ %% Estimate lambda from true energy
+
+ e_wideband_true_energy = zeros(n_areas,1);
+ x_wideband_tf_mat = dgt(gabmul_list{1}(signals.wideband));
+
+ for k_area =1:n_areas
+ mask_k = (mask_labeled==k_area);
+ x_wideband_tf_masked = mask_k .* x_wideband_tf_mat;
+
+ e_wideband_true_energy(k_area) =norm(x_wideband_tf_masked, 'fro').^2;
+ end
+ e_wideband = e_wideband_true_energy;
+
+ [lambda_true_energy, t_true_energy] = compute_lambda(x_mix, mask, dgt_params,...,
+ signal_params, dgt, s_vec_list, u_mat_list, ut_x_list,...,
+ gabmul_list,fig_dir, e_wideband);
+
+ fprintf("Running time to tune lambda (True): %f \n",t_true_energy);
+
+
+ %% Results
+
+ x_wideband = signals.wideband;
+ sdr_wideband = @(lambda_coef)sdr(x_wideband, x_rec(lambda_coef));
+
+ sdr_wideband_1area = @(lambda_coef)sdr_engine_1area(lambda_coef, signals, k_area,...,
+ n_areas,s_vec_list, u_mat_list, ut_x_list);
+
+ is_wideband = @(lambda_coef) itakura_saito_dist_spectrum(x_wideband, x_rec(lambda_coef));
+
+
+
+ %% sdr wideband
+
+ l_range = 10.^linspace(-10,10,100);
+ sdr_wideband_l = zeros(length(l_range),1);
+ sdr_engine1area_l = zeros(length(l_range),1);
+
+
+ for k =1:length(l_range)
+ sdr_wideband_l(k) = sdr_wideband(l_range(k));
+ end
+ figure;
+ plot(l_range,sdr_wideband_l, '-','LineWidth',3);
+ hold on;
+ plot(lambda_oracle,sdr_wideband(lambda_oracle),'gs','MarkerSize',12);
+ plot(lambda_est,sdr_wideband(lambda_est),'o','MarkerSize',12)
+ plot(lambda_true_energy,sdr_wideband(lambda_true_energy),'*','MarkerSize',12)
+ plot(1,sdr_wideband(1),'o','MarkerSize',12)
+ legend('SDR', 'TFF-O','TFF-1', 'TFF-E','Zero fill');
+
+ xlabel('$\lambda$','Interpreter','latex')
+ ylabel('SDR(dB)')
+ set(gca,'XScale','log');
+ grid on;
+ set(gca, 'FontSize', 20, 'fontName','Times');
+
+ saveas(gcf,fullfile(fig_dir, 'tuning_lambda.pdf'));
+
+
+ %% Itakura saito
+ is_wideband_l = zeros(length(l_range),1);
+
+ figure;
+ for l =1: length(l_range)
+ is_wideband_l(l) = is_wideband(l_range(l));
+ end
+ plot(l_range, is_wideband_l,'-','LineWidth',3)
+ plot(lambda_oracle, is_wideband(lambda_oracle), 'o','LineWidth',3)
+ plot(lambda_est, is_wideband(lambda_est), 'o')
+ plot(lambda_true_energy, is_wideband(lambda_true_energy),'o','LineWidth',3)
+ plot(1, is_wideband(1), 'o','LineWidth',3)
+
+ xlabel('$\lambda$','Interpreter','latex')
+ ylabel('IS (dB)')
+ set(gca,'XScale','log');
+ grid()
+ legend('SDR','TFF-O','TFF-1','TFF-E','Zero fill')
+ axis tight;
+ saveas(gcf,fullfile(fig_dir, 'tuning_lambda_IS.pdf'));
+
+ %% plot both sdr and itakura saito in the same axis
+ figure;
+ yyaxis left;
+ plot(l_range, sdr_wideband_l, '-','LineWidth',3); hold on;
+ plot(lambda_est, sdr_wideband(lambda_est), 'o','MarkerSize',3,'LineWidth',3)
+ plot(lambda_true_energy, sdr_wideband(lambda_true_energy), 'bo','LineWidth',3)
+ plot(lambda_oracle, sdr_wideband(lambda_oracle), 'go','LineWidth',3)
+ plot(1, sdr_wideband(1), 'mo','LineWidth',3);
+ grid on;
+ xlabel('$\lambda$','Interpreter','latex')
+ ylabel('SDR (dB)')
+ set(gca,'XScale','log');
+
+
+ yyaxis right;
+
+ plot(l_range,is_wideband_l,'-','LineWidth',3); hold on;
+ plot(lambda_est, is_wideband(lambda_est), 'o','MarkerSize',3,'LineWidth',3)
+ plot(lambda_true_energy, is_wideband(lambda_true_energy),'bo','LineWidth',3)
+ plot(lambda_oracle, is_wideband(lambda_oracle), 'go','LineWidth',3)
+ plot(1, is_wideband(1), 'mo','LineWidth',3)
+
+
+
+
+ axis tight;
+ legend('SDR','TFF-1','TFF-E','TFF-O','Zero fill','Location','northwest');
+ xlabel('$\lambda$','Interpreter','latex')
+ ylabel('IS divergence')
+ set(gca, 'FontSize', 20, 'fontName','Times');
+
+
+ saveas(gcf,fullfile(fig_dir, 'tuning_lambda_SDR_IS.pdf'));
+
+
+ %% Reconstructed signals
+ tf_mat_mix = compute_dgt(signals.mix, dgt );
+
+ x_oracle = x_rec(lambda_oracle);
+ wav_write('x_oracle.wav', x_oracle, signal_params.fs);
+
+ x_est = x_rec(lambda_est);
+ wav_write('x_est.wav', x_est, signal_params.fs);
+
+ x_true_energy = x_rec(lambda_true_energy);
+ wav_write('x_true_energy.wav', x_true_energy, signal_params.fs);
+
+
+ x_zero = solver_tfgm_zero(tf_mat_mix, mask, idgt);
+ wav_write('x_zero_fill.wav', x_zero, signal_params.fs);
+
+ x_interp= solver_tfgm_interp(tf_mat_mix, mask, idgt);
+ wav_write('x_interp.wav', x_zero, signal_params.fs);
+
+
+ %% Sdr
+
+
+ sdr_oracle = sdr(x_wideband, x_oracle);
+ sdr_est = sdr(x_wideband, x_est);
+ sdr_true_energy = sdr(x_wideband, x_true_energy);
+ sdr_zero = sdr(x_wideband, x_zero);
+ sdr_interp = sdr(x_wideband, x_interp);
+ sdr_mix = sdr(x_wideband, x_mix);
+
+
+ %% Itakura saito
+ is_oracle = itakura_saito_dist_spectrum(x_wideband,x_oracle);
+ is_est = itakura_saito_dist_spectrum(x_wideband,x_est);
+ is_true_energy = itakura_saito_dist_spectrum(x_wideband,x_true_energy);
+ is_zero = itakura_saito_dist_spectrum(x_wideband,x_zero) ;
+ is_mix= itakura_saito_dist_spectrum(x_wideband,x_mix) ;
+ is_interp= itakura_saito_dist_spectrum(x_wideband,x_interp);
+
+ %%
+
+
+
+ fprintf('Oracle lambda: %f\n', lambda_oracle);
+ fprintf('SDR for oracle lambda: %f dB\n',sdr_oracle);
+
+
+ fprintf('Estimated lambda: %f \n', lambda_est);
+ fprintf('SDR for estimated lambda: %f dB\n', sdr_est);
+
+
+ fprintf('True-energy lambda: %f \n', lambda_true_energy);
+ fprintf('SDR for true-energy lambda: %f dB\n', sdr_true_energy);
+
+ fprintf('Zero filling SDR: %f dB\n', sdr_zero);
+ fprintf('Mix SDR: %f dB \n',sdr_mix);
+ fprintf('Interp + random phases filling SDR: %e dB\n',sdr_interp);
+
+ %%
+
+ figure;
+ plot_spectrogram(x_mix, dgt_params, signal_params, dgt);
+ title(['Mix SDR=' , num2str(sdr_mix,4),'dB ','IS= ',num2str(is_mix)]);
+ set(gca, 'FontSize', 20, 'fontName','Times');
+ axis tight;
+ saveas(gcf,fullfile(fig_dir, 'mix.pdf'));
+
+ figure;
+ plot_spectrogram(signals.wideband, dgt_params, signal_params, dgt);
+ title(['True source -', wideband_src])
+ set(gca, 'FontSize', 20, 'fontName','Times');
+ saveas(gcf,fullfile(fig_dir, 'spectrogram_true_wb_source.pdf'));
+
+
+ figure;
+ plot_spectrogram(x_zero, dgt_params, signal_params, dgt)
+ title(['Zero fill SDR= ', num2str(sdr_zero,4),'dB ', 'IS=', num2str(is_zero)])
+ set(gca, 'FontSize', 20, 'fontName','Times');
+ saveas(gcf,fullfile(fig_dir, 'spectrogram_zero_fill.pdf'));
+
+
+
+
+ figure;
+ plot_spectrogram(x_oracle, dgt_params, signal_params, dgt)
+ title(['TFF-O SDR= ', num2str(sdr_oracle,4), 'dB ','IS=', num2str(is_oracle)])
+ set(gca, 'FontSize', 20, 'fontName','Times');
+ axis tight;
+ saveas(gcf,fullfile(fig_dir,'spectrogram_TFF-O.pdf'));
+
+
+
+
+
+ figure;
+ plot_spectrogram(x_est, dgt_params, signal_params, dgt)
+
+
+ title(['TFF-1 - SDR= ',num2str(sdr_est,4),'dB ','IS=',num2str(is_est)])
+ set(gca, 'FontSize', 20, 'fontName','Times');
+ axis tight;
+ saveas(gcf,fullfile(fig_dir, 'spectrogram_TFF-1.pdf'));
+
+
+ figure;
+ plot_spectrogram(x_true_energy, dgt_params, signal_params,dgt)
+ title(['TFF-E SDR= ', num2str(sdr_true_energy,4),'dB ','IS=',num2str(is_true_energy) ])
+ set(gca, 'FontSize', 20, 'fontName','Times');
+ saveas(gcf,fullfile(fig_dir, 'spectrogram_TFF-E.pdf'));
+
+ %%
+
+ figure;
+ plot_spectrogram(x_interp, dgt_params, signal_params,dgt)
+ title(['Interp SDR= ', num2str(sdr_interp,4),'dB ','IS=',num2str(is_interp)])
+ set(gca, 'FontSize', 20, 'fontName','Times');
+ saveas(gcf,fullfile(fig_dir,'spectrogram_interp.pdf'));
+
+ %% save in csv
+ fprintf(f,'%s %s %s %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f \n',...,
+ wb_list{wb},loc_list{loc},win_list{win},win_len,t_oracle,t_true_energy,...,
+ t_est,t_arrf,t_evdn,t_ut_x,sdr_mix, sdr_interp,...,
+ sdr_zero,sdr_est,sdr_oracle, is_interp, is_mix, is_est, is_zero, is_oracle);
+
+
+
+
+
+ end
+
+ end
+end
+
+
diff --git a/matlab/tfgm/scripts/solve_all_tffP.m b/matlab/tfgm/scripts/solve_all_tffP.m
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/matlab/tfgm/scripts/solve_p1area_cuicui.m b/matlab/tfgm/scripts/solve_p1area_cuicui.m
new file mode 100644
index 0000000000000000000000000000000000000000..41f5d1cbd10723ee76be16b791942f1a905ef06d
--- /dev/null
+++ b/matlab/tfgm/scripts/solve_p1area_cuicui.m
@@ -0,0 +1,412 @@
+
+clc; clear; close all;
+% Algo 1
+%%
+pwd;
+pathname ='solve_1area_cuicui';
+if ~exist('solve_1area_cuicui','dir')
+ mkdir('solve_1area_cuicui');
+end
+addpath('solve_1area_cuicui')
+
+
+%%
+fs = 8000; % sampling frequency
+sig_len = 16384; % siglen
+
+%% DGT params - signals - mask
+close all
+
+win_len = 512;
+win_type = 'hann';
+params = get_params(win_len, win_type);%Gauss
+
+win_len = params.win_len;
+win_type = params.win_type;
+hop = params.hop;
+nbins = params.nbins;
+
+wideband_src = 'car';
+loc_source='modulations';
+
+win_dur=win_len/8000;
+hop_ratio=1/8;
+nbins_ratio = 2;
+
+[alpha, seuil, radius] = set_smooth_mask_params(wideband_src, loc_source, win_type);
+gamma=0.7;
+fig_dir = pathname;
+
+ [signals, dgt_params, signal_params, mask, mask_area, dgt,...,
+ idgt] = get_mix(loc_source, wideband_src, gamma, win_dur, hop_ratio,...,
+ nbins_ratio, win_type, alpha, seuil, radius, fig_dir);
+
+
+%%
+[mask_area, mask_area_ratio] = get_mask_area(mask);
+
+fprintf("We work with %s window of length %.f\n", win_type, win_len);
+
+fprintf("Gabor transform parameters are: \n")
+fprintf('hop :%2.f\n', dgt_params.hop);
+fprintf('n_bins: %2.f\n', dgt_params.nbins);
+
+
+fprintf("The parameters for smoothing the mask are: \n")
+fprintf("alpha = %f\n", alpha);
+fprintf("seuil = %f\n", seuil);
+fprintf("radius = %f\n", radius);
+
+figure; % window plot
+plot_win(dgt_params.win, signal_params.fs, signal_params.sig_len, win_type)
+title([num2str(win_type), ' - window']);
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(pathname, [num2str(win_type),'_window.png']));
+
+
+
+
+
+
+%% plot mask
+
+figure('name','mask'); plot_spectrogram(mask, dgt_params,signal_params, dgt);
+title(['mask : mask-area = ',num2str(mask_area)]);
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(pathname, 'gauss_mask.png'));
+
+
+
+%%
+mask_bool = mask;
+tol_subregions = 0;
+[mask_labeled, n_areas,t_subregions] = get_nareas(mask_bool,dgt, idgt, dgt_params,...,
+ signal_params, fig_dir,tol_subregions);
+
+
+[gabmul_list, mask_list] = get_P_gabmul(mask_labeled, dgt, idgt);
+
+x_mix = signals.mix;
+tolerance_arrf = 1e-3;
+proba_arrf = 1 - 1e-4;
+
+
+[t_arrf,t_evdn, t_ut_x, rank_q, s_vec_list, u_mat_list,...,
+ ut_x_list,r] = compute_decomposition(x_mix, mask_list, gabmul_list,...,
+ tolerance_arrf, proba_arrf);
+
+%% plot mask
+
+figure('name','mask');
+plot_mask(mask, dgt_params.hop,dgt_params.nbins, signal_params.fs);
+title(['mask : mask-area = ',num2str(mask_area)]);
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(fig_dir, 'mask.pdf'));
+
+%% Plot eigenvalues
+figure;
+
+for k_area=1:n_areas
+ txt = ['sub-region =' num2str(k_area)];
+ plot(s_vec_list{k_area},'LineWidth',3, 'DisplayName',txt);
+ hold on;
+end
+xlabel('$k$','Interpreter','latex');
+ylabel('$\sigma[k]$','Interpreter','latex');
+set(gca,'YScale','log');
+grid;
+legend show;
+set(gca, 'FontSize', 25, 'fontName','Times');
+xlabel('$k$','Interpreter','latex');
+set(gca, 'FontSize', 25, 'fontName','Times');
+saveas(gcf,fullfile(fig_dir, 'gabmul_eigenvalues.pdf'));
+
+%% find optimal lambda (best SDR)
+x_wideband = signals.wideband;
+x_rec = @(lambda_coef)compute_estimate(lambda_coef, x_mix, s_vec_list,...,
+ u_mat_list, ut_x_list);
+
+[lambda_oracle, t_oracle] = compute_lambda_oracle_sdr(n_areas,x_wideband, x_rec);
+
+
+
+fprintf("Running time to tune lambda (oracle): %f \n",t_oracle);
+
+%% Estimate energy and lambda
+
+
+[lambda_est, t_est] = compute_lambda(x_mix, mask_labeled, dgt_params,...,
+ signal_params, dgt,s_vec_list, u_mat_list, ut_x_list,...,
+ gabmul_list,fig_dir);
+
+fprintf("Running time to tune lambda (est): %f \n",t_est);
+
+%% Estimate lambda from true energy
+e_wideband_true_energy = zeros(n_areas,1);
+x_wideband_tf_mat = dgt(gabmul_list{1}(signals.wideband));
+
+for k_area =1:n_areas
+ mask_k = (mask_labeled==k_area);
+ x_wideband_tf_masked = mask_k .* x_wideband_tf_mat;
+
+ e_wideband_true_energy(k_area) =norm(x_wideband_tf_masked, 'fro').^2;
+end
+e_wideband = e_wideband_true_energy;
+
+[lambda_true_energy, t_true_energy] = compute_lambda(x_mix, mask_labeled, dgt_params,...,
+ signal_params, dgt, s_vec_list, u_mat_list, ut_x_list,...,
+ gabmul_list, fig_dir,e_wideband);
+
+fprintf("Running time to tune lambda (True): %f \n",t_true_energy);
+
+
+%% Results
+
+x_wideband = signals.wideband;
+sdr_wideband = @(lambda_coef)sdr(x_wideband, x_rec(lambda_coef));
+
+sdr_wideband_1area = @(lambda_coef)sdr_engine_1area(lambda_coef, signals, k_area,...,
+ n_areas,s_vec_list, u_mat_list, ut_x_list);
+
+is_wideband = @(lambda_coef) itakura_saito_dist_spectrum(x_wideband, x_rec(lambda_coef));
+
+
+
+%%
+
+l_range = 10.^linspace(-10,10,100);
+sdr_wideband_l = zeros(length(l_range),1);
+sdr_engine1area_l = zeros(length(l_range),1);
+
+
+if tol_subregions==0
+ for k =1:length(l_range)
+ sdr_wideband_l(k) = sdr_wideband(l_range(k));
+ end
+ figure;
+ plot(l_range,sdr_wideband_l, '-','LineWidth',3);
+ hold on;
+ plot(lambda_oracle,sdr_wideband(lambda_oracle),'gs','MarkerSize',12);
+ plot(lambda_est,sdr_wideband(lambda_est),'o','MarkerSize',12)
+ plot(lambda_true_energy,sdr_wideband(lambda_true_energy),'*','MarkerSize',12)
+ plot(1,sdr_wideband(1),'o','MarkerSize',12)
+
+
+
+else
+
+
+ figure;
+ for k_area =1: n_areas
+ for k=1:length(l_range)
+ sdr_engine1area_l(k) = sdr_engine_1area(k, k_area);
+ end
+ txt = ['SDR sub-reg =' num2str(k)];
+ end
+
+ plot(l_range, sdr_engine1area_l,'_','LineWidth',3,'DisplayName',txt)
+ for k_area =1:n_areas
+ txt1 = ['TFF-O ',num2str(k_area)];
+ plot(lambda_oracle(k_area), sdr_engine_1area(lambda_oracle(k_area), k_area),...,
+ '*','LineWidth',3,'DisplayName',txt1);
+ txt2 = ['TFF-P',num2str(k_area)];
+ plot(lambda_est(k_area),sdr_engine_1area(lambda_est(k_area), k_area),...,
+ 'o','LineWidth',3,'DisplayName',txt2);
+ txt3 = ['TFF-E',num2str(k_area)];
+ plot(lambda_true_energy(k_area),sdr_engine_1area(lambda_true_energy(k_area), k_area),...,
+ 'o','LineWidth',3,'DisplayName',txt3);
+ txt4 = ['Zero fill',num2str(k_area)];
+ plot(1, sdr_engine_1area(1, k_area), 'o','LineWidth',3,'DisplayName',txt4);
+
+ end
+end
+xlabel('$\lambda$','Interpreter','latex')
+ylabel('SDR(dB)')
+set(gca,'XScale','log');
+grid on;
+set(gca, 'FontSize', 20, 'fontName','Times');
+legend('SDR', 'TFF-O','TFF-1', 'TFF-E','Zero fill')
+saveas(gcf,fullfile(fig_dir, 'tuning_lambda.pdf'));
+
+
+%%
+is_wideband_l = zeros(length(l_range),1);
+if tol_subregions ==0
+ figure;
+ for l =1: length(l_range)
+ is_wideband_l(l) = is_wideband(l_range(l));
+ end
+ plot(l_range, is_wideband_l,'-','LineWidth',3)
+ plot(lambda_oracle, is_wideband(lambda_oracle), 'o','LineWidth',3)
+ plot(lambda_est, is_wideband(lambda_est), 'o')
+ plot(lambda_true_energy, is_wideband(lambda_true_energy),'o','LineWidth',3)
+ plot(1, is_wideband(1), 'o','LineWidth',3)
+
+ xlabel('$\lambda$','Interpreter','latex')
+ ylabel('IS (dB)')
+ set(gca,'XScale','log');
+ grid()
+ legend('SDR','TFF-O','TFF-1','TFF-E','Zero fill')
+ axis tight;
+ saveas(gcf,fullfile(fig_dir, 'tuning_lambda_IS.pdf'));
+
+ %%
+ figure;
+ yyaxis left;
+ plot(l_range, sdr_wideband_l, '-','LineWidth',3); hold on;
+ plot(lambda_est, sdr_wideband(lambda_est), 'o','MarkerSize',3,'LineWidth',3)
+ plot(lambda_true_energy, sdr_wideband(lambda_true_energy), 'bo','LineWidth',3)
+ plot(lambda_oracle, sdr_wideband(lambda_oracle), 'go','LineWidth',3)
+ plot(1, sdr_wideband(1), 'mo','LineWidth',3);
+ grid on;
+ xlabel('$\lambda$','Interpreter','latex')
+ ylabel('SDR (dB)')
+ set(gca,'XScale','log');
+
+
+
+ yyaxis right;
+
+ plot(l_range,is_wideband_l,'-','LineWidth',3); hold on;
+ plot(lambda_est, is_wideband(lambda_est), 'o','MarkerSize',3,'LineWidth',3)
+ plot(lambda_true_energy, is_wideband(lambda_true_energy),'bo','LineWidth',3)
+ plot(lambda_oracle, is_wideband(lambda_oracle), 'go','LineWidth',3)
+ plot(1, is_wideband(1), 'mo','LineWidth',3)
+
+
+
+ axis tight;
+ legend('SDR','TFF-1','TFF-E','TFF-O','Zero fill','Location','northwest');
+ xlabel('$\lambda$','Interpreter','latex')
+ ylabel('IS divergence')
+ set(gca, 'FontSize', 20, 'fontName','Times');
+
+%
+% saveas(gcf,fullfile(fig_dir, 'tuning_lambda_SDR_IS.pdf'));
+%
+end
+
+%% Reconstructec signals
+tf_mat_mix = compute_dgt(signals.mix, dgt );
+
+x_oracle = x_rec(lambda_oracle);
+wav_write('x_oracle.wav', x_oracle, signal_params.fs);
+
+x_est = x_rec(lambda_est);
+wav_write('x_est.wav', x_est, signal_params.fs);
+
+x_true_energy = x_rec(lambda_true_energy);
+wav_write('x_true_energy.wav', x_true_energy, signal_params.fs);
+
+
+x_zero = solver_tfgm_zero(tf_mat_mix, mask, idgt);
+wav_write('x_zero_fill.wav', x_zero, signal_params.fs);
+
+x_interp= solver_tfgm_interp(tf_mat_mix, mask, idgt);
+wav_write('x_interp.wav', x_zero, signal_params.fs);
+
+
+%% Sdr
+
+
+sdr_oracle = sdr(x_wideband, x_oracle);
+sdr_est = sdr(x_wideband, x_est);
+sdr_true_energy = sdr(x_wideband, x_true_energy);
+sdr_zero = sdr(x_wideband, x_zero);
+sdr_interp = sdr(x_wideband, x_interp);
+sdr_mix = sdr(x_wideband, x_mix);
+
+
+%% Itakura saito
+is_oracle = itakura_saito_dist_spectrum(x_wideband,x_oracle);
+is_est = itakura_saito_dist_spectrum(x_wideband,x_est);
+is_true_energy = itakura_saito_dist_spectrum(x_wideband,x_true_energy);
+is_zero = itakura_saito_dist_spectrum(x_wideband,x_zero) ;
+is_mix= itakura_saito_dist_spectrum(x_wideband,x_mix) ;
+is_interp= itakura_saito_dist_spectrum(x_wideband,x_interp);
+
+%%
+
+
+
+fprintf('Oracle lambda: %f\n', lambda_oracle);
+fprintf('SDR for oracle lambda: %f dB\n',sdr_oracle);
+
+
+fprintf('Estimated lambda: %f \n', lambda_est);
+fprintf('SDR for estimated lambda: %f dB\n', sdr_est);
+
+
+fprintf('True-energy lambda: %f \n', lambda_true_energy);
+fprintf('SDR for true-energy lambda: %f dB\n', sdr_true_energy);
+
+fprintf('Zero filling SDR: %f dB\n', sdr_zero);
+fprintf('Mix SDR: %f dB \n',sdr_mix);
+fprintf('Interp + random phases filling SDR: %e dB\n',sdr_interp);
+
+%%
+
+figure;
+plot_spectrogram(x_mix, dgt_params, signal_params, dgt);
+title(['Mix SDR=' , num2str(sdr_mix,4),'dB ','IS= ',num2str(is_mix)]);
+set(gca, 'FontSize', 20, 'fontName','Times');
+axis tight;
+saveas(gcf,fullfile(fig_dir, 'mix.pdf'));
+
+figure;
+plot_spectrogram(signals.wideband, dgt_params, signal_params, dgt);
+title(['True source -', wideband_src])
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(fig_dir, 'spectrogram_true_wb_source.pdf'));
+
+
+figure;
+plot_spectrogram(x_zero, dgt_params, signal_params, dgt)
+title(['Zero fill SDR= ', num2str(sdr_zero,4),'dB ', 'IS=', num2str(is_zero)])
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(fig_dir, 'spectrogram_zero_fill.pdf'));
+
+
+
+
+figure;
+plot_spectrogram(x_oracle, dgt_params, signal_params, dgt)
+title(['TFF-O SDR= ', num2str(sdr_oracle,4), 'dB ','IS=', num2str(is_oracle)])
+set(gca, 'FontSize', 20, 'fontName','Times');
+axis tight;
+saveas(gcf,fullfile(fig_dir,'spectrogram_TFF-O.pdf'));
+
+
+
+
+
+figure;
+plot_spectrogram(x_est, dgt_params, signal_params, dgt)
+
+if tol_subregions==0
+ title(['TFF-1 - SDR= ',num2str(sdr_est,4),'dB ','IS=',num2str(is_est)])
+ set(gca, 'FontSize', 20, 'fontName','Times');
+ axis tight;
+ saveas(gcf,fullfile(fig_dir, 'spectrogram_TFF-1.pdf'));
+else
+ title(['TFF-P - SDR= ',num2str(sdr_est,4),'dB ','IS=',num2str(is_est)])
+ set(gca, 'FontSize', 20, 'fontName','Times');
+ axis tight;
+ saveas(gcf,fullfile(fig_dir, 'spectrogram_TFF-P.pdf'));
+end
+
+
+figure;
+plot_spectrogram(x_true_energy, dgt_params, signal_params,dgt)
+title(['TFF-E SDR= ', num2str(sdr_true_energy,4),'dB ','IS=',num2str(is_true_energy) ])
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(fig_dir, 'spectrogram_TFF-E.pdf'));
+%%
+
+
+figure;
+plot_spectrogram(x_interp, dgt_params, signal_params,dgt)
+title(['Interp SDR= ', num2str(sdr_interp,4),'dB ','IS=',num2str(is_interp)])
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(fig_dir,'spectrogram_interp.pdf'));
+%%
diff --git a/matlab/tfgm/subregions/create_subregions.m b/matlab/tfgm/subregions/create_subregions.m
new file mode 100644
index 0000000000000000000000000000000000000000..32a31aab0b7e0843549f8a4b11f4275d14c6ea8b
--- /dev/null
+++ b/matlab/tfgm/subregions/create_subregions.m
@@ -0,0 +1,118 @@
+function [mask_labeled, varargout] = create_subregions(mask, dgt, idgt, ...,
+ dgt_params, signal_params, tol, fig_dir)
+
+%% [mask_labeled, varargout] = create_subregions(mask, dgt, idgt, dgt_params, signal_params, tol, fig_dir)
+% This function splits the whole region $\Omega$ in such sub-regions.[1]
+%
+% Inputs:
+% - mask: original mask
+% - dgt, idgt : Gabor transform and its inverse operator
+% - dgt_params : Discrete Gabor Transform parameters(hop, nbins,win, ect..)
+% -signal_params: Signals parameters(sig_len, fs)
+% - tol: tolerance .see [1]
+% - fig_dir : Figures directory
+%
+% Outputs:
+% - mask_labeled: mask with P regions
+% -pq_norms_val: norms between two Gabor multipliers
+%
+%
+% Reference:
+% [1]Time-frequency fading algorithms based on Gabor multipliers,2020.
+%
+%
+% Author: Marina KREME
+%%
+mask = boolean(mask);
+[mask_labeled, n_labels] = bwlabel(mask);
+sig_len = signal_params.sig_len;
+pq_norms_val = get_pq_norms(sig_len,dgt,idgt,mask_labeled);
+
+%%
+figure;
+plot_mask(mask_labeled, dgt_params.hop, dgt_params.nbins, signal_params.fs)
+title('Initial subregions')
+saveas(gcf,fullfile(fig_dir, 'initial_subregions.pdf'));
+
+figure;
+imagesc(real(log10(pq_norms_val+pq_norms_val')))
+ylabel('p')
+xlabel('q')
+colorbar()
+title('Initial norms of Gabor multiplier composition')
+saveas(gcf,fullfile(fig_dir, 'initial_norms.pdf'));
+
+n_labels_max = n_labels;
+
+%%
+
+while max(pq_norms_val(:))>tol
+ %Merge each pair (p, q), q < p, such that pq_norms[p, q] > tol
+ to_be_updated = boolean(zeros(n_labels,1));
+
+ while max(pq_norms_val(:))>tol
+ [i_p, i_q] = find(pq_norms_val == max(pq_norms_val(:)));
+
+
+ mask = mask_labeled;
+ [mask_labeled, pq_norms_val] = merge_subregions(mask, pq_norms_val, i_p, i_q);
+
+ to_be_updated(i_q)= true;
+ to_be_updated(i_p) = to_be_updated(end);
+ to_be_updated = to_be_updated(1:end-1);
+ n_labels =n_labels- 1;
+ end
+
+ for i_p =1:n_labels
+ if to_be_updated(i_p)==true
+ pq_norms_val = update_pq_norms(mask_labeled, pq_norms_val, i_p, signal_params, dgt, idgt);
+ end
+ end
+
+
+
+
+
+ figure;
+ plot_mask(mask_labeled, dgt_params.hop, dgt_params.nbins, signal_params.fs)
+ title('subregions ')
+ saveas(gcf,fullfile(fig_dir, ['subregions_i_', num2str(n_labels_max-n_labels),'.pdf']));
+
+
+ figure;
+ imagesc(real(log10(pq_norms_val+pq_norms_val')))
+ ylabel('p-1')
+ xlabel('q-1')
+ colorbar()
+ title('norms of Gabor multiplier composition')
+ saveas(gcf,fullfile(fig_dir, ['norms_i', num2str(n_labels_max-n_labels),'.pdf']));
+
+
+end
+
+
+%%
+
+
+
+figure;
+plot_mask(mask_labeled, dgt_params.hop, dgt_params.nbins, signal_params.fs)
+title('Final subregions')
+saveas(gcf,fullfile(fig_dir,'final_subregions.pdf'));
+
+
+figure;
+imagesc(real(log10(pq_norms_val+pq_norms_val')))
+ylabel('p-1')
+xlabel('q-1')
+colorbar()
+title('Final norms of Gabor multiplier composition')
+saveas(gcf,fullfile(fig_dir, 'final_norms.pdf'));
+
+varargout{1} = pq_norms_val;
+
+end
+
+
+
+
diff --git a/matlab/tfgm/subregions/get_pq_norms.m b/matlab/tfgm/subregions/get_pq_norms.m
new file mode 100644
index 0000000000000000000000000000000000000000..cd69f5f4c10240c98d0a26e7a0b6f2a726f0d170
--- /dev/null
+++ b/matlab/tfgm/subregions/get_pq_norms.m
@@ -0,0 +1,37 @@
+function pq_norms_val = get_pq_norms(sig_len, dgt, idgt, mask_labeled)
+
+%% pq_norms_val = get_pq_norms(sig_len, dgt, idgt, mask_labeled)
+% This function compute norms between two Gabor multiplier
+%
+% Inputs:
+% - sig_len : signal length
+% - dgt, idgt: Discrete Gabor Transform parameters(hop, nbins,win, ect..)
+% - mask_labeled: mask with P regions
+% Output:
+% - pq_norms_val : array with all norms between all p and q regions
+%
+% Author: Marina KREME
+%
+%%
+dbstack;
+n_labels = length(unique(mask_labeled))-1;
+
+pq_norms_val = zeros(n_labels);
+
+for p =1: n_labels
+ fprintf('p %f\n',p)
+ for q = 1:p
+ fprintf('q %f\n',q)
+
+ mask_p = (mask_labeled==p);
+ mask_q = (mask_labeled==q);
+ mul_pq = @(x)idgt(mask_p.*dgt(idgt(mask_q.*dgt(x))));
+ pq_norms_val(p,q) = real(eigs(mul_pq, sig_len,1));
+
+
+ end
+end
+end
+
+
+
diff --git a/matlab/tfgm/subregions/make_subregions.m b/matlab/tfgm/subregions/make_subregions.m
new file mode 100644
index 0000000000000000000000000000000000000000..7aae2137361bc3a3216da96cc3a60c62131ec11a
--- /dev/null
+++ b/matlab/tfgm/subregions/make_subregions.m
@@ -0,0 +1,53 @@
+function [mask_list, mask_labeled, mask_area_list] = make_subregions(mask, dgt_params, signal_params)
+
+%%[mask_list, mask_labeled, mask_area_list] = make_subregions(mask, dgt_params, signal_params)
+% This function split the whole regions into P regions
+% Inputs:
+% - mask: original mask
+% - dgt_params : Discrete Gabor Transform parameters(hop, nbins,win, ect..)
+% -signal_params: Signals parameters(sig_len, fs)
+% Outputs:
+% - mask_list(struct):list contains P masks
+% - mask_labeled: mask labeled
+% - mask_area_list: mask area for each P region
+%
+% Author: Marina KREME
+
+%%
+
+
+
+[~,n_labels] = bwlabel(mask);
+
+mask_area_list = zeros(n_labels,1);
+mask_list = cell(n_labels,1);
+
+
+for k =1:n_labels
+ %%
+
+ [mask_labeled,~] = bwlabel(mask);
+
+ % on construit chaque mask
+ mask_labeled(mask_labeled~=k)= false;
+ mask_labeled(mask_labeled==k)=true;
+ mask_k =mask_labeled;
+ mask_list{k} = mask_k;
+ figure(k); plotdgtreal(mask_k, dgt_params.hop, dgt_params.nbins, signal_params.fs);
+ title(['k=', num2str(k)])
+
+ [mask_area, mask_area_ratio] = get_mask_area(mask_k);
+ mask_area_list(k) = mask_area;
+ fprintf('mask area = %.f, mask area ratio = %f\n',mask_area, mask_area_ratio);
+
+
+end
+
+[mask_labeled,~] = bwlabel(mask);
+end
+
+
+
+
+
+
diff --git a/matlab/tfgm/subregions/merge_subregions.m b/matlab/tfgm/subregions/merge_subregions.m
new file mode 100644
index 0000000000000000000000000000000000000000..0b7ea9c393f5e07329df6196462b5023032984e6
--- /dev/null
+++ b/matlab/tfgm/subregions/merge_subregions.m
@@ -0,0 +1,33 @@
+function[mask, pq_norms_val] = merge_subregions(mask, pq_norms_val, i_p, i_q)
+
+%% [mask, pq_norms_val] = merge_subregions(mask, pq_norms_val, i_p, i_q)
+% This function merge two regions. See [1]
+%
+% Inputs:
+% -mask: mask with P regions (mask labeled)
+% -pq_norms_val: array with all norms between all p and q regions
+% - i_p, i_q: ineteger
+% Outputs:
+% -mask:final mask
+% - pq_norms_val: array with all norms between all p and q regions
+
+% Reference:
+% [1]Time-frequency fading algorithms based on Gabor multipliers,2020.
+%
+% Author: Marina KREME
+%%
+p = i_p + 1;
+q = i_q + 1;
+
+n_labels = size(pq_norms_val,1);
+mask(mask == p)= q;
+mask(mask == n_labels) = p;
+pq_norms_val(i_p, 1:i_p - 1)= pq_norms_val(end, 1:i_p - 1);
+pq_norms_val(i_p:end, i_p) = pq_norms_val(end, i_p:end);
+pq_norms_val = pq_norms_val(1:end-1, 1:end-1);
+
+end
+
+
+
+
diff --git a/matlab/tfgm/subregions/pq_norms.m b/matlab/tfgm/subregions/pq_norms.m
new file mode 100644
index 0000000000000000000000000000000000000000..753e198f6bb777343e354aaab3202ffe90ba4db0
--- /dev/null
+++ b/matlab/tfgm/subregions/pq_norms.m
@@ -0,0 +1,38 @@
+function pq_norms = pq_norms(sig_len, dgt, idgt, mask_list)
+
+%% pq_norms = pq_norms(sig_len, dgt, idgt, mask_list)
+% This function compute norm between each p and q regio $p\neq q$ from list
+% of mask
+%
+% Inputs:
+% -sig_len: signal length
+% -dgt, idgt: Discrete Gabor Transform parameters(hop, nbins,win, ect..)
+% -mask_list(struct):list contains P masks
+% Outputs:
+% - pq_norms: array with all norms between all p and q regions
+%
+% Author: Marina KREME
+
+%%
+
+n_labels = length(mask_list);
+pq_norms = zeros(n_labels);
+
+
+%%
+
+for p =1: n_labels-1
+
+ mask_p = mask_list{p};
+ for q = p+1:n_labels
+
+ mask_q = mask_list{q};
+
+ mul_pq = @(x)idgt(mask_p.*dgt(idgt(mask_q.*dgt(x))));
+ pq_norms(p,q) = real(eigs(mul_pq, sig_len,1));
+
+
+ end
+end
+
+end
\ No newline at end of file
diff --git a/matlab/tfgm/subregions/run_create_subregions.m b/matlab/tfgm/subregions/run_create_subregions.m
new file mode 100644
index 0000000000000000000000000000000000000000..8159fcc8e2fd2948c035f6a54520a6138ffbc0ff
--- /dev/null
+++ b/matlab/tfgm/subregions/run_create_subregions.m
@@ -0,0 +1,42 @@
+clc; clear; close all;
+%%
+
+pwd;
+fig_dir ='create_subregions_cuicui';
+if ~exist('create_subregions_cuicui','dir')
+ mkdir('create_subregions_cuicui');
+end
+addpath('create_subregions_cuicui')
+
+%%
+
+loc_source='bird';
+wideband_src='car';
+gamma=0.7;
+win_type ='gauss';
+
+[alpha, thres, radius] = set_smooth_mask_params(wideband_src, loc_source, win_type);
+
+
+win_dur =256/8000;
+hop_ratio=1/4;
+nbins_ratio=4;
+
+
+[signals, dgt_params, signal_params, mask, mask_area, dgt,...,
+ idgt] = get_mix(loc_source, wideband_src, gamma, win_dur, hop_ratio,...,
+ nbins_ratio, win_type, alpha, thres, radius, fig_dir);
+
+
+
+%%
+tol = 1e-5;
+mask_bool = mask;
+
+
+[mask_labeled, n_areas,t_subregions] = get_nareas(mask_bool, dgt, idgt, dgt_params,...,
+ signal_params, fig_dir, tol);
+
+
+
+%%
diff --git a/matlab/tfgm/subregions/update_pq_norms.m b/matlab/tfgm/subregions/update_pq_norms.m
new file mode 100644
index 0000000000000000000000000000000000000000..40347c68544025b67a178e4c3e6e833a4699faba
--- /dev/null
+++ b/matlab/tfgm/subregions/update_pq_norms.m
@@ -0,0 +1,47 @@
+function pq_norms_val = update_pq_norms(mask_labeled, pq_norms_val, i_p, signal_params, dgt, idgt)
+
+
+%% pq_norms_val = update_pq_norms(mask_labeled, pq_norms_val, i_p, signal_params, dgt, idgt)
+%
+% This function compute bit faster norms between two Gabor multiplier.
+% This is an improvement of the function get_pq_norms.m
+%
+% Inputs:
+% - mask_labeled: mask labeled-mask with P regions
+% -pq_norms_val: array with all norms between all p and q regions
+% -i_p: ineteger
+% -signal_params: Signals parameters(sig_len, fs)
+% - dgt, idgt: Discrete Gabor Transform parameters(hop, nbins,win, ect..)
+% Output:
+% - pq_norms_val : array with all norms between all p and q regions
+%
+% Author: Marina KREME
+
+%%
+
+
+sig_len = signal_params.sig_len;
+n_labels = size(pq_norms_val,1);
+
+mask_p = (mask_labeled==i_p);
+gabmul_p = gen_gabmul_operator(dgt, idgt, mask_p);
+
+for i_q =1:n_labels
+ if i_p == i_q
+ continue
+ end
+ mask_q = (mask_labeled==i_q);
+ gabmul_q = gen_gabmul_operator(dgt, idgt, mask_q);
+
+ gabmul_pq =@(x)gabmul_p(gabmul_q(x));
+ gabmul_pq_norm = real(eigs(gabmul_pq, sig_len,1));
+end
+if i_q < i_p
+ pq_norms_val(i_p, i_q) = gabmul_pq_norm;
+else
+ pq_norms_val(i_q, i_p) = gabmul_pq_norm;
+end
+
+
+end
+
diff --git a/matlab/tfgm/tf_filtering/U_transpose_observation.m b/matlab/tfgm/tf_filtering/U_transpose_observation.m
new file mode 100644
index 0000000000000000000000000000000000000000..513f51d291a556aacae6e9dd658939e3bc6298cf
--- /dev/null
+++ b/matlab/tfgm/tf_filtering/U_transpose_observation.m
@@ -0,0 +1,18 @@
+function ut_x = U_transpose_observation(x_mix, u_mat)
+
+%% ut_x = U_transpose_observation(x_mix, u_mat)
+% Function that calculates u_mat'*x_mix
+%
+% Inputs:
+% -x_mix :mixtures of signals with wideband and localized spectrograms
+% -u_mat:eignevectors matrix
+% Outputs:
+% - ut_x: result of calculation
+%
+% Author: Marina KREME
+%
+%%
+ut_x = u_mat'*x_mix;
+
+end
+
diff --git a/matlab/tfgm/tf_filtering/compute_decomposition.m b/matlab/tfgm/tf_filtering/compute_decomposition.m
new file mode 100644
index 0000000000000000000000000000000000000000..b769ed9cf7d7538a78ffc31662dca0b1257d9453
--- /dev/null
+++ b/matlab/tfgm/tf_filtering/compute_decomposition.m
@@ -0,0 +1,91 @@
+function [t_arrf,t_evdn, t_ut_x, rank_q, s_vec_list, u_mat_list,...,
+ ut_x_list,r] = compute_decomposition(x_mix, mask_list, gabmul_list,...,
+ tolerance_arrf, proba_arrf)
+
+%% [t_arrf,t_evdn,t_ut_x, rank_q, s_vec_list, u_mat_list, ut_x_list,r] = compute_decomposition(x_mix, mask_list, gabmul_list,tolerance_arrf, proba_arrf)
+
+% This fucntion computes the eigenvalues decomposition (EVD) using
+% random projection algorithms. see[1]
+%
+% Inputs:
+% - x_mix: mixtures of signals with wideband and localized spectrograms
+% -mask_list: list of mask
+% -gabmul_list: list of Gabor multiplier associated to each mask
+% - tolerance_arrf: tolearance. see [1]
+% - proba_arrf: probability of success. see[1]
+% Outputs:
+% -t_arrf: time for adaptativerandomized range finder(arrf)
+% -t_evdn: time for eigenvalue decomposition via Nystr�m (evdn)
+% -t_ut_x: time for U^{T}*x_mix
+% -rank_q: array contains list of rank estimated by arrf
+% -s_vec_list: list of nonnegative and diagonal matrix obtained by evdn
+% - u_mat_list list of orthononmal matrix obtained by evdn
+% - r: parameter for arrf.
+%
+%
+% Reference:
+%
+% [1] Nathan Halko, Per-Gunnar Martinsson, Joel A. Tropp, "Finding structure
+% with randomness: Probabilistic algorithms for constructing approximate
+% matrix decompositions", 2011.
+%
+% Author: Marina KREME
+%%
+
+sig_len = length(x_mix);
+
+
+n_areas = length(mask_list);
+r = compute_r(sig_len, sig_len, proba_arrf);
+
+
+%%
+
+t_arrf = zeros(n_areas,1);
+t_evdn = zeros(n_areas,1);
+t_ut_x = zeros(n_areas,1);
+rank_q = zeros(n_areas,1);
+
+s_vec_list = cell(n_areas,1);
+u_mat_list = cell(n_areas,1);
+ut_x_list = cell(n_areas,1);
+
+%%
+
+
+for k =1: n_areas
+ %%
+
+ mask_p = mask_list{k};
+ fprintf('Random EVD of Gabor multiplier number %.f\n',k);
+
+ [mask_area, mask_area_ratio] = get_mask_area(mask_p);
+ fprintf('#coefs in mask: %f \n',mask_area);
+ fprintf('#ratio of coefs in mask: %f %%\n',mask_area_ratio);
+
+
+ tic;
+ q_mat = adaptative_randomized_range_finder(gabmul_list{k}, sig_len, tolerance_arrf, r);
+ t_arrf(k) = toc;
+ rank_q(k) = size(q_mat,2);
+ fprintf('Q size: %.f %.f\n', size(q_mat,1),size(q_mat,2));
+
+ tic;
+ evdn = EVD_nystrom(gabmul_list{k}, q_mat);
+ t_evdn(k) = toc;
+
+ s_vec_list{k} = sort(diag(evdn.D),'descend');
+ u_mat_list{k} = evdn.U;
+
+
+ fprintf('Running times:\n')
+ fprintf('- adaptive_randomized_range_finder: %f s\n',t_arrf(k));
+ fprintf('- evd_nystrom: %f s \n\n', t_evdn(k));
+
+
+ tic;
+ ut_x_list{k} = u_mat_list{k}'* x_mix;
+ t_ut_x(k) = toc;
+
+end
+end
\ No newline at end of file
diff --git a/matlab/tfgm/tf_filtering/compute_decomposition_fixed_rank.m b/matlab/tfgm/tf_filtering/compute_decomposition_fixed_rank.m
new file mode 100644
index 0000000000000000000000000000000000000000..5bc3b49d8f5813dfefe45b1ece6407ff7bec4318
--- /dev/null
+++ b/matlab/tfgm/tf_filtering/compute_decomposition_fixed_rank.m
@@ -0,0 +1,85 @@
+function [t_rrf,t_evdn, t_ut_x, s_vec_list, u_mat_list,...,
+ ut_x_list]=compute_decomposition_fixed_rank(x_mix, mask_list, gabmul_list, rank)
+
+%% [t_rrf,t_evdn, t_ut_x, s_vec_list, u_mat_list,ut_x_list]=compute_decomposition_fixed_rank(x_mix, mask_list, gabmul_list, rank)
+
+% This fucntion computes the eigenvalues decomposition fixed rank with (EVD) using
+% random projection algorithms. see[1]
+%
+% Inputs:
+% - x_mix: mixtures of signals with wideband and localized spectrograms
+% -mask_list: list of mask
+% -gabmul_list: list of Gabor multiplier associated to each mask
+% - rank : matrix rank see [1]
+% Outputs:
+% -t_rrf: time for randomized range finder(rrf)
+% -t_evdn: time for eigenvalue decomposition via Nystr�m (evdn)
+% -t_ut_x: time for U^{T}*x_mix
+% -rank_q: array contains list of rank estimated by arrf
+% -s_vec_list: list of nonnegative and diagonal matrix obtained by evdn
+% - u_mat_list list of orthononmal matrix obtained by evdn
+% - ut_x_list: list of U^{T}*x_mix
+%
+%
+% Reference:
+%
+% [1] Nathan Halko, Per-Gunnar Martinsson, Joel A. Tropp, "Finding structure
+% with randomness: Probabilistic algorithms for constructing approximate
+% matrix decompositions", 2011.
+%
+% Author: Marina KREME
+%%
+
+
+%%
+n_areas = length(mask_list);
+
+sig_len = length(x_mix);
+%%
+
+t_rrf = zeros(n_areas,1);
+t_evdn = zeros(n_areas,1);
+t_ut_x = zeros(n_areas,1);
+
+
+s_vec_list = cell(n_areas,1);
+u_mat_list = cell(n_areas,1);
+ut_x_list = cell(n_areas,1);
+
+%%
+
+
+for k =1: n_areas
+ mask_p = mask_list{k};
+ fprintf('Random EVD of Gabor multiplier nummber %.f\n',k);
+
+ [mask_area, mask_area_ratio] = get_mask_area(mask_p);
+ fprintf('#coefs in mask: %f \n',mask_area);
+ fprintf('#ratio of coefs in mask: %f %%\n',mask_area_ratio);
+
+
+ tic;
+ q_mat = randomized_range_finder(gabmul_list{k}, sig_len, rank);
+ t_rrf(k) = toc;
+
+ fprintf('Q size: %.f %.f\n', size(q_mat,1),size(q_mat,2));
+
+ tic;
+ evdn = EVD_nystrom(gabmul_list{k}, q_mat);
+ t_evdn(k) = toc;
+
+ s_vec_list{k} = diag(evdn.D);
+ u_mat_list{k} = evdn.U;
+
+
+ fprintf('Running times:\n')
+ fprintf('- randomized_range_finder: %f s\n',t_rrf(k));
+ fprintf('- evd_nystrom: %f s \n\n', t_evdn(k));
+
+
+ tic;
+ ut_x_list{k} = u_mat_list{k}'* x_mix;
+ t_ut_x(k) = toc;
+
+end
+
diff --git a/matlab/tfgm/tf_filtering/compute_estimate.m b/matlab/tfgm/tf_filtering/compute_estimate.m
new file mode 100644
index 0000000000000000000000000000000000000000..89b35466aab126a25167d411b1975d58b4f6c014
--- /dev/null
+++ b/matlab/tfgm/tf_filtering/compute_estimate.m
@@ -0,0 +1,45 @@
+function x=compute_estimate(lambda_coef, x_mix, s_vec_list, u_mat_list, ut_x_list)
+
+%% x=compute_estimate(lambda_coef, x_mix, s_vec_list, u_mat_list, ut_x_list)
+% This function computes the signal estimated by the algorithms proposed in [1]
+%
+% Inputs:
+% - lambda_coef: hyperparameters
+% - x_mix: mixtures of signals with wideband and localized spectrograms
+% - s_vec_list:list of nonnegative and diagonal matrix
+% - u_mat_list: list of orthononmal matrix
+% - ut_x_list: list of u_mat^{T}*x_mix
+%
+% Output:
+% x : estimated signal
+%
+% Reference:
+%
+% [1]Time-frequency fading algorithms based on Gabor multipliers,2020.
+%
+%
+% Author: Marina KREME
+
+
+%%
+
+
+n_areas = length(s_vec_list);
+
+n = length(lambda_coef);
+if n>1
+ assert(n==n_areas);
+else
+ lambda_coef = lambda_coef*ones(n_areas,1);
+end
+
+x = x_mix;
+for k= 1:n_areas
+ gamma_vec = lambda_coef(k)*s_vec_list{k}./(1-(1-lambda_coef(k))*s_vec_list{k});
+ x =x-u_mat_list{k}*(gamma_vec.*ut_x_list{k});
+end
+
+
+end
+
+
diff --git a/matlab/tfgm/tf_filtering/compute_gamma.m b/matlab/tfgm/tf_filtering/compute_gamma.m
new file mode 100644
index 0000000000000000000000000000000000000000..b5df28f4a34bc2e2983217bc153daa3593f3dd6c
--- /dev/null
+++ b/matlab/tfgm/tf_filtering/compute_gamma.m
@@ -0,0 +1,8 @@
+function gamma_vec = compute_gamma(s_vec)
+% compute gamma
+
+gamma_vec =@(lambda_coef) lambda_coef*s_vec./(lambda_coef*s_vec + 1- s_vec);
+
+end
+
+
diff --git a/matlab/tfgm/tf_filtering/compute_lambda.m b/matlab/tfgm/tf_filtering/compute_lambda.m
new file mode 100644
index 0000000000000000000000000000000000000000..b9cbfebe19aabde37e38e6f1d79c44f9cec20829
--- /dev/null
+++ b/matlab/tfgm/tf_filtering/compute_lambda.m
@@ -0,0 +1,60 @@
+function [lambda_est, t_est] = compute_lambda(x_mix, mask, dgt_params,...,
+ signal_params, dgt, s_vec_list, u_mat_list, ut_x_list,...,
+ gabmul_list, fig_dir, e_target)
+
+%% [lambda_est, t_est] = compute_lambda(x_mix, mask, dgt_params, signal_params, dgt, s_vec_list, u_mat_list, ut_x_list,gabmul_list, fig_dir, e_target)
+
+% This function calculates lambda in algorithmes proposed in [1]
+%
+% Inputs:
+% -x_mix:mixtures of signals with wideband and localized spectrograms
+% -mask: labeled mask
+% -dgt_params : Discrete Gabor Transform parameters(hop, nbins,win, ect..)
+% -signal_params:Signals parameters(sig_len, fs)
+% -dgt: Gabor transform operator
+% -s_vec_list:list of nonnegative and diagonal matrix
+% - u_mat_list: list of orthononmal matrix
+% - ut_x_list: list of u_mat^{T}*x_mix
+% -gabmul_list: list of Gabor multiplier associated to each mask
+% -fig_dir: figures directory
+% -e_target: estimated energy in another region. see [1]
+% Outputs:
+% - lambda_est: lambda estimated
+% - t_est: time to estimate lambda
+%
+% Reference:
+%
+% [1]Time-frequency fading algorithms based on Gabor multipliers,2020.
+%
+% Author: Marina KREME
+%%
+
+%%
+if nargin<=10
+ e_target = estimate_energy_in_mask(x_mix, mask, dgt_params, ...,
+ signal_params, dgt,fig_dir);
+
+end
+%%
+n_areas = length(u_mat_list);
+t_est = zeros(n_areas,1);
+lambda_est = zeros(n_areas,1);
+
+for k_area = 1:n_areas
+ mask_k = (mask==k_area);
+ gab_mul = gabmul_list{k_area};
+ e_target_k = e_target(k_area);
+
+
+ obj_fun_est = @(lambda_coef)obj_fun(lambda_coef, x_mix, s_vec_list, ...,
+ u_mat_list, ut_x_list, mask_k, gab_mul, dgt, e_target_k);
+
+ tic;
+ sol_est = fminbnd(obj_fun_est, 0,1);
+ t_est(k_area) = toc;
+ lambda_est(k_area) = sol_est;
+end
+end
+
+
+
diff --git a/matlab/tfgm/tf_filtering/compute_lambda_oracle_sdr.m b/matlab/tfgm/tf_filtering/compute_lambda_oracle_sdr.m
new file mode 100644
index 0000000000000000000000000000000000000000..f85f7832bea23b3e8c8660c765944def45c42fbb
--- /dev/null
+++ b/matlab/tfgm/tf_filtering/compute_lambda_oracle_sdr.m
@@ -0,0 +1,33 @@
+function [lambda_oracle, t_oracle] = compute_lambda_oracle_sdr(n_areas, x_wb, x_rec)
+
+%% [lambda_oracle, t_oracle] = compute_lambda_oracle_sdr(n_areas,x_wb, x_rec)
+% Function that calculates the estimated lambda using the true energy. see[1]
+%
+% Inputs:
+% - n_areas: number of regions in mask
+% - x_wb: signal with wideband spectrogram
+% - x_rec: Estimated signal as a function of hyperpparametre lambda.see[1]
+%
+% Outputs:
+% -lambda_oracle: estimates lambda
+% - t_oracle:time to estimate lambda
+%
+% Reference:
+%
+% [1]Time-frequency fading algorithms based on Gabor multipliers,2020.
+%
+% Author: Marina KREME
+%%
+tic;
+obj_fun_oracle = @(lambda_coef) norm(x_wb - x_rec(lambda_coef));
+
+if n_areas>1
+ lambda_oracle = fmincon(obj_fun_oracle, ones(n_areas,1));
+else
+ lambda_oracle = fminbnd(obj_fun_oracle, 0, 1);
+end
+t_oracle = toc;
+
+end
+
+
diff --git a/matlab/tfgm/tf_filtering/estimate_energy_in_mask.m b/matlab/tfgm/tf_filtering/estimate_energy_in_mask.m
new file mode 100644
index 0000000000000000000000000000000000000000..2232cd04e3fade15f017d2af892e7f1b037d0d68
--- /dev/null
+++ b/matlab/tfgm/tf_filtering/estimate_energy_in_mask.m
@@ -0,0 +1,95 @@
+function estimated_energy = estimate_energy_in_mask(x_mix, mask, dgt_params, signal_params, dgt,fig_dir)
+
+%%estimated_energy = estimate_energy_in_mask(x_mix, mask, dgt_params, signal_params, dgt,fig_dir)
+% Functions that estimates energy in the mask
+%
+% Inputs:
+% - x_mix:mixtures of signals with wideband and localized spectrograms
+% - mask:labeled mask
+% - dgt_params : Discrete Gabor Transform parameters(hop, nbins,win, ect..)
+% - signal_params:Signals parameters(sig_len, fs)
+% - dgt: Gabor transform operator
+% - fig_dir: firgures directory
+% Outputs:
+% -estimated_energy:estimated energy
+%
+%
+% Author: Marina KREME
+%%
+x_tf_mat = dgt(x_mix);
+x_tf_mat(mask>0)= nan;
+e_f_mean = nanmean(abs(x_tf_mat).^2, 2);
+%%
+n_areas = length(unique(mask))-1;
+estimated_energy = zeros(n_areas,1);
+e_mat = e_f_mean*ones(1, size(x_tf_mat,2));
+e_mat(mask==0) = 0;
+
+for k_area = 1:n_areas
+ mask_k = (mask==k_area);
+ estimated_energy(k_area) = sum(e_mat(:).*mask_k(:));
+
+end
+
+%%
+
+
+dynrange = 100;
+c_max = nanmax(db(x_tf_mat(:)));
+clim = [c_max - dynrange, c_max];
+
+
+fs = signal_params.fs;
+figure;
+plot_spectrogram(x_mix, dgt_params, signal_params, dgt, dynrange, clim)
+%plotdgtreal(S_mix, dgt_params.hop, dgt_params.nbins, fs);
+title('Mix');
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(fig_dir, 'mix.pdf'));
+
+
+
+%
+figure;
+plotdgtreal(sqrt(e_mat), dgt_params.hop, dgt_params.nbins, fs, 'clim', clim);
+%title(['Mask filled with average energy (total: ', num2str(estimated_energy,8),')']);
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(fig_dir, 'filled_mask.pdf'));
+
+
+%
+
+x_tf_mat(mask>0) = sqrt(e_mat(mask>0));
+figure;
+plotdgtreal(x_tf_mat, dgt_params.hop, dgt_params.nbins, fs, 'clim', clim);
+%title(['Mix filled with average energy (total: ', num2str(estimated_energy,8),')']);
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(fig_dir, 'filled_mask.pdf'));
+
+
+%
+figure;
+plot(db(e_f_mean) / 2);
+xlabel('Frequency index')
+ylabel('Average energy')
+grid on;
+title('Average energy per frequency bin in mix');
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(fig_dir, 'average_energy.pdf'));
+
+
+%%
+e_f_mean_check = mean(abs(x_tf_mat).^2, 2);
+figure;
+plot(db(e_f_mean) / 2); hold on;
+plot(db(e_f_mean_check) / 2, '--')
+xlabel('Frequency index')
+ylabel('Average energy')
+title('Average energy per frequency bin in mix')
+legend('Before filling', 'After filling')
+grid on;
+set(gca, 'FontSize', 20, 'fontName','Times');
+saveas(gcf,fullfile(fig_dir, 'average_energy_check.pdf'));
+
+
+end
diff --git a/matlab/tfgm/tf_filtering/filtering_out_Pareas.m b/matlab/tfgm/tf_filtering/filtering_out_Pareas.m
new file mode 100644
index 0000000000000000000000000000000000000000..ece8365bf6a0d67fb1d46d61253a1f4c4a065c43
--- /dev/null
+++ b/matlab/tfgm/tf_filtering/filtering_out_Pareas.m
@@ -0,0 +1,82 @@
+function [x_rec, t_arrf, t_evdn, t_ut_x, rank_q, s_vec_list, u_mat_list,...,
+ lambda_vec_opt] = filtering_out_Pareas(x_mix, mask_labels, dgt, idgt, e_target, tolerance_arrf, proba_arrf)
+
+%%
+
+r = compute_r(sig_len, sig_len, proba_arrf);
+
+P = length(mask_labels);
+P= 2;
+t_arrf = zeros(P,1);
+t_evdn = zeros(P,1);
+t_ut_x = zeros(P,1);
+rank_q = zeros(P,1);
+
+s_vec_list =cell(P,1);
+u_mat_list = cell(P,1);
+
+
+
+lambda_vec_opt = zeros(P,1);
+
+%%
+for p = 1:P
+p=2;
+ %%
+ mask_p = mask_labels{p};
+
+ gabmul_p = gen_gabmul_operator(dgt, idgt, mask_p);
+
+ figure; imagesc(mask_p);
+
+ fprintf('Random EVD of Gabor multiplier number %.f\n',p)
+ fprintf('#coefs in mask: %.f environ %f %%\n\n', sum(mask_p(:)),sum(mask_p(:)/(size(mask_p,1)*size(mask_p,2))*100));
+ %%
+
+ tic;
+ q_mat = adaptative_randomized_range_finder(gabmul_p, sig_len, tolerance_arrf, r);
+ t_arrf(p) = toc;
+
+ rank_q(p) = size(q_mat,2);
+ fprintf('Q size: %.f %.f\n', size(q_mat,1),size(q_mat,2));
+ %%
+ tic;
+ evdn = EVD_nystrom(gabmul_p, q_mat);
+ t_evdn(p) = toc;
+
+ u_mat = evdn.U;
+ s_vec = diag(evdn.D);
+ s_vec_list{p} = s_vec;
+ u_mat_list{p} = u_mat;
+
+ %%
+
+ fprintf('Running times:\n')
+ fprintf('- adaptive_randomized_range_finder: %f s\n',t_arrf(p));
+ fprintf('- evd_nystrom: %f s \n\n', t_evdn(p));
+
+
+ %%
+ ut_x = u_mat'*x_mix;
+ gamma_p =@(lambda_coef)(lambda_coef*s_vec)./(1- (1-lambda_coef)*s_vec);
+
+ x_p=@(lambda_coef) x_mix-u_mat*(gamma_p(lambda_coef).*ut_x);
+ figure;
+ plot_spectrogram(x_p(1), dgt_params, signal_params, dgt)
+
+%%
+ obj_fun = @(lambda_coef) abs(e_target(p) - norm(mask_p.*dgt(x_p(lambda_coef))));
+ sol = fminbnd(obj_fun, 0,1);
+ lambda_vec_opt(p) = sol;
+
+end
+%%
+
+
+
+
+%%
+
+
+end
+
diff --git a/matlab/tfgm/tf_filtering/get_P_gabmul.m b/matlab/tfgm/tf_filtering/get_P_gabmul.m
new file mode 100644
index 0000000000000000000000000000000000000000..081629c5a9180cbeadb822c4f84177d15b4439bf
--- /dev/null
+++ b/matlab/tfgm/tf_filtering/get_P_gabmul.m
@@ -0,0 +1,34 @@
+function [gabmul_list, mask_list] = get_P_gabmul(final_mask_labeled, dgt, idgt)
+
+%% [gabmul_list, mask_list] = get_P_gabmul(final_mask_labeled, dgt, idgt)
+%
+% This function create Gabor multiplier associated to eack mask
+% Inputs:
+% - final_mask_labeled: labeling mask with merging of certain regions
+% -dgt, idgt : Gabor tranform and its inverse operator
+% Outputs:
+% - gabmul_list: list of Gabor multipliers
+% - mask_list: list of mask corresponding to each region
+%
+%
+% Author: Marina KREME
+%
+%%
+n_labels = length(unique(final_mask_labeled))-1;
+gabmul_list = cell(n_labels,1);
+mask_list = cell(n_labels,1);
+
+for k=1:n_labels
+ mask_k = (final_mask_labeled==k);
+ gabmul_k = gen_gabmul_operator(dgt, idgt, mask_k);
+
+ gabmul_list{k} = gabmul_k;
+ mask_list{k} = mask_k;
+end
+
+
+end
+
+
+
+
diff --git a/matlab/tfgm/tf_filtering/get_nareas.m b/matlab/tfgm/tf_filtering/get_nareas.m
new file mode 100644
index 0000000000000000000000000000000000000000..f240d4ccd9bf981adb1fd4612c14af3962280602
--- /dev/null
+++ b/matlab/tfgm/tf_filtering/get_nareas.m
@@ -0,0 +1,47 @@
+function [mask_labeled, n_areas,t_subregions] = get_nareas(mask_bool,dgt, idgt, dgt_params,...,
+ signal_params, fig_dir, tol_subregions)
+
+%% [mask_labeled, n_areas,t_subregions] = get_nareas(mask_bool,dgt, idgt, dgt_params, signal_params, fig_dir, tol_subregions)
+%
+% This function creates regions
+%
+% Inputs:
+% - mask_bool:binary mask
+% -dgt, idgt:Gabor transform and its inverse operator
+% -dgt_params:Discrete Gabor Transform parameters(hop, nbins,win, ect..)
+% -signal_params:Signals parameters(sig_len, fs)
+% -fig_dir: figures directory
+% -tol_subregions :tolerance
+%
+% Outputs:
+% - mask_labeled:mask labeled
+% - n_areas: number of sub regions
+% -t_subregions:time to create sub regions
+%
+%
+% Author: Marina KREME
+
+
+%%
+
+switch tol_subregions
+ case 1e-5
+ tic;
+ mask_labeled = create_subregions(mask_bool, dgt, idgt, dgt_params,...,
+ signal_params, tol_subregions,fig_dir);
+ t_subregions = toc;
+ n_areas = length(unique(mask_labeled))-1;
+ case 0
+
+ n_areas =1;
+ mask_labeled = mask_bool>0;
+ t_subregions=0;
+ otherwise
+ fprintf("Incorrect value of tolerance\n");
+
+end
+
+
+end
+
+
diff --git a/matlab/tfgm/tf_filtering/obj_fun.m b/matlab/tfgm/tf_filtering/obj_fun.m
new file mode 100644
index 0000000000000000000000000000000000000000..369be32a77e7d21af1048083e15f6ad023627c3f
--- /dev/null
+++ b/matlab/tfgm/tf_filtering/obj_fun.m
@@ -0,0 +1,35 @@
+function f_lambda = obj_fun(lambda_coef, x_mix, s_vec_list, ...,
+ u_mat_list, ut_x_list, mask, gab_mul, dgt, e_target)
+
+%% f_lambda = obj_fun(lambda_coef, x_mix, s_vec_list,u_mat_list, ut_x_list, mask, gab_mul, dgt, e_target)
+% Objecitve function for finding optimal lambda value in algorithms
+% proppsed in [1]
+%
+% Inputs:
+% -lambda_coef: hyperparameters
+% - x_mix: mixtures of signals with wideband and localized spectrograms
+% - s_vec_list:list of nonnegative and diagonal matrix obtained after diagonalization
+% - u_mat_list: list of orthononmal matrix obtained after diagonalization
+% - ut_x_list: list of each u_mat'*x_mix
+% - mask: mask
+% - gab_mul:Gabor multiplier
+% - dgt: Gabor transform operator
+% - e_target: estimated energy in Omega region
+%
+% Output:
+% - f_lambda: objective function
+%
+%
+%
+% Reference:
+% [1]Time-frequency fading algorithms based on Gabor multipliers,2020.
+%
+%
+% Author: Marina KREME
+%%
+x =compute_estimate(lambda_coef, x_mix, s_vec_list, u_mat_list, ut_x_list);
+x_tf_masked = mask.*dgt(gab_mul(x));
+e_mask = norm(x_tf_masked, 'fro').^2;
+f_lambda = abs(e_target - e_mask);
+
+end
diff --git a/matlab/tfgm/tf_filtering/solver_tfgm.m b/matlab/tfgm/tf_filtering/solver_tfgm.m
new file mode 100644
index 0000000000000000000000000000000000000000..26cd55b9018b369f1feb6bc3eeb58d45a45c9185
--- /dev/null
+++ b/matlab/tfgm/tf_filtering/solver_tfgm.m
@@ -0,0 +1,29 @@
+function x_est= solver_tfgm(x_mix, u_mat, s_vec, ut_x)
+%% x_est= solver_tfgm(x_mix, u_mat, s_vec, ut_x)
+% function that returns the solution of the problem below
+%
+% $x = \argmin ||Vx-Vx0||^{2}_{\bar{\Omega}}$ + \lambda*||V_g x||^{2}_{\Omega}$
+% with M_{Omega} = V_g^{*}1_{Omega}V_g : Gabor multiplier
+%
+% where \Omega is the hole area,V_g is discrete Gabor transform and x0
+% observations
+%
+% Inputs :
+% - x_mix : mixtures of signals with wideband and localized spectrograms.
+% - u_mat : matrix of eigenvectors
+% - s_vec : eigenvalues vec
+% - ut_x : matrix obtained by performing u_mat'*x_mix
+%
+% Output:
+% - x_est: estimated signal
+%
+% Author : A. Marina KREME
+% e-mail : ama-marina.kreme@lis-lab.fr/ama-marina.kreme@univ-amu.fr
+%
+%%
+
+gamma_vec = compute_gamma(s_vec);
+x_est = @(x) x_mix - u_mat* (gamma_vec(x).*ut_x) ;
+
+end
+
diff --git a/matlab/tfgm/tf_filtering/solver_tfgm_interp.m b/matlab/tfgm/tf_filtering/solver_tfgm_interp.m
new file mode 100644
index 0000000000000000000000000000000000000000..ca79151157990af16a8aa69cd170a415bbc73c2a
--- /dev/null
+++ b/matlab/tfgm/tf_filtering/solver_tfgm_interp.m
@@ -0,0 +1,41 @@
+function x_interp= solver_tfgm_interp(X, mask, idgt)
+%% x_interp= solver_tfgm_interp(X, mask, idgt)
+% This function apply a linear interpolation along
+% the frequency axis of the magnitude of observation time-frequency matrix
+% and draws the related phase uniformly at random.
+%
+% Inputs:
+% - X: time-frequency matrix
+% - mask: binary mask
+% - idgt: Inverse of Gabor transform operator
+% Outputs:
+% -x_interp: estimated signal
+%
+%
+% Author: Marina KREME
+
+%%
+
+X_abs = abs(X);
+X_ang = angle(X);
+
+mask_copy = mask;
+
+%% modulus interpolation
+Y = X_abs.*(1-mask_copy);
+
+figure; imagesc(Y); title('before interp');
+
+Z = (Y==0);
+
+Y(Z) = interp1(find(~Z),Y(~Z), find(Z),'linear');
+figure; imagesc(Y); title('after interp')
+
+%%
+
+X_ang(mask==1) = 2*pi*rand(sum(mask(:)),1);
+X_interp = abs(Y).*exp(1i.*X_ang);
+x_interp = compute_idgt(X_interp, idgt);
+
+
+end
\ No newline at end of file
diff --git a/matlab/tfgm/tf_filtering/solver_tfgm_zero.m b/matlab/tfgm/tf_filtering/solver_tfgm_zero.m
new file mode 100644
index 0000000000000000000000000000000000000000..9eef53133c043983b955f8b99a39721723f6bc9d
--- /dev/null
+++ b/matlab/tfgm/tf_filtering/solver_tfgm_zero.m
@@ -0,0 +1,19 @@
+function x_zero= solver_tfgm_zero(X, mask, idgt)
+
+%% x_zero= solver_tfgm_zero(X, mask, idgt)
+% Thid function reconstruct the signal after filling the masked regions by zeros.
+% Inputs:
+% - X: time-frequency matrix
+% - mask: binary mask
+% - idgt: Inverse of Gabor transform operator
+% Outputs:
+% -x_interp: estimated signal
+%
+%
+% Author: Marina KREME
+
+%%
+X(mask==1)=0;
+x_zero = compute_idgt(X, idgt);
+
+end
\ No newline at end of file
diff --git a/matlab/tfgm/tf_tools/error_operator_norm.m b/matlab/tfgm/tf_tools/error_operator_norm.m
new file mode 100644
index 0000000000000000000000000000000000000000..cdfe4651a2c68663eeef531c242a65779473ba25
--- /dev/null
+++ b/matlab/tfgm/tf_tools/error_operator_norm.m
@@ -0,0 +1,18 @@
+function eig_val = error_operator_norm(gab_mul, svd_res)
+% compute error M -UDU.T
+
+u_mat = svd_res.U;
+s = svd_res.D;
+u_h = u_mat';
+
+u_op = @(x) u_mat*x;
+s_op = @(x) s*x;
+u_h_op = @(x)u_h*x;
+
+a_est = @(x) real(u_op(s_op(u_h_op(x))));
+
+err_op = @(x) gab_mul(x) - a_est(x) ;
+
+eig_val = abs(eigs(err_op, size(u_mat,1),1));
+
+end
\ No newline at end of file
diff --git a/matlab/tfgm/tf_tools/gabormultiplier/compute_ambiguity_function.m b/matlab/tfgm/tf_tools/gabormultiplier/compute_ambiguity_function.m
new file mode 100644
index 0000000000000000000000000000000000000000..ea700e1731532cc5409b4af6648fdad9e8b66746
--- /dev/null
+++ b/matlab/tfgm/tf_tools/gabormultiplier/compute_ambiguity_function.m
@@ -0,0 +1,23 @@
+function x = compute_ambiguity_function(x, dgt ,apply_fftshift)
+%% x = compute_ambiguity_function(x, dgt ,fftshift_)
+% is used to compute the ambiguity function.
+%
+% Inputs:
+% - x : vector
+% - dgt : Gabor transform operator
+% -apply_fftshift: Boolean
+%
+%Author: Marina KREME
+%%
+
+switch apply_fftshift
+
+ case 'True'
+ x = dgt(fftshift(x));
+
+ case 'False'
+ x = dgt(x);
+ otherwise
+ fprintf('Incorrect value fftshift_\n')
+
+end
\ No newline at end of file
diff --git a/matlab/tfgm/tf_tools/gabormultiplier/gen_gabmul_operator.m b/matlab/tfgm/tf_tools/gabormultiplier/gen_gabmul_operator.m
new file mode 100644
index 0000000000000000000000000000000000000000..e34720b8b8f704ec5eb16b4e389d92b1207db6f3
--- /dev/null
+++ b/matlab/tfgm/tf_tools/gabormultiplier/gen_gabmul_operator.m
@@ -0,0 +1,23 @@
+function [gabmul_op, varargout] = gen_gabmul_operator(dgt, idgt, mask)
+%% GEN_GABMUL_OPERATOR computes a Gabor multiplier
+% [gabmul_op, varargout] = gen_gabmul_operator(dgt, idgt, mask)
+%
+% Inputs:
+% - dgt: Gabor transform operator
+% - idgt: inverse Gabor transform operator
+% - mask: binary known mask
+% Output:
+% - gabmul_op: gabor multiplier- handle function
+%
+% Author : A. Marina KREME
+% e-mail : ama-marina.kreme@lis-lab.fr/ama-marina.kreme@univ-amu.fr
+% Created: 2020-28-01
+%%
+
+
+
+gabmul_op = @(x)idgt(mask.*dgt(x));
+varargout{1} = mask;
+
+
+end
\ No newline at end of file
diff --git a/matlab/tfgm/tf_tools/gabormultiplier/generate_rectangular_mask.m b/matlab/tfgm/tf_tools/gabormultiplier/generate_rectangular_mask.m
new file mode 100644
index 0000000000000000000000000000000000000000..a026f3af0cf8e913ebdd4d12ef335959e3e64451
--- /dev/null
+++ b/matlab/tfgm/tf_tools/gabormultiplier/generate_rectangular_mask.m
@@ -0,0 +1,31 @@
+function mask = generate_rectangular_mask(nbins, hop, sig_len, t_lim, f_lim)
+%% GENERATE_RECTANGULAR_MASK
+% This function generates a rectangular mask
+% mask = generate_rectangular_mask(nbins, hop, sig_len, t_lim, f_lim)
+% Inputs:
+% - nbins: numbers of channels (int)
+% - hop : length of time shift (int)
+% - sig_len: signal length (int)
+% - t_lim : time value interval
+% - f_lim : frequency value interval
+%
+% Outputs:
+% - mask : mask
+% Author : A. Marina KREME
+%%
+
+
+M = nbins/2 +1;
+N = sig_len/hop;
+
+if size(f_lim,2)~=2 || size(t_lim,2)~=2
+ error("Incorrect value. f_lim or t_lim must be an interval")
+end
+
+mask = zeros(M,N);
+f_lim = round(f_lim*size(mask,1));
+t_lim =round(t_lim*size(mask,2));
+
+mask(f_lim(1):f_lim(2),t_lim(1):t_lim(2))=1;
+
+end
diff --git a/matlab/tfgm/tf_tools/gabormultiplier/plot_ambiguity_function.m b/matlab/tfgm/tf_tools/gabormultiplier/plot_ambiguity_function.m
new file mode 100644
index 0000000000000000000000000000000000000000..460137560b7d91cf838c3e7ca665d5482ce61c90
--- /dev/null
+++ b/matlab/tfgm/tf_tools/gabormultiplier/plot_ambiguity_function.m
@@ -0,0 +1,29 @@
+function plot_ambiguity_function(x, dgt , dgt_params, signal_params, dynrange)
+
+%% plot_ambiguity_function(x, dgt , dgt_params, signal_params, dynrange)
+
+% This function compute and plot ambiguity function for a given vector
+%
+% Inputs:
+% - x: signal
+% -dgt: Gabor transform operator
+% - dgt_params: Signals parameters(sig_len, fs)
+% - signal_params: Discrete Gabor Transform parameters(hop, nbins,win, ect..)
+% - dynrange : dynamic range (optional)
+%
+% Author: Marina KREME
+%%
+
+
+
+if nargin==4
+ dynrange = 100;
+end
+
+apply_fftshift ='True';
+
+x = compute_ambiguity_function(x, dgt ,apply_fftshift);
+plotdgtreal(x, dgt_params.hop, dgt_params.nbins, signal_params.fs,'dynrange', dynrange)
+
+
+end
diff --git a/matlab/tfgm/tf_tools/gabormultiplier/product_of2_multipliers.m b/matlab/tfgm/tf_tools/gabormultiplier/product_of2_multipliers.m
new file mode 100644
index 0000000000000000000000000000000000000000..49c49eb72ddfb8fd3a1fc3f31a53f0a1165f16a9
--- /dev/null
+++ b/matlab/tfgm/tf_tools/gabormultiplier/product_of2_multipliers.m
@@ -0,0 +1,19 @@
+function mul1mul2= product_of2_multipliers(dgt, idgt, mask1, mask2)
+% mul1mul2= product_of2_multipliers(direct_stft, adjoint_stft, mask1, mask2)
+%
+% This function generates the product of two multipliers
+% associated with two masks.
+%
+% Inputs:
+% - dgt: short-time Fourier transfrom operator
+% - idgt: inverse short-time Fourier transfrom operator
+% - mask1, mask2: binary known mask
+% Output:
+% - mul1mul2, mul2mul1: product of two gabor multipliers- handle function
+%
+
+
+mul1mul2 = @(x)idgt(mask1.*dgt(idgt(mask2.*dgt(x))));
+
+
+end
\ No newline at end of file
diff --git a/matlab/tfgm/tf_tools/generate_dgt_parameters.m b/matlab/tfgm/tf_tools/generate_dgt_parameters.m
new file mode 100644
index 0000000000000000000000000000000000000000..bd9afbdca3cb48fdea6a5480a665a049b12c1a49
--- /dev/null
+++ b/matlab/tfgm/tf_tools/generate_dgt_parameters.m
@@ -0,0 +1,74 @@
+function dgt_params = generate_dgt_parameters(win_type, approx_win_len, hop, nbins, sig_len)
+%% dgt_params = generate_dgt_parameters(win_type, approx_win_len, hop, nbins, sig_len)
+%
+% function that generates the dgt parameters.The functions used for
+% the DGT are those of ltfat and not those of Matlab
+
+% Inputs:
+% - win_type : str. It can be either a hanning (hann) or gauss window.
+% - approx_win_len : window length
+% - hop : length of time shift.
+% - nbins: number of channels.
+% -sig_len: length of input signal.
+%
+% Outputs: dgt_params - struct containing dgt parameters
+%
+%
+% Author : A. Marina KREME
+% e-mail : ama-marina.kreme@lis-lab.fr/ama-marina.kreme@univ-amu.fr
+% Created: 2020-28-01
+%%
+
+
+
+win_type = lower(win_type);
+
+if ~ischar(win_type)
+ error('%s: The window type must be a string',upper(mfilename));
+end
+
+
+ch1= strcmp('hann', win_type);
+ch2 = strcmp('gauss', win_type);
+
+if ch1==0 && ch2==0
+ error('%s: Incorrect window type. Please choose hann or gauss.',upper(mfilename));
+end
+%%
+
+
+
+input_win_len = 2^(round(log2(approx_win_len)));
+
+if input_win_len ~= approx_win_len
+ warning('Input window length %.2f has been changed to %.2f.',approx_win_len, input_win_len);
+end
+
+win_len = input_win_len;
+
+%%
+
+L = sig_len;
+
+switch win_type
+ case 'hann'
+ [win, info]= gabwin({'tight',{win_type, win_len}}, hop, nbins, L);
+
+ case 'gauss'
+ tfr = (pi*win_len^2)/(4*sig_len*log(2));
+ [win, info]= gabwin({'tight',{win_type, tfr}}, hop, nbins,L);
+
+end
+
+%%
+
+dgt_params.win_len = win_len;
+dgt_params.hop = hop;
+dgt_params.nbins= nbins;
+dgt_params.win_type = win_type;
+dgt_params.win = win;
+dgt_params.info = info;
+
+
+end
+
diff --git a/matlab/tfgm/tf_tools/generate_signal_parameters.m b/matlab/tfgm/tf_tools/generate_signal_parameters.m
new file mode 100644
index 0000000000000000000000000000000000000000..a35b334d76d70846adb9b4a618b7a31c68c569f0
--- /dev/null
+++ b/matlab/tfgm/tf_tools/generate_signal_parameters.m
@@ -0,0 +1,28 @@
+function signal_params = generate_signal_parameters(fs, sig_len)
+%% GENERATE_SIGNAL_PARAMETERS
+% signal_params = generate_signal_parameters(fs, sig_len)
+% function that generates signals parameters (fs and sig_len)
+%
+% Inputs:
+% - fs: sampling frequency
+% - sig_len : signal length
+% Outputs:
+% - signal_params: structure that contains the signal parameters,
+% i.e. the sampling frequency and the length of the signal.
+%
+% Author : A. Marina KREME
+% e-mail : ama-marina.kreme@lis-lab.fr/ama-marina.kreme@univ-amu.fr
+% Created: 2020-28-01
+%%
+
+
+if mod(sig_len,2)~=0
+ sig_len = 2^(round(log2(sig_len)));
+end
+
+
+signal_params.fs=fs;
+signal_params.sig_len = sig_len ;
+
+
+end
\ No newline at end of file
diff --git a/matlab/tfgm/time_frequency_filtering/reconstruction.m b/matlab/tfgm/time_frequency_filtering/reconstruction.m
new file mode 100644
index 0000000000000000000000000000000000000000..52f99865a639a7e5debacc93d0038a3cdcf018ad
--- /dev/null
+++ b/matlab/tfgm/time_frequency_filtering/reconstruction.m
@@ -0,0 +1,9 @@
+function x = reconstruction(lambda_vec, u_mat_list, s_vect_list)
+
+x =x_mix;
+for i=1:length(lambda_vec)
+ x_rec = recs{i};
+ x = x+x_rec(lambda_vec(i))-x_mix;
+end
+
+end
\ No newline at end of file
diff --git a/matlab/tfgm/time_frequency_filtering/tf_filtering_init.m b/matlab/tfgm/time_frequency_filtering/tf_filtering_init.m
new file mode 100644
index 0000000000000000000000000000000000000000..4fadc40a49910805898ce920cbd8ff5a8edb58f4
--- /dev/null
+++ b/matlab/tfgm/time_frequency_filtering/tf_filtering_init.m
@@ -0,0 +1,38 @@
+function tf_filtering_init(x_mix, mask, dgt_params, signal_params, multiple_masks)
+
+%%
+if multiple_masks=='True'
+ n_areas = unique(mask);
+ mask=mask;
+else
+ n_areas=1;
+ mask= mask>0;
+end
+%%
+gabmul_list =cell(length(n_areas),1);
+
+for i =1:length(n_areas)
+ gabmul_list{i} = gen_gabmul_operator(tight_direct_stft, tight_adjoint_stft, mask_);
+end
+end
+
+% def __init__(self, x_mix, mask, dgt_params, signal_params, multiple_masks):
+% self.x_mix = x_mix
+% self.dgt_params = dgt_params
+% self.signal_params = signal_params
+% if multiple_masks:
+% n_areas = np.unique(mask).size - 1
+% self.mask = mask
+% else:
+% n_areas = 1
+% self.mask = mask > 0
+% self.gabmul_list = [GaborMultiplier(mask=(mask == i + 1),
+% dgt_params=dgt_params,
+% signal_params=signal_params)
+% for i in range(n_areas)]
+% self.s_vec_list = [None for i in range(n_areas)]
+% self.u_mat_list = [None for i in range(n_areas)]
+% self.uh_x_list = [None for i in range(n_areas)]
+% self.t_arrf = [None for i in range(n_areas)]
+% self.t_evdn = [None for i in range(n_areas)]
+% self.t_uh_x = [None for i in range(n_areas)]
diff --git a/matlab/tfgm/time_frequency_filtering/untitled.m b/matlab/tfgm/time_frequency_filtering/untitled.m
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/matlab/tfgm/utils/EVD_eigs.m b/matlab/tfgm/utils/EVD_eigs.m
new file mode 100644
index 0000000000000000000000000000000000000000..03ac5836e88a2b5aaf46bf9b41ddab347fcdabec
--- /dev/null
+++ b/matlab/tfgm/utils/EVD_eigs.m
@@ -0,0 +1,23 @@
+function svd_res = EVD_eigs(mul, sig_len, r)
+%% SVD_RES = EVD_eigs(MUL, SIG_LEN, R)
+% this function is used to perform the spectral value decomposition
+% by pre-estimating the rank of the matrix to be diagonalized.
+% It uses the MATLAB's "eigs" function for diagonalization.
+%
+% Inputs:
+% - mul : operator to be diagonalized (Gabor multiplier )
+% - sig_len : signal length
+% - r : integer - number of eigenvalues to keep
+%
+% Outputs:
+%
+% - U :orthonormal matrix
+% - D : nonnegative and diagonal matrix
+%
+% Created: 2020-04-01
+%%
+
+[U,D] = eigs(mul, sig_len, r);
+svd_res.U = U;
+svd_res.D =D;
+end
\ No newline at end of file
diff --git a/matlab/tfgm/utils/EVD_nystrom.m b/matlab/tfgm/utils/EVD_nystrom.m
new file mode 100644
index 0000000000000000000000000000000000000000..bab9774e2b9a1a219718dae4fd7bf41f28456e70
--- /dev/null
+++ b/matlab/tfgm/utils/EVD_nystrom.m
@@ -0,0 +1,33 @@
+function svd_res = EVD_nystrom(mul, Q)
+%% SVD_RES = EVD_HALKO(MUL, Q)
+% this function is used to perform the spectral value decomposition
+% by pre-estimating the rank of the matrix to be diagonalized.
+% It uses the function "eigenvalue decomposition via nystrom[1]" for diagonalization.
+%
+%
+% Inputs:
+% - mul : operator to be diagonalized (Gabor multiplier )
+% - Q : orthonormal matrix
+%
+% Outputs:
+%
+% - U :orthononmal matrix
+% - D : nonnegative and diagonal matrix
+%
+%
+% REFERENCES:
+%
+% Nathan Halko, Per-Gunnar Martinsson, Joel A. Tropp, "Finding structure
+% with randomness: Probabilistic algorithms for constructing approximate
+% matrix decompositions", 2011.
+%
+%
+% Created: 2020-04-01
+%%
+
+[U,D] = eigvalue_decomposition_via_nystrom(mul, Q);
+svd_res.U = U;
+svd_res.D =D;
+
+
+end
diff --git a/matlab/tfgm/utils/build_IS_tab.m b/matlab/tfgm/utils/build_IS_tab.m
new file mode 100644
index 0000000000000000000000000000000000000000..79bc31f8a224fd83c0ec82ff8868dc47651853cf
--- /dev/null
+++ b/matlab/tfgm/utils/build_IS_tab.m
@@ -0,0 +1,74 @@
+%% load data
+fid = fopen('exp_solve_pd.csv', 'r');
+% read data
+formatSpec = '%s %s %s %f %s %f';
+data = textscan(fid, formatSpec,...
+ 'headerlines', 1,...
+ 'delimiter',',',...
+ 'TreatAsEmpty','NA'); % lecture du fichier
+fclose(fid);
+
+%% define data to be taken
+% PERTUBATION
+%data{1,1}
+% 'beeps' 'bird' 'chirps' 'clicks' 'finger_snaps' 'modulations'
+listp={'beeps','bird','chirps','clicks','finger_snaps','modulations'};
+% WIDEBAND SIGNALS
+%data{1,2}
+% 'car' 'train' 'plane'
+listw={'car','train','plane'};
+% WINDOW
+%data{1,3}
+win = 'gauss 256'; %ou 'hann 512'
+% 1 REGION or P REGIONS
+%data{1,4}
+%isnan 1 region sinon P region
+% DATA TO BE READ
+%data{1,5}
+% 'is_zero' 'is_interp' 'is_oracle_sdr' 'is_tff'
+% NUMERICAL VALUE
+%data{1,6} --> les res numeriques
+
+%% generate matlab table
+indw=strcmp(data{1,3},win); %window
+indnan=isnan(data{1,4}); %1 or P regions
+
+% we read all configurations
+tab=[];
+for i=listp
+ indb=strcmp(data{1,1},i);
+ for j=listw
+ tabtmp=[];
+ indc=strcmp(data{1,2},j);
+ for k={'is_zero','is_interp','is_oracle_sdr','is_tff'}
+ inds=strcmp(data{1,5},k);
+ ind=indw&indb&indc&inds&indnan;
+ tabtmp=[tabtmp,data{1,6}(ind)];
+ end
+ ind=indw&indb&indc&inds&~indnan;
+ tabtmp=[tabtmp,data{1,6}(ind)];
+ tab=[tab;tabtmp];
+ end
+end
+
+%% generate latex table
+fic='resIS.txt';
+fid=fopen(fic,'a+');
+l=1;
+txt=[];
+for i=listp
+ for j=listw
+ for m=1:5
+ txt=[txt,'&',num2str(tab(l,m),'%.1f')];
+ if m==5
+ txt=[txt,'\\'];
+ end
+ end
+ text=[i{1},'&',j{1},txt];
+ fprintf(fid,'%s\n',text);
+ l=l+1;
+ txt=[];
+ end
+ fprintf(fid,'%s\n','\hline');
+end
+fclose(fid);
\ No newline at end of file
diff --git a/matlab/tfgm/utils/build_SDR_tab.m b/matlab/tfgm/utils/build_SDR_tab.m
new file mode 100644
index 0000000000000000000000000000000000000000..d3515bcf3ba15d57cd281d54c1ae7d930914ac75
--- /dev/null
+++ b/matlab/tfgm/utils/build_SDR_tab.m
@@ -0,0 +1,74 @@
+%% load data
+fid = fopen('exp_solve_pd.csv', 'r');
+% read data
+formatSpec = '%s %s %s %f %s %f';
+data = textscan(fid, formatSpec,...
+ 'headerlines', 1,...
+ 'delimiter',',',...
+ 'TreatAsEmpty','NA'); % lecture du fichier
+fclose(fid);
+
+%% define data to be taken
+% PERTUBATION
+%data{1,1}
+% 'beeps' 'bird' 'chirps' 'clicks' 'finger_snaps' 'modulations'
+listp={'beeps','bird','chirps','clicks','finger_snaps','modulations'};
+% WIDEBAND SIGNALS
+%data{1,2}
+% 'car' 'train' 'plane'
+listw={'car','train','plane'};
+% WINDOW
+%data{1,3}
+win = 'gauss 256'; %ou 'hann 512'
+% 1 REGION or P REGIONS
+%data{1,4}
+%isnan 1 region sinon P region
+% DATA TO BE READ
+%data{1,5}
+% 'sdr_zero' 'sdr_interp' 'sdr_tff' 'sdr_oracle_sdr'
+% NUMERICAL VALUE
+%data{1,6} --> les res numeriques
+
+%% generate matlab table
+indw=strcmp(data{1,3},win); %window
+indnan=isnan(data{1,4}); %1 or P regions
+
+% we read all configurations
+tab=[];
+for i=listp
+ indb=strcmp(data{1,1},i);
+ for j=listw
+ tabtmp=[];
+ indc=strcmp(data{1,2},j);
+ for k={'sdr_zero','sdr_interp','sdr_oracle_sdr','sdr_tff'}
+ inds=strcmp(data{1,5},k);
+ ind=indw&indb&indc&inds&indnan;
+ tabtmp=[tabtmp,data{1,6}(ind)];
+ end
+ ind=indw&indb&indc&inds&~indnan;
+ tabtmp=[tabtmp,data{1,6}(ind)];
+ tab=[tab;tabtmp];
+ end
+end
+
+%% generate latex table
+fic='resSDR.txt';
+fid=fopen(fic,'a+');
+l=1;
+txt=[];
+for i=listp
+ for j=listw
+ for m=1:5
+ txt=[txt,'&',num2str(tab(l,m),'%.2f')];
+ if m==5
+ txt=[txt,'\\'];
+ end
+ end
+ text=[i{1},'&',j{1},txt];
+ fprintf(fid,'%s\n',text);
+ l=l+1;
+ txt=[];
+ end
+ fprintf(fid,'%s\n','\hline');
+end
+fclose(fid);
\ No newline at end of file
diff --git a/matlab/tfgm/utils/compute_dgt.m b/matlab/tfgm/utils/compute_dgt.m
new file mode 100644
index 0000000000000000000000000000000000000000..f37e9dc88cb9e0dc330a9b8552e77e775ea8e252
--- /dev/null
+++ b/matlab/tfgm/utils/compute_dgt.m
@@ -0,0 +1,19 @@
+function tf_mat = compute_dgt(x, dgt)
+%% tf_mat = compute_dgt(x, dgt)
+% This function computes the time-frequency (TF) matrix from a signal
+%
+% Input:
+% - x: signal. must be a vector
+% - dgt :gabor transform operator
+% Output:
+% -tf_mat: TF matrix
+%
+% Author : A. Marina KREME
+% e-mail : ama-marina.kreme@lis-lab.fr/ama-marina.kreme@univ-amu.fr
+% Created: 2020-28-01
+%%
+if size(x,2)~=1
+ error('Input signal must be a vector of a column:%s',upper(mfilename))
+end
+tf_mat = dgt(x);
+end
\ No newline at end of file
diff --git a/matlab/tfgm/utils/compute_idgt.m b/matlab/tfgm/utils/compute_idgt.m
new file mode 100644
index 0000000000000000000000000000000000000000..72243bc33715cca4728d72ca03680d2e059b8c0f
--- /dev/null
+++ b/matlab/tfgm/utils/compute_idgt.m
@@ -0,0 +1,18 @@
+function x = compute_idgt(tf_mat, idgt)
+%% x = compute_idgt(tf_mat, idgt)
+% This function reconstruct a signal form its the time-frequency (TF) matrix
+%
+% Input:
+% - tf_mat: TF matrix
+% - idgt: inverse of gabor transform operator
+% Output:
+% -x: reconstructed signal
+%
+% Author : A. Marina KREME
+% e-mail : ama-marina.kreme@lis-lab.fr/ama-marina.kreme@univ-amu.fr
+% Created: 2020-28-01
+%%
+
+x = idgt(tf_mat);
+
+end
\ No newline at end of file
diff --git a/matlab/tfgm/utils/compute_r.m b/matlab/tfgm/utils/compute_r.m
new file mode 100644
index 0000000000000000000000000000000000000000..2fa569feedafe3f05391ca5620de602ead03cf7a
--- /dev/null
+++ b/matlab/tfgm/utils/compute_r.m
@@ -0,0 +1,28 @@
+function r = compute_r(m, n, prob)
+%% COMPUTE_R: this function calculates a small integer r which is used to equilibrate the
+% calculation cost and the reliability of the approximation error of
+% |(I-QQ')A| < tol in Halko, 2011.
+%
+% Input:
+% - m: number of lines in the input matrix
+% - n: number of columns in the input matrix
+% - prob: the probability with which one would like to achieve approximation Q of A.
+%
+% Output:
+% - r: integer
+%
+% REFERENCES:
+%
+% Nathan Halko, Per-Gunnar Martinsson, Joel A. Tropp, "Finding structure
+% with randomness: Probabilistic algorithms for constructing approximate
+% matrix decompositions", 2011.
+%
+% Author : A. Marina KREME
+% e-mail : ama-marina.kreme@lis-lab.fr/ama-marina.kreme@univ-amu.fr
+% Created: 2020-28-01
+%%
+
+
+r = ceil(-(log((1-prob)/min(m,n)))/log(10));
+
+end
\ No newline at end of file
diff --git a/matlab/tfgm/utils/db.m b/matlab/tfgm/utils/db.m
new file mode 100644
index 0000000000000000000000000000000000000000..dd0ccf488de1cde98e0ae9ec67e9aaa5939df726
--- /dev/null
+++ b/matlab/tfgm/utils/db.m
@@ -0,0 +1,10 @@
+function x_db = db(x)
+%% x_db = db(x)
+% Converts the elements of x to decibels (dB).
+% Author: Marina KREME
+%%
+x_db = 20*log10(abs(x));
+end
+
+
+
diff --git a/matlab/tfgm/utils/generate_mask.m b/matlab/tfgm/utils/generate_mask.m
new file mode 100644
index 0000000000000000000000000000000000000000..42e94e3605f2fc6ad3e5a22890f86049e69c29d8
--- /dev/null
+++ b/matlab/tfgm/utils/generate_mask.m
@@ -0,0 +1,44 @@
+function [mask,varargout] = generate_mask(tf_mat_wideband, tf_mat_loc, alpha, seuil, radius)
+
+%% GENERATE MASK
+% [original_mask, mask_after_imclose, mask_after_imopen,...,
+% mask] = generate_mask(tf_mat_wideband, tf_mat_loc, alpha, seuil, radius)
+
+% function that generates a binary mask
+%
+% Inputs:
+
+% - tf_mat_wideband: dgt of target signal
+% - tf_mat_loc : dgt of perturbation signal
+% - alpha: parameter to adjust the size of the mask
+% - radius : it specifies the radius of morphological structuring element.
+% - seuil: threshold value.
+%
+% Output:
+% - mask: binary mask
+%
+% Author : A. Marina KREME
+% e-mail : ama-marina.kreme@lis-lab.fr/ama-marina.kreme@univ-amu.fr
+% Created: 2020-28-01
+%%
+
+
+original_mask = or(abs(tf_mat_wideband)<alpha*abs(tf_mat_loc), abs(tf_mat_loc)>seuil);
+varargout{1} = original_mask;
+
+%figure('name','mask initial'); imagesc(original_mask)
+
+%%
+
+se = strel('disk',radius);
+mask_after_imclose = imclose(original_mask,se);
+
+varargout{2} = mask_after_imclose;
+%figure('name','imclose'); imagesc(mask_after_imclose)
+%%
+mask_after_imopen = imopen(mask_after_imclose,se);
+varargout{3} = mask_after_imopen;
+%figure('name','mask imopen'); imagesc(mask_after_imopen)
+mask =mask_after_imopen;
+end
+
diff --git a/matlab/tfgm/utils/generate_mask_db.m b/matlab/tfgm/utils/generate_mask_db.m
new file mode 100644
index 0000000000000000000000000000000000000000..8a8c10cb55c54a788ec77601f00dff50d9a8a0b0
--- /dev/null
+++ b/matlab/tfgm/utils/generate_mask_db.m
@@ -0,0 +1,46 @@
+function mask = generate_mask_db(x_loc, x_wb, gamma, dgt, delta_mix_db, delta_loc_db,radius, or_mask)
+%% GENERATE MASK
+% mask = generate_mask_db(dgt_X_wb, dgt_X_loc, gain_mix_db, gain_loc_db,radius, or_mask)
+% function that generates a binary mask
+%
+%%
+
+signals = generate_mix_signal(x_wb, x_loc, gamma);
+x_wb = signals.wideband;
+x_loc = signals.localized;
+
+tf_mat_loc_db = db(abs(dgt(x_loc)));
+tf_mat_wb_db = db(abs(dgt(x_wb)));
+
+
+mask_mix = tf_mat_loc_db > tf_mat_wb_db + delta_mix_db;
+mask_loc = tf_mat_loc_db > max(tf_mat_loc_db(:)) - delta_loc_db;
+
+
+
+
+if or_mask==1
+ mask_raw = or(mask_mix, mask_loc);
+else
+ mask_raw = and(mask_mix, mask_loc);
+end
+
+%figure('name','init'); imagesc(mask)
+%%
+se = strel('disk',radius,0);
+mask = mask_raw;
+for k=1:10
+%%
+mask_close = imclose(mask,se);
+%figure('name','imclose'); imagesc(mask)
+
+%%
+mask = imopen(mask_close,se);
+%figure('name','imopen'); imagesc(mask)
+
+end
+
+
+
+
+end
\ No newline at end of file
diff --git a/matlab/tfgm/utils/generate_mix_signal.m b/matlab/tfgm/utils/generate_mix_signal.m
new file mode 100644
index 0000000000000000000000000000000000000000..be2fb55cf5bd9d68fa7f5a6ab9179aee535e22eb
--- /dev/null
+++ b/matlab/tfgm/utils/generate_mix_signal.m
@@ -0,0 +1,41 @@
+function signals = generate_mix_signal(x_wb, x_loc, gamma)
+%% signals = generate_mix_signal(x_wb, x_loc, gamma)
+% function that generates mixtures of two signals
+% Inputs:
+% - x_wb: signal with wideband spectrogram
+% - x_loc: signal with localized spectrogram
+% - gamma: constant belonging to interval ]0,1[.
+% allows you to control the percentages of each signal.
+% Outputs:
+% - signals: struct containing wideband, localized and mixtures of two signals.
+%
+%
+% Author : A. Marina KREME
+% e-mail : ama-marina.kreme@lis-lab.fr/ama-marina.kreme@univ-amu.fr
+% Created: 2020-28-01
+%
+%%
+
+
+
+if length(x_wb)~= length(x_loc)
+ error('%s:Arrays are not equal',upper(mfilename));
+end
+
+x_wb= x_wb./norm(x_wb);
+x_loc = x_loc./norm(x_loc);
+
+
+if (gamma==0 || gamma==1)
+ error('%s: Incorrect gamma value. It must be in ]0,1[. Please check it',upper(mfilename));
+else
+ x_wb = gamma*x_wb;
+ x_loc = (1-gamma)*x_loc;
+ x_mix = x_wb + x_loc;
+end
+
+signals.wideband = x_wb;
+signals.localized = x_loc;
+signals.mix = x_mix;
+
+end
\ No newline at end of file
diff --git a/matlab/tfgm/utils/get_stft_operators.m b/matlab/tfgm/utils/get_stft_operators.m
new file mode 100644
index 0000000000000000000000000000000000000000..b42074d2927e1c87d15430a957bf59c777266a7e
--- /dev/null
+++ b/matlab/tfgm/utils/get_stft_operators.m
@@ -0,0 +1,46 @@
+function [dgt, idgt, varargout] = get_stft_operators(dgt_params, signal_params, phase_conv)
+%% GET_STFT_OPERATORS
+% [dgt, idgt, pseudoinverse_dgt] = get_stft_operators(dgt_params, signal_params, phase_conv)
+
+% functions that generate the DGT operators.
+%
+% Inputs:
+% - dgt_params: struct that contains the DGT parameters. See generate_dgt_parameters.m
+% - signal_params: structure which contains the sampling frequency as well as the signal length
+% - phase_conv : Compute a DGT using a frequency-invariant phase.
+%
+% Outputs:
+%
+% Author : A. Marina KREME
+% e-mail : ama-marina.kreme@lis-lab.fr/ama-marina.kreme@univ-amu.fr
+% Created: 2020-28-01
+%%
+
+
+if nargin==2
+ phase_conv= 'freqinv';
+end
+
+
+L = signal_params.sig_len;
+
+
+%%
+win = dgt_params.win;
+wd = gabdual(win, dgt_params.hop, dgt_params.nbins, L);
+
+
+dgt = @(x)dgtreal(x, win, dgt_params.hop, dgt_params.nbins, L, phase_conv);
+idgt = @(x)idgtreal(x, win, dgt_params.hop, dgt_params.nbins, L, phase_conv);
+
+pseudoinverse_dgt = @(x)idgtreal(x, wd, dgt_params.hop, dgt_params.nbins, L, phase_conv);
+
+
+varargout{1} = pseudoinverse_dgt;
+
+
+
+end
+
+
+
diff --git a/matlab/tfgm/utils/itakura_saito_dist.m b/matlab/tfgm/utils/itakura_saito_dist.m
new file mode 100644
index 0000000000000000000000000000000000000000..286d9c0aa0c9e4f7b3130308f563fb2e04b006d4
--- /dev/null
+++ b/matlab/tfgm/utils/itakura_saito_dist.m
@@ -0,0 +1,27 @@
+function IS = itakura_saito_dist(x_ref,x_est)
+%% IS = itakura_saito_dist(x_ref,x_est)
+% The Itakura?Saito distance (or Itakura?Saito divergence).It's measure
+% of the difference between an original signal x_ref and an approximation
+% x_est. see [1]
+% Inputs:
+% - x_ref : original signal
+% - x_est : estimated signal
+% Output:
+% -IS: Itakura SAito measurement.
+%
+%
+% Reference:
+%
+% [1] Itakura,F.,& Saito,S. (1968). Analysis synthesis telephony based
+% on the maximum likelihood method.
+%
+%
+% Author: Marina KREME
+%%
+z = x_ref./x_est;
+
+IS = sum(z - log(z)) - length(z);
+end
+
+
+
diff --git a/matlab/tfgm/utils/itakura_saito_dist_spectrum.m b/matlab/tfgm/utils/itakura_saito_dist_spectrum.m
new file mode 100644
index 0000000000000000000000000000000000000000..4a7d9a638e3aefada64e4f82d39b43106f4be6a2
--- /dev/null
+++ b/matlab/tfgm/utils/itakura_saito_dist_spectrum.m
@@ -0,0 +1,31 @@
+function IS_spectrum= itakura_saito_dist_spectrum(x_ref,x_est)
+
+%% IS_spectrum= itakura_saito_dist_spectrum(x_ref,x_est)
+% The Itakura?Saito distance (or Itakura?Saito divergence).It's measure
+% of the difference between an original spectrum and an approximation. see [1]
+% Inputs:
+% - x_ref : original signal
+% - x_est : estimated signal
+% Output:
+% -IS: Itakura SAito measurement.
+%
+%
+% Reference:
+%
+% [1] Itakura,F.,& Saito,S. (1968). Analysis synthesis telephony based
+% on the maximum likelihood method.
+%
+%
+% Author: Marina KREME
+%%
+
+
+x_spectre = abs(fft(x_ref));
+y_spectre = abs(fft(x_est));
+IS_spectrum =itakura_saito_dist(x_spectre,y_spectre);
+
+end
+
+
+
+
diff --git a/matlab/tfgm/utils/plot_mask.m b/matlab/tfgm/utils/plot_mask.m
new file mode 100644
index 0000000000000000000000000000000000000000..f2180c7adc23e5892ab6b6c9fb8bc1c30c4242f5
--- /dev/null
+++ b/matlab/tfgm/utils/plot_mask.m
@@ -0,0 +1,18 @@
+function plot_mask(mask, hop, nbins, fs)
+
+%% plot_mask(mask, hop, nbins, fs)
+% % This function displays the mask
+%
+% Inputs:
+% - mask: binary mask
+% - hop : length of time shift (int)
+% - nbins: numbers of channels (int)
+% - fs : sampling frequency
+
+% Author : A. Marina KREME
+%%
+
+%L = hop*size(mask,2);
+
+plotdgtreal(mask, hop, nbins, fs,'lin');
+%title(['Signal length = ' num2str(L)]);
diff --git a/matlab/tfgm/utils/plot_spectrogram.m b/matlab/tfgm/utils/plot_spectrogram.m
new file mode 100644
index 0000000000000000000000000000000000000000..3a4a29ea3808be5de974376645aed978523821fd
--- /dev/null
+++ b/matlab/tfgm/utils/plot_spectrogram.m
@@ -0,0 +1,31 @@
+function plot_spectrogram(x, dgt_params, signal_params, dgt, dynrange, clim)
+%% plot_spectrogram(x, dgt_params, signal_params, dgt, dynrange, clim)
+% Function that displays the spectrogram of a signal
+%
+% Inputs:
+% - x: signal
+% - dgt_params: dgt parameters
+% - signal_params: signal parameters
+% - dgt : Gabor transform operator
+% - dynrange : optional
+% - clim: optional
+%
+% Author : A. Marina KREME
+%%
+
+if size(x,2)==1
+ x = compute_dgt(x,dgt);
+end
+
+
+if nargin==4
+ dynrange=100;
+ c_max = max(db(x(:)));
+ clim = [c_max - dynrange, c_max];
+end
+
+
+
+plotdgtreal(x, dgt_params.hop, dgt_params.nbins, signal_params.fs,...,
+ 'dynrange', dynrange,'clim',clim)
+end
diff --git a/matlab/tfgm/utils/plot_win.m b/matlab/tfgm/utils/plot_win.m
new file mode 100644
index 0000000000000000000000000000000000000000..4d817aad34bc98b2108e1bccaad4fa8657b1e505
--- /dev/null
+++ b/matlab/tfgm/utils/plot_win.m
@@ -0,0 +1,33 @@
+function plot_win(win, fs, sig_len, win_type)
+%% plot_win(win, fs, sig_len, win_type)
+% This function displays the analysis window
+%
+% Inputs:
+% - win : analysis window
+% - fs : sampling frequency
+% - sig_len : signal lenght
+% - win_type: window type (str)
+%
+% Author: Marina KREME
+%%
+
+x_range = fftshift((1:length(win))./fs);
+x_range(x_range > x_range(end)) = x_range(x_range > x_range(end)) - length(x_range)/fs;
+
+if nargin==3
+ plot(x_range, fftshift(win),'LineWidth',2.5);
+elseif ~ischar(win_type)
+ error('%s: The window type must be a string',upper(mfilename));
+else
+ plot(x_range, fftshift(win), 'LineWidth',2.5)
+ legend(win_type)
+
+end
+xlabel('Time (s)')
+grid('on')
+title(['Signal length = ' num2str(sig_len)]);
+
+
+
+
+
diff --git a/matlab/tfgm/utils/sdr.m b/matlab/tfgm/utils/sdr.m
new file mode 100644
index 0000000000000000000000000000000000000000..e94493dcd77fe9d230a9c0f6459438c921a3fa1d
--- /dev/null
+++ b/matlab/tfgm/utils/sdr.m
@@ -0,0 +1,18 @@
+function SDR = sdr(x_ref, x_est)
+
+%% SDR = sdr(x_ref, x_est)
+% Compute Signal to Distorsion Ratio (SDR) between target signal
+% and estimated signal
+%
+% Inputs:
+% - x_ref: target signal
+% - x_est: estimated signal
+%
+% Output:
+% -SDR: Signal to Distorsion Ratio in dB
+%
+% Author: Marina KREME
+%%
+SDR= 20*log10(norm(x_ref,2)/norm(x_ref-x_est,2));
+
+end
\ No newline at end of file
diff --git a/matlab/tfgm/utils/snr.m b/matlab/tfgm/utils/snr.m
new file mode 100644
index 0000000000000000000000000000000000000000..b6d265686e85ec9be6fad473b129cfbd2a1742c9
--- /dev/null
+++ b/matlab/tfgm/utils/snr.m
@@ -0,0 +1,18 @@
+function SNR = snr(x_signal, x_noise)
+
+%% SNR = snr(x_signal, x_noise)
+% Compute SIgnal to Noise Ratio. It's used to compare the level
+% of a desired signal to the level of background noise.
+%
+% Inputs:
+% -x_signal: target signal
+% - x_noise: noise signal
+%
+% Output:
+% - SNR : SNR
+% Author: Marina KREME
+%%
+
+SNR = db(norm(x_signal)/norm(x_noise));
+end
+