def run(mic_observation_path, OUT_wav_path):
data, rate = read_mic_wav_from_folder(mic_observation_path, max_len_sec=45)
stft_arr = mic_stft.stft_arr(x_arr=data, fftsize=512)
sensor_positions = mic_geometry.get_sensor_positions(hor_mic_count,
vert_mic_count,
dHor=dHor,
dVert=dVert)
source_position = mic_geometry.get_source_position(0, 0)
steering_vector = mic_steering.propagation_vector_free_field(
sensor_positions, source_position, N_fft=512,
F_s=rate).transpose(1, 0)
S_spec = gsc_griffiths_filter(stft_arr=stft_arr,
d_arr=steering_vector,
mic_pos='closed')
# ISFFT signal
sig_out = istft(S_spec.transpose(1, 0), overlap=2)
# ISFFT signal
sf.write(OUT_wav_path, sig_out, rate)
def run_once():
# #################################################################
# # 1.0 - _wav_wbn45_dict0 PROFILE
#
# vert_mic_count = 6
# hor_mic_count = 11
# dHor = 0.035
# dVert = 0.05
# max_len_sec = 45
# n_fft = 512
#
# (angle_hor_log, angle_vert_log) = (0.0, 0.0)
# (angle_inf_hor_log, angle_inf_vert_log) = (45, 0)
#
# angle_h = -angle_hor_log
# angle_v = -angle_vert_log
#
# angle_inf_h = -angle_inf_hor_log
# angle_inf_v = -angle_inf_vert_log
#
# angle_h = -angle_hor_log
# angle_v = -angle_vert_log
#
# _mix_start = 0.0
# _mix_end = 20.0
#
# in_wav_path = r'./data/_wav_wbn45_dict0/'
# out_wav_path = r'./data/out/'
# #################################################################
# #################################################################
# 1.0 - _sol PROFILE MVDR
vert_mic_count = 6
hor_mic_count = 11
dHor = 0.035
dVert = 0.05
max_len_sec = 3 * 60
n_fft = 512
(angle_hor_log, angle_vert_log) = (13.8845, 6.60824)
(angle_inf_hor_log, angle_inf_vert_log) = (-15.06, -0.31)
angle_h = -angle_hor_log
angle_v = -angle_vert_log
angle_inf_h = -angle_inf_hor_log
angle_inf_v = -angle_inf_vert_log
in_wav_path = r'./data/_sol/'
out_wav_path = r'./data/out/'
_mix_start = 28
_mix_end = 48
#################################################################
#################################################################
# 1.0 - Read signal
x_all_arr, sr = read_mic_wav_from_folder(in_wav_path,
vert_mic_count,
hor_mic_count,
max_len_sec=max_len_sec)
x_all_arr = x_all_arr[:, (np.int32)(_mix_start * sr):(np.int32)(_mix_end *
sr)]
(n_channels, n_samples) = x_all_arr.shape
print("Array data read done!")
print(" n_channels = ", n_channels)
print(" n_samples = ", n_samples)
print(" freq = ", sr)
#################################################################
# 2 - Do STFT
stft_all = stft_arr(x_all_arr, fftsize=n_fft)
(n_bins, n_sensors, n_frames) = stft_all.shape
print("STFT calc done!")
print(" n_bins = ", n_bins)
print(" n_sensors = ", n_sensors)
print(" n_frames = ", n_frames)
#################################################################
# 3 - Calc steering vector
print('Calc steering vector!')
print(' (angle_h, angle_v) = ', angle_h, angle_v)
print(' (angle_inf_h, angle_inf_v) = ', angle_inf_h, angle_inf_v)
sensor_positions = get_sensor_positions(hor_mic_count,
vert_mic_count,
dHor=dHor,
dVert=dVert)
source_position = get_source_position(angle_h, angle_v, radius=6.0)
source_position_inf = get_source_position(angle_inf_h,
angle_inf_v,
radius=6.0)
d_arr = propagation_vector_free_field(sensor_positions,
source_position,
N_fft=n_fft,
F_s=sr)
d_arr_inf = propagation_vector_free_field(sensor_positions,
source_position_inf,
N_fft=n_fft,
F_s=sr)
#################################################################
# 4 - Calc DS beamforming in desired and noise direction
result_spec = ds_beamforming(stft_all, d_arr.T)
result_spec_inf = ds_beamforming(stft_all, d_arr_inf.T)
#################################################################
# 5 - ISTFT
sig_sp = istft(result_spec.transpose((1, 0)), overlap=2)
sig_inf = istft(result_spec_inf.transpose((1, 0)), overlap=2)
sf.write(r"out/out_ds_sp.wav", sig_sp, sr)
sf.write(r"out/out_ds_inf.wav", sig_inf, sr)
#################################################################
# 4 - NULL filter output
result_spec, _ = null_filter(stft_all,
d_arr_sp=d_arr.T,
d_arr_inf=d_arr_inf.T)
sig_out = istft(result_spec.transpose((1, 0)), overlap=2)
sf.write(r"out/out_null.wav", sig_out, sr)
#result_spec, _ = null_filter_ex(stft_mix_arr, d_arr_sp=d_arr.T, lst_d_arr_inf=[d_arr_inf.T, d_arr_inf_d1.T, d_arr_inf_d2.T])
# #################################################################
# # 6 - AP filter
# M = 200
# step = 0.05
# L = 5
# sig_result = affine_projection_filter(main=sig_sp, ref=sig_inf, M=M,step=step,L=5)
#################################################################
# 6.1 - AP filter + cyclic parameters
# M = 200
# step = 0.05
# L = 5
# leak = 0.0
# delay = -5
#params = [(200, 0.005, 5), (200, 0.05, 5), (200, 0.1, 5), (200, 0.5, 5)]
#params = [(200, 0.005, 5),(200, 0.005, 11), (200, 0.005, 25) , (200, 0.005, 35)]
params = [(100, 0.01, 5, 0.01, -5)]
for (M, step, L, leak, delay) in params:
print("process M = {}, step = {}, L = {}, leak = {}, dealy = {}".
format(M, step, L, leak, delay))
sig_inf = np.roll(sig_inf, delay)
sig_result = affine_projection_filter(main=sig_sp,
ref=sig_inf,
M=M,
step=step,
L=L,
leak=leak)
sf.write(
r"out/out_ap_null_M_{}_step_{}_L_{}_leak_{}_delay_{}.wav".format(
M, step, L, leak, delay), sig_result, sr)
sdr_impr, sir_impr, sar_impr, sdr_base, sir_base, sar_base = calc_sdr_impr_metric(
ref_sp, ref_mus, mix, sig_result)
print(base_name)
print(
"sdr_impr, sir_impr, sar_impr = {}, {}, {}, sdr_base, sir_base, sar_base = {}, {}, {}\n"
.format(sdr_impr, sir_impr, sar_impr, sdr_base, sir_base,
sar_base))
def params_iterate_null():
#base_name = 'out_mus1_spk1_snr_-10'
base_name = 'out_wgn_spk_snr_-10'
config = cfg.ConfigParser()
config.read(os.path.join(r'./data/_sdr_test', base_name, 'config.cfg'))
in_Main = r'./data/_sdr_test/' + base_name + r'/ds_mix.wav'
in_Main_Sp = r'./data/_sdr_test/' + base_name + r'/ds_spk.wav'
in_Main_Mus = r'./data/_sdr_test/' + base_name + r'/ds_mus.wav'
# #################################################################
# 1.0 - read PROFILE
vert_mic_count = int(config['MIC_CFG']['vert_mic_count'])
hor_mic_count = int(config['MIC_CFG']['hor_mic_count'])
dHor = float(config['MIC_CFG']['dhor'])
dVert = float(config['MIC_CFG']['dvert'])
max_len_sec = int(config['MIC_CFG']['max_len_sec'])
n_fft = int(config['MIC_CFG']['fft_size'])
angle_h = -float(config['FILTER_CFG']['angle_h'])
angle_v = -float(config['FILTER_CFG']['angle_v'])
angle_inf_h = -float(config['FILTER_CFG']['angle_inf_h'])
angle_inf_v = -float(config['FILTER_CFG']['angle_inf_v'])
in_wav_path = r'./data/_sdr_test/' + base_name + r'/mix'
out_wav_path = r'./data/out/'
_mix_start = float(config['FILTER_CFG']['start_mix_time'])
_mix_end = 30
#################################################################
#################################################################
# 1.0 - Read signal
x_all_arr, sr = read_mic_wav_from_folder(in_wav_path,
vert_mic_count,
hor_mic_count,
max_len_sec=max_len_sec)
ref_sp, _ = sf.read(in_Main_Sp)
ref_mus, _ = sf.read(in_Main_Mus)
mix, _ = sf.read(in_Main)
x_all_arr = x_all_arr[:, (np.int32)(_mix_start * sr):(np.int32)(_mix_end *
sr)]
ref_sp = ref_sp[:(np.int32)((_mix_end - _mix_start) * sr)]
ref_mus = ref_mus[:(np.int32)((_mix_end - _mix_start) * sr)]
mix = mix[(np.int32)(_mix_start * sr):(np.int32)(_mix_end * sr)]
(n_channels, n_samples) = x_all_arr.shape
print("Array data read done!")
print(" n_channels = ", n_channels)
print(" n_samples = ", n_samples)
print(" freq = ", sr)
#################################################################
# 2 - Do STFT
stft_all = stft_arr(x_all_arr, fftsize=n_fft)
(n_bins, n_sensors, n_frames) = stft_all.shape
print("STFT calc done!")
print(" n_bins = ", n_bins)
print(" n_sensors = ", n_sensors)
print(" n_frames = ", n_frames)
#################################################################
# 3 - Calc steering vector
print('Calc steering vector!')
print(' (angle_h, angle_v) = ', angle_h, angle_v)
print(' (angle_inf_h, angle_inf_v) = ', angle_inf_h, angle_inf_v)
sensor_positions = get_sensor_positions(hor_mic_count,
vert_mic_count,
dHor=dHor,
dVert=dVert)
source_position = get_source_position(angle_h, angle_v, radius=6.0)
source_position_inf = get_source_position(angle_inf_h,
angle_inf_v,
radius=6.0)
d_arr = propagation_vector_free_field(sensor_positions,
source_position,
N_fft=n_fft,
F_s=sr)
d_arr_inf = propagation_vector_free_field(sensor_positions,
source_position_inf,
N_fft=n_fft,
F_s=sr)
#################################################################
# 4 - Calc DS beamforming in desired and noise direction
result_spec = ds_beamforming(stft_all, d_arr.T)
result_spec_inf = ds_beamforming(stft_all, d_arr_inf.T)
#################################################################
# 5 - ISTFT
sig_sp = istft(result_spec.transpose((1, 0)), overlap=2)
sig_inf = istft(result_spec_inf.transpose((1, 0)), overlap=2)
sf.write(r"out/out_ds_sp.wav", sig_sp, sr)
sf.write(r"out/out_ds_inf.wav", sig_inf, sr)
#################################################################
# 5.1 - NULL filter + cyclic parameters
out_spec, _ = null_filter(stft_all,
d_arr_sp=d_arr.T,
d_arr_inf=d_arr_inf.T)
sig_out = istft(out_spec.transpose((1, 0)), overlap=2)
sf.write(r"out/out_null.wav", sig_out, sr)
#result_spec, _ = null_filter_ex(stft_mix_arr, d_arr_sp=d_arr.T, lst_d_arr_inf=[d_arr_inf.T, d_arr_inf_d1.T, d_arr_inf_d2.T])
sdr_impr, sir_impr, sar_impr, sdr_base, sir_base, sar_base = calc_sdr_impr_metric(
ref_sp, ref_mus, mix, sig_out)
print(base_name)
print(
"sdr_impr, sir_impr, sar_impr = {}, {}, {}, sdr_base, sir_base, sar_base = {}, {}, {}\n"
.format(sdr_impr, sir_impr, sar_impr, sdr_base, sir_base, sar_base))
print('---------------------------------------------')
def params_iterate():
base_name = 'out_mus1_spk1_snr_-10'
#base_name = 'out_wgn_spk_snr_-10'
config = cfg.ConfigParser()
config.read(os.path.join(r'./data/_sdr_test', base_name, 'config.cfg'))
in_Main = r'./data/_sdr_test/' + base_name + r'/ds_mix.wav'
in_Main_Sp = r'./data/_sdr_test/' + base_name + r'/ds_spk.wav'
in_Main_Mus = r'./data/_sdr_test/' + base_name + r'/ds_mus.wav'
# #################################################################
# 1.0 - read PROFILE
vert_mic_count = int(config['MIC_CFG']['vert_mic_count'])
hor_mic_count = int(config['MIC_CFG']['hor_mic_count'])
dHor = float(config['MIC_CFG']['dhor'])
dVert = float(config['MIC_CFG']['dvert'])
max_len_sec = int(config['MIC_CFG']['max_len_sec'])
n_fft = int(config['MIC_CFG']['fft_size'])
angle_h = -float(config['FILTER_CFG']['angle_h'])
angle_v = -float(config['FILTER_CFG']['angle_v'])
angle_inf_h = -float(config['FILTER_CFG']['angle_inf_h'])
angle_inf_v = -float(config['FILTER_CFG']['angle_inf_v'])
in_wav_path = r'./data/_sdr_test/' + base_name + r'/mix'
out_wav_path = r'./data/out/'
_mix_start = float(config['FILTER_CFG']['start_mix_time'])
_mix_end = 30
#################################################################
#################################################################
# 1.0 - Read signal
x_all_arr, sr = read_mic_wav_from_folder(in_wav_path,
vert_mic_count,
hor_mic_count,
max_len_sec=max_len_sec)
ref_sp, _ = sf.read(in_Main_Sp)
ref_mus, _ = sf.read(in_Main_Mus)
mix, _ = sf.read(in_Main)
x_all_arr = x_all_arr[:, (np.int32)(_mix_start * sr):(np.int32)(_mix_end *
sr)]
ref_sp = ref_sp[:(np.int32)((_mix_end - _mix_start) * sr)]
ref_mus = ref_mus[:(np.int32)((_mix_end - _mix_start) * sr)]
mix = mix[(np.int32)(_mix_start * sr):(np.int32)(_mix_end * sr)]
(n_channels, n_samples) = x_all_arr.shape
print("Array data read done!")
print(" n_channels = ", n_channels)
print(" n_samples = ", n_samples)
print(" freq = ", sr)
#################################################################
# 2 - Do STFT
stft_all = stft_arr(x_all_arr, fftsize=n_fft)
(n_bins, n_sensors, n_frames) = stft_all.shape
print("STFT calc done!")
print(" n_bins = ", n_bins)
print(" n_sensors = ", n_sensors)
print(" n_frames = ", n_frames)
#################################################################
# 3 - Calc steering vector
print('Calc steering vector!')
print(' (angle_h, angle_v) = ', angle_h, angle_v)
print(' (angle_inf_h, angle_inf_v) = ', angle_inf_h, angle_inf_v)
sensor_positions = get_sensor_positions(hor_mic_count,
vert_mic_count,
dHor=dHor,
dVert=dVert)
source_position = get_source_position(angle_h, angle_v, radius=6.0)
source_position_inf = get_source_position(angle_inf_h,
angle_inf_v,
radius=6.0)
d_arr = propagation_vector_free_field(sensor_positions,
source_position,
N_fft=n_fft,
F_s=sr)
d_arr_inf = propagation_vector_free_field(sensor_positions,
source_position_inf,
N_fft=n_fft,
F_s=sr)
#################################################################
# 4 - Calc DS beamforming in desired and noise direction
result_spec = ds_beamforming(stft_all, d_arr.T)
result_spec_inf = ds_beamforming(stft_all, d_arr_inf.T)
#################################################################
# 5 - ISTFT
sig_sp = istft(result_spec.transpose((1, 0)), overlap=2)
sig_inf = istft(result_spec_inf.transpose((1, 0)), overlap=2)
sf.write(r"out/out_ds_sp.wav", sig_sp, sr)
sf.write(r"out/out_ds_inf.wav", sig_inf, sr)
#################################################################
# 6.1 - AP filter + cyclic parameters
# M = 200
# step = 0.05
# L = 5
# leak = 0.0
# delay = -5
params = [
#(150, 0.005, 5, 0.001, 0),
(150, 0.005, 5, 0.001, 0),
(200, 0.05, 5, 0.001, 0),
]
for (M, step, L, leak, delay) in params:
print("process M = {}, step = {}, L = {}, leak = {}, delay = {}".
format(M, step, L, leak, delay))
sig_inf = np.roll(sig_inf, delay)
sig_result = affine_projection_filter(main=sig_sp,
ref=sig_inf,
M=M,
step=step,
L=L,
leak=leak)
sf.write(
r"out/out_ap_null_M_{}_step_{}_L_{}_leak_{}_delay_{}.wav".format(
M, step, L, leak, delay), sig_result, sr)
sdr_impr, sir_impr, sar_impr, sdr_base, sir_base, sar_base = calc_sdr_impr_metric(
ref_sp, ref_mus, mix, sig_result)
print(base_name)
print(
"sdr_impr, sir_impr, sar_impr = {}, {}, {}, sdr_base, sir_base, sar_base = {}, {}, {}\n"
.format(sdr_impr, sir_impr, sar_impr, sdr_base, sir_base,
sar_base))
print('---------------------------------------------')
weights = np.load(
r'./mic_utils/room_simulation\room_simulation_Gleb\weights14.npy')
n_iter = 15
n_comp = 2
res = ilrma(stft_all_arr_ilrma,
n_iter=n_iter,
n_components=n_comp,
W0=weights)
entr = np.zeros(res.shape[-1])
for i in range(res.shape[-1]):
for j in range(res.shape[1]):
entr[i] += entropy(np.real(res[:, j, i] * np.conj(res[:, j, i])))
resulting_sig = istft(res[:, :, np.argmin(entr)], overlap=2)
# def demix(X, W):
# Y = np.zeros(X.shape, dtype=X.dtype)
# for f in range(X.shape[1]):
# Y[:,f,:] = np.dot(X[:,f,:], np.conj(W[f,:,:]))
# return Y
#
# Y = demix(stft_all_arr_ilrma, weights)
# resulting_sig = istft(Y[:,:,8], overlap=2)
# sf.write(r'./out/Simulation/MVDR+ILRMA/test.wav', resulting_sig, sr)
# 3.0 Calculate average amd make a mask
def double_exp_average(X,
source_position,
N_fft=n_fft,
F_s=sr)
d_arr_inf = propagation_vector_free_field(sensor_positions,
source_position_inf,
N_fft=n_fft,
F_s=sr)
#################################################################
# 4 - Calc RTF steering vector
print('Calc RTF steering vector!')
#result_spec_rtf = rtf_filter(stft_mix, stft_chirp_sp_arr, 'simple')
result_spec_rtf = rtf_filter(stft_mix, stft_chirp_noise_arr, 'simple')
#################################################################
# 5 - Do DS beamforming
result_sp = ds_beamforming(stft_mix, d_arr.T)
result_noise = ds_beamforming(stft_mix, d_arr_inf.T)
#################################################################
# 5 - Write result
sig_out = istft(result_spec_rtf.transpose((1, 0)), overlap=n_overlap)
sf.write(r"out/out_DS_rtf.wav", sig_out, sr)
sig_out = istft(result_sp.transpose((1, 0)), overlap=n_overlap)
sf.write(r"out/out_DS_sp.wav", sig_out, sr)
sig_out = istft(result_noise.transpose((1, 0)), overlap=n_overlap)
sf.write(r"out/out_DS_noise.wav", sig_out, sr)
def ds_respk():
# # #################################################################
# # 1.0 - simulation showroom, wgn WBN_16000hz
# n_fft = 512
# n_overlap = 2
#
# intermic_distance = 0.0457
# mic_count = 4
# in_wav_path = r'./data/_sim_shoroom/WBN_16000hz/4mic_output.wav'
# out_wav_path = r'./data/out/'
# _chirp_noise_start = 0
# _chirp_noise_end = 59
# _mix_start = 0
# _mix_end = 59
# angle_azimuth = 150.0
# #################################################################
# 1.0 - simulation showroom, wgn 2800_3800
n_fft = 512
n_overlap = 2
intermic_distance = 0.0457
mic_count = 4
#in_wav_path = r'./data/_sim_shoroom/WBN_2800_3800/4mic_output.wav'
in_wav_path = r'./data/_sim_shoroom/WBN_2800_3800/4mic_output_reflection_0.wav'
out_wav_path = r'./data/out/'
_chirp_noise_start = 0
_chirp_noise_end = 59
_mix_start = 0
_mix_end = 59
angle_azimuth = 0.0
# # #################################################################
# # 1.0 - stc-h873 ex2
# n_fft = 512
# n_overlap = 2
#
# intermic_distance = 0.05
# mic_count = 2
# in_wav_path = r'./data/_re_spk_ex2/stc-h873.wav'
# out_wav_path = r'./data/out/'
# _chirp_noise_start = 47
# _chirp_noise_end = 60 + 3
# _mix_start = 60 + 9
# _mix_end = 3*60 + 31
# angle_azimuth = 0.0
# # #################################################################
# # 1.0 - respeaker_mic_array ex2
# n_fft = 512
# n_overlap = 2
#
# intermic_distance = 0.0457
# mic_count = 4
# in_wav_path = r'./data/_re_spk_ex2/respeaker_mic_array.wav'
# out_wav_path = r'./data/out/'
# _chirp_noise_start = 40
# _chirp_noise_end = 56
# _mix_start = 60
# _mix_end = 3*60 + 22
# angle_azimuth = -50.0
# # #################################################################
# # 1.0 - respeaker_core_v2 ex2
# n_fft = 512
# n_overlap = 2
#
# intermic_distance = 0.0463
# mic_count = 6
# in_wav_path = r'./data/_re_spk_ex2/respeaker_core_v2.wav'
# out_wav_path = r'./data/out/'
# _chirp_noise_start = 52
# _chirp_noise_end = 69
# _mix_start = 70
# _mix_end = 3*60 + 35
# angle_azimuth = 30.0
# # #################################################################
# # 1.0 - respeaker_core_v2 ex1
# n_fft = 512
# n_overlap = 2
#
# intermic_distance = 0.0463
# mic_count = 6
# in_wav_path = r'./data/_re_spk_ex1/respeaker_core_v2.wav'
# out_wav_path = r'./data/out/'
# _chirp_noise_start = 15
# _chirp_noise_end = 60 + 48
# _mix_start = 10
# _mix_end = 15
# angle_azimuth = 30.0
# # #################################################################
# # 1.0 - respeaker_mic_array ex1
# n_fft = 512
# n_overlap = 2
#
# intermic_distance = 0.0457
# mic_count = 4
# in_wav_path = r'./data/_re_spk_ex2/respeaker_mic_array.wav'
# out_wav_path = r'./data/out/'
# _chirp_noise_start = 38
# _chirp_noise_end = 56
# _mix_start = 38
# _mix_end = 56
# angle_azimuth = -50.0
#################################################################
# 1.0 - Read signal
x_all_arr, sr = read_mic_wav_from_file(in_wav_path, mic_count)
(n_channels, n_samples) = x_all_arr.shape
print("Array data read done!")
print(" n_channels = ", n_channels)
print(" n_samples = ", n_samples)
print(" freq = ", sr)
x_chirp_noise_arr = x_all_arr[:,
(np.int32)(_chirp_noise_start *
sr):(np.int32)(_chirp_noise_end *
sr)]
x_mix_arr = x_all_arr[:, (np.int32)(_mix_start * sr):(np.int32)(_mix_end *
sr)]
#################################################################
# 2 - Do STFT
stft_mix = stft_arr(x_mix_arr, fftsize=n_fft, overlap=n_overlap)
stft_chirp_noise_arr = stft_arr(x_chirp_noise_arr,
fftsize=n_fft,
overlap=n_overlap)
(n_bins, n_sensors, n_frames) = stft_mix.shape
print("STFT calc done!")
print(" n_bins = ", n_bins)
print(" n_sensors = ", n_sensors)
print(" n_frames = ", n_frames)
#################################################################
# 3 - Plot DN
angle_step = 1
print("Begin steering calc ...")
arr_angle = range(-180, 180, angle_step)
arr_d_arr = np.zeros((len(arr_angle), n_sensors, n_bins), dtype=np.complex)
print('arr_d_arr = ', arr_d_arr.shape)
for i, angle in enumerate(arr_angle):
sensor_positions = get_sensor_positions_respeaker(
intermic_distance, mic_count)
source_position = get_source_position_respeaker(azimuth=angle,
polar=90)
arr_d_arr[i, :, :] = propagation_vector_free_field(sensor_positions,
source_position,
N_fft=n_fft,
F_s=sr)
print("Steering calc done!")
#################################################################
# 4 - Calc map
POW = np.zeros((len(arr_angle)))
print("Begin calc map ...")
for i, angle_h in enumerate(arr_angle):
print(" process angle = {}".format(angle_h))
d_arr = arr_d_arr[i, :, :]
# DS beamforming
result_spec = ds_beamforming(stft_chirp_noise_arr, d_arr.T)
POW[i] = np.real(
np.sum(result_spec * np.conjugate(result_spec)) / n_frames)
print("Calc map done!")
#################################################################
# 5 - Scale to power ch_0_0
P0 = np.sum(stft_chirp_noise_arr[:, 0, :] *
np.conjugate(stft_chirp_noise_arr[:, 0, :])) / n_frames
POW = POW / P0
#################################################################
# 6 - Plot DN
plt.plot(arr_angle, POW)
plt.xlabel('angle (s)')
plt.ylabel('pow_res/pow_s0')
plt.title('DS alg')
plt.grid(True)
plt.savefig(r".\out\DS_mic{}.png".format(mic_count))
plt.show()
#################################################################
# 7 - Do DS beamforming
print('Calc steering vector!')
print(' (angle_azimuth) = ', angle_azimuth)
sensor_positions = get_sensor_positions_respeaker(intermic_distance,
mic_count)
source_position = get_source_position_respeaker(azimuth=angle_azimuth,
polar=90)
d_arr = propagation_vector_free_field(sensor_positions,
source_position,
N_fft=n_fft,
F_s=sr)
#################################################################
# 4 - Calc DS filter output
result_spec = ds_beamforming(stft_mix, d_arr.T)
print('Calc RTF steering vector!')
result_spec_rtf = rtf_filter(stft_mix, stft_chirp_noise_arr, 'simple')
#################################################################
# 5 inverse STFT and save
sig_out = istft(result_spec.transpose((1, 0)), overlap=n_overlap)
sf.write(r"out/out_DS.wav", sig_out, sr)
sig_out = istft(result_spec_rtf.transpose((1, 0)), overlap=n_overlap)
sf.write(r"out/out_DS_rtf.wav", sig_out, sr)
print(' (angle_h, angle_v) = ', angle_h, angle_v)
sensor_positions = get_sensor_positions(hor_mic_count,
vert_mic_count,
dHor=dHor,
dVert=dVert)
source_position = get_source_position(angle_h, angle_v, radius=6.0)
d_arr = propagation_vector_free_field(sensor_positions,
source_position,
N_fft=n_fft,
F_s=sr)
# 4 - DS filter
result_spec = ds_beamforming(stft_mix, d_arr.T)
# 5 - inverse STFT and save
sig_out = istft(result_spec.transpose((1, 0)), overlap=2)
out_ds_path = r'{}/tmp_ds.wav'.format(os.path.dirname(out_wav_path))
sf.write(out_ds_path, sig_out, sr)
# 6 - get noise mask
print('Get noise mask form neural net!')
# shape - (time, freq, 2)
config_path = r'/home/stc/MA_ALG/datasets/test_ma/' \
r'chimera_v12/9_chimera.json'
in_model_path = r'/home/stc/MA_ALG/datasets/test_ma/chimera_v12/checkpoint/'
frozen_model_path = r'/home/stc/MA_ALG/datasets/test_ma/chimera_frozen/model_chimera_v11.pb'
mask = ChimeraPredictFrozen(frozen_model_path).predict_mask(out_ds_path)
def do_ds():
#################################################################
# 1.0 - out_mus1_spk1_snr_-10 PROFILE
vert_mic_count = 6
hor_mic_count = 11
dHor = 0.035
dVert = 0.05
max_len_sec = 60
n_fft = 512
# (angle_hor_log, angle_vert_log) = (7.1539, 7.39515)
(angle_hor_log, angle_vert_log) = (-16.0721, -0.163439)
angle_h = -angle_hor_log
angle_v = -angle_vert_log
_mix_start = 10
_mix_end = 50
in_wav_path = r'./data/_sdr_test/out_mus1_spk1_snr_-15/mix/'
out_wav_path = r'./data/out/'
#################################################################
#################################################################
# 1.0 - Read signal
x_all_arr, sr = read_mic_wav_from_folder(in_wav_path,
vert_mic_count,
hor_mic_count,
max_len_sec=max_len_sec)
x_all_arr = x_all_arr[:, (np.int32)(_mix_start * sr):(np.int32)(_mix_end *
sr)]
(n_channels, n_samples) = x_all_arr.shape
print("Array data read done!")
print(" n_channels = ", n_channels)
print(" n_samples = ", n_samples)
print(" freq = ", sr)
#################################################################
# 2 - Do STFT
stft_all = stft_arr(x_all_arr, fftsize=n_fft)
(n_bins, n_sensors, n_frames) = stft_all.shape
print("STFT calc done!")
print(" n_bins = ", n_bins)
print(" n_sensors = ", n_sensors)
print(" n_frames = ", n_frames)
#################################################################
# 3 - Calc steering vector
print('Calc steering vector!')
print(' (angle_h, angle_v) = ', angle_h, angle_v)
sensor_positions = get_sensor_positions(hor_mic_count,
vert_mic_count,
dHor=dHor,
dVert=dVert)
source_position = get_source_position(angle_h, angle_v, radius=6.0)
d_arr = propagation_vector_free_field(sensor_positions,
source_position,
N_fft=n_fft,
F_s=sr)
#################################################################
# 4 - Calc DS filter output
result_spec = ds_beamforming(stft_all, d_arr.T)
#################################################################
# 5 inverse STFT and save
sig_out = istft(result_spec.transpose((1, 0)), overlap=2)
sf.write(r"out/out_DS.wav", sig_out, sr)
def main2():
X_wav_path = r'./out/ADAPT_SAD/SNR_-8/out_DS_mix_sp.wav'
N_ideal_wav_path = r'./out/ADAPT_SAD/SNR_-8/out_DS_mus_sp.wav'
N_wav_path = r'./out/ADAPT_SAD/SNR_-8/out_DS_mix_mus.wav'
# N_wav_path = r'./out/ADAPT_SAD/SNR_-8/out_DS_mus_sp.wav'
# N_wav_path = r'./out/ADAPT_SAD/SNR_-8/out_DS_mix_mus.wav'
OUT_wav_path = r'./out/ADAPT_SAD/SNR_-8/_result.wav'
n_fft = 512
overlap = 2
####################################################
# 1 - Load signal
X_sig, rate = sf.read(X_wav_path)
N_ideal_sig, rate = sf.read(N_ideal_wav_path)
N_sig, rate = sf.read(N_wav_path)
# X_sig = np.roll(X_sig, -10)
X_spec = stft(X_sig, fftsize=n_fft, overlap=overlap)
N_spec = stft(N_sig, fftsize=n_fft, overlap=overlap)
N_ideal_spec = stft(N_ideal_sig, fftsize=n_fft, overlap=overlap)
n_frames, b_bins = X_spec.shape
start = time.time()
#OUT = spectral_substract_filter(stft_main=X_spec, stft_ref=N_spec, alfa_PX=0.001, alfa_PN=0.00199199)
#OUT = compensate_ref_ch_filter(stft_main=X_spec, stft_ref=N_spec, alfa=0.75)
#OUT = compensate_ref_ch_filter_ex(stft_main=X_spec, stft_ref=N_spec, alfa=.0075, beta=0.95)
OUT = smb_filter(stft_main=X_spec, stft_ref=N_spec, gain_max=18)
# 6.1 - AP filter + cyclic parameters
M = 200
step = 0.05
L = 5
leak = 0.1
delay = -5
# AP filter
#sig_result = affine_projection_filter(main=X_sig, ref=N_sig, M=M, step=step, L=L, leak=leak)
end = time.time()
print("Elapsed (with compilation) = %s" % (end - start))
################################################
start = time.time()
for g in range(1, 28):
OUT = smb_filter(stft_main=X_spec, stft_ref=N_spec, gain_max=g)
end = time.time()
print("Elapsed (with compilation) = %s" % (end - start))
################################################
# NLMS
#sig_result = lms_filter(main=X_sig, ref=N_sig, M=M, step=step, leak=leak, norm=True)
# LMS
#sig_result = lms_filter(main=X_sig, ref=N_sig, M=M, step=step, leak=leak, norm=False)
# ####################################################
# # 4 - Plot
# n_bin = 50
# T = np.arange(0, n_frames) * (n_fft/overlap) / rate
# E1 = np.abs(X_spec)[:, n_bin]
# E2 = np.abs(N_ideal_spec)[:, n_bin]
# E3 = np.abs(est_noise)[:, n_bin]
#
# plt.plot(T, E1,'r--', T, E2,'b', T, E3,'g')
# plt.show()
# ####################################################
#
# X_sig
# plt.plot(T, E1,'r--', T, E2,'b', T, E3,'g')
# plt.show()
sig_out = istft(OUT, overlap=overlap)
#sig_out = sig_result
sf.write(OUT_wav_path, sig_out, rate)
psd_noise_matrix.shape[-1])
w = get_mvdr_vector(d_arr.T, psd_noise_matrix)
#################################################################
# 4 - Calc filter output
result_spec = cov_matrix_tracking(stft_noise,
stft_mix,
w * mic_count,
filter_type='blocking_matrix')
#################################################################
# 5 - Do align
align_stft_arr = ds_align(stft_mix, d_arr.T)
print('Align mix_arr done!')
#################################################################
# 6 - Calc zelin filter output
result_spec_, H = zelin_filter(stft_arr=align_stft_arr,
alfa=0.7,
alg_type=0)
print('Calc zelin filter output done!')
#################################################################
# 7 - Calc tracking + Zelin filter output
result_spec = result_spec * H
#################################################################
# 8 inverse STFT and save
sig_out = istft(result_spec.T, overlap=2)
sf.write(r"out/out_cov_matrix_tracking_zelin.wav", sig_out, sr)
axis=-1)
weights = np.load(
r'./mic_utils/room_simulation\room_simulation_Gleb\weights14.npy')
res = ilrma(stft_all_arr_ilrma,
n_iter=15,
n_components=2,
W0=weights,
seed=0)
entr = np.zeros(res.shape[-1])
for i in range(res.shape[-1]):
for j in range(res.shape[1]):
entr[i] += entropy(np.real(res[:, j, i] * np.conj(res[:, j, i])))
resulting_sig = istft(res[:, :, np.argmin(entr)], overlap=2)
sf.write(r'./out/simulation/res_sig.wav', resulting_sig, sr)
average_sig = double_exp_average(resulting_sig, sr)
average_sig[-300:] = average_sig[-300]
average_sig[:300] = average_sig[300]
mask = make_mask(average_sig, percent_threshold=100)
mask_frames = mask_to_frames(mask, int(n_fft), int(n_fft / 2))
# plt.plot(mask_frames)
# plt.show()
print('Mask is ready!')
def ds_respk():
# #################################################################
# 1.0 - AMI dataset small session
n_fft = 512
n_overlap = 2
r_circular_array = 0.1
mic_count = 8
in_wav_path = r'./data/_ami_data'
out_wav_path = r'./data/out/'
_mix_start = 15.0
_mix_end = 22.0
angle_azimuth = 64.0
#################################################################
# 1.0 - Read signal
x_all_arr, sr = read_mic_wav_from_path(in_wav_path, mic_count)
(n_channels, n_samples) = x_all_arr.shape
print("Array data read done!")
print(" n_channels = ", n_channels)
print(" n_samples = ", n_samples)
print(" freq = ", sr)
x_mix_arr = x_all_arr[:, (np.int32)(_mix_start * sr):(np.int32)(_mix_end *
sr)]
#################################################################
# 2 - Do STFT
stft_mix = stft_arr(x_mix_arr, fftsize=n_fft, overlap=n_overlap)
(n_bins, n_sensors, n_frames) = stft_mix.shape
print("STFT calc done!")
print(" n_bins = ", n_bins)
print(" n_sensors = ", n_sensors)
print(" n_frames = ", n_frames)
#################################################################
# 3 - Plot DN
angle_step = 1
print("Begin steering calc ...")
arr_angle = range(-180, 180, angle_step)
arr_d_arr = np.zeros((len(arr_angle), n_sensors, n_bins), dtype=np.complex)
print('arr_d_arr = ', arr_d_arr.shape)
for i, angle in enumerate(arr_angle):
sensor_positions = get_sensor_positions_circular(
r_circular_array, mic_count)
source_position = get_source_position_circular(azimuth=angle,
polar=90.0)
arr_d_arr[i, :, :] = propagation_vector_free_field(sensor_positions,
source_position,
N_fft=n_fft,
F_s=sr)
print("Steering calc done!")
#################################################################
# 4 - Calc map
POW = np.zeros((len(arr_angle)))
print("Begin calc map ...")
for i, angle_h in enumerate(arr_angle):
print(" process angle = {}".format(angle_h))
d_arr = arr_d_arr[i, :, :]
# DS beamforming
result_spec = ds_beamforming(stft_mix, d_arr.T)
POW[i] = np.real(
np.sum(result_spec * np.conjugate(result_spec)) / n_frames)
print("Calc map done!")
#################################################################
# 5 - Scale to power ch_0_0
P0 = np.sum(stft_mix[:, 0, :] * np.conjugate(stft_mix[:, 0, :])) / n_frames
POW = POW / P0
#################################################################
# 6 - Plot DN
plt.plot(arr_angle, POW)
plt.xlabel('angle (s)')
plt.ylabel('pow_res/pow_s0')
plt.title('DS alg')
plt.grid(True)
plt.savefig(r".\out\DS_mic{}.png".format(mic_count))
plt.show()
#################################################################
# 7 - Do DS beamforming
print('Calc DS beamforming!')
print(' (angle_azimuth) = ', angle_azimuth)
sensor_positions = get_sensor_positions_circular(r_circular_array,
mic_count)
source_position = get_source_position_circular(azimuth=angle_azimuth,
polar=90.0)
d_arr = propagation_vector_free_field(sensor_positions,
source_position,
N_fft=n_fft,
F_s=sr)
#################################################################
# 4 - Calc DS filter output
result_spec = ds_beamforming(stft_mix, d_arr.T)
#################################################################
# 5 inverse STFT and save
sig_out = istft(result_spec.transpose((1, 0)), overlap=n_overlap)
sf.write(r"out/out_DS_{}.wav".format(angle_azimuth), sig_out, sr)
print("STFT calc done!")
print(" n_bins = ", n_bins)
print(" n_sensors = ", n_sensors)
print(" stft_noise_arr.shape = ", stft_noise_arr.shape)
print(" stft_mix.shape = ", stft_mix.shape)
print(" stft_sp_arr.shape = ", stft_sp_arr.shape)
#################################################################
print('Calc steering vector!')
print(' (angle_h, angle_v) = ', angle_h, angle_v)
sensor_positions = get_sensor_positions(hor_mic_count,
vert_mic_count,
dHor=dHor,
dVert=dVert)
source_position = get_source_position(angle_h, angle_v)
d_arr = propagation_vector_free_field(sensor_positions,
source_position,
N_fft=n_fft,
F_s=sr)
psd = get_power_spectral_density_matrix(stft_mix)
psd = psd + 0.001 * np.identity(psd.shape[-1])
w = get_mvdr_vector(d_arr.T, psd)
result_mvdr_spec = apply_beamforming_vector(w, stft_mix)
sig_out = istft(result_mvdr_spec.transpose((1, 0)), overlap=4)
sf.write(r"out/out_mvdr_mix.wav", sig_out, sr)
def main():
# #################################################################
# # 1.0 - LANDA PROFILE
# vert_mic_count = 1
# hor_mic_count = 8
# dHor = 0.05
# dVert = 0.05
# max_len_sec = 60
# n_fft = 512
# n_overlap = 2
#
# (angle_hor_log, angle_vert_log) = (16.0, 0.0)
# angle_h = -angle_hor_log
# angle_v = -angle_vert_log
#
# _mix_start = 17
# _mix_end = 40
#
# in_wav_path = r'./data/_landa/'
# out_wav_path = r'./data/out/'
# #################################################################
#################################################################
# 1.0 - _du_hast PROFILE
#vert_mic_count = 6
#hor_mic_count = 11
vert_mic_count = 1
hor_mic_count = 11
dHor = 0.035
dVert = 0.05
max_len_sec = 45
n_fft = 512
n_overlap = 2
(angle_hor_log, angle_vert_log) = (12.051, 5.88161)
angle_h = -angle_hor_log
angle_v = -angle_vert_log
_mix_start = 17
_mix_end = 40
in_wav_path = r'./data/_du_hast/'
out_wav_path = r'./data/out/'
#################################################################
#################################################################
# 1.0 - Read signal
x_all_arr, sr = read_mic_wav_from_folder(in_wav_path,
vert_mic_count,
hor_mic_count,
max_len_sec=max_len_sec)
x_all_arr = x_all_arr[:, (np.int32)(_mix_start * sr):(np.int32)(_mix_end *
sr)]
(n_channels, n_samples) = x_all_arr.shape
print("Array data read done!")
print(" n_channels = ", n_channels)
print(" n_samples = ", n_samples)
print(" freq = ", sr)
#################################################################
# 2 - Do STFT
stft_all = stft_arr(x_all_arr, fftsize=n_fft, overlap=n_overlap)
(n_bins, n_sensors, n_frames) = stft_all.shape
print("STFT calc done!")
print(" n_bins = ", n_bins)
print(" n_sensors = ", n_sensors)
print(" n_frames = ", n_frames)
#################################################################
# 3 - Calc steering vector
print('Calc steering vector!')
print(' (angle_h, angle_v) = ', angle_h, angle_v)
sensor_positions = get_sensor_positions(hor_mic_count,
vert_mic_count,
dHor=dHor,
dVert=dVert)
source_position = get_source_position(angle_h, angle_v, radius=6.0)
d_arr = propagation_vector_free_field(sensor_positions,
source_position,
N_fft=n_fft,
F_s=sr)
#################################################################
# Reshape to (nframes, nfrequencies, nchannels)
M_spec = stft_all.transpose((2, 0, 1))
def callback_fn(X):
print(' invoke callback_fn')
# #(nfrequencies, nchannels, nchannels)
# W = np.array([np.eye(n_sensors, n_sensors) for f in range(n_bins)], dtype=M_spec.dtype)
# for i in range(n_bins):
# W[i, : , 0 ] = d_arr[:, i]/8.0
# Y = np.zeros((n_frames, n_bins, n_sensors), dtype=M_spec.dtype)
# def demix(Y, X, W):
# for f in range(n_bins):
# Y[:,f,:] = np.dot(X[:,f,:], np.conj(W[f,:,:]))
# demix(Y, M_spec, W)
# # IVA Demix
Y = pyroomacoustics.bss.auxiva(M_spec,
n_iter=20,
proj_back=True,
callback=callback_fn)
# Save result
for i in range(Y.shape[2]):
sig_out = istft(Y[:, :, i], overlap=n_overlap)
sf.write(r'out/iva_res_{}.wav'.format(i), sig_out, sr)
def main():
seg_path = r'./out/ADAPT_SAD/ds_spk.seg'
X_wav_path = r'./out/ADAPT_SAD/out_DS_sp.wav'
N_wav_path = r'./out/ADAPT_SAD/out_DS_inf.wav'
S_wav_path = r'./out/ADAPT_SAD/ds_spk.wav'
n_fft = 512
overlap = 256
####################################################
# 1 - Load signal
X_sig, rate = sf.read(X_wav_path)
N_sig, rate = sf.read(N_wav_path)
S_sig, rate = sf.read(S_wav_path)
####################################################
# 2 - SFFT signal
X_spec = stft(X_sig, fftsize=n_fft, overlap=2)
N_spec = stft(N_sig, fftsize=n_fft, overlap=2)
S_spec = stft(S_sig, fftsize=n_fft, overlap=2)
(n_frames, n_bins) = X_spec.shape
assert X_spec.shape == N_spec.shape and X_spec.shape == S_spec.shape, 'X_spec.shape == N_spec.shape and X_spec.shape == S_spec.shape'
print('X_spec.shape = ', X_spec.shape)
print('N_spec.shape = ', N_spec.shape)
print('S_spec.shape = ', S_spec.shape)
####################################################
# 3 - Read true time segmentation
count_frames = X_spec.shape[0]
true_time_segm, freq = read_seg_file_pause(seg_file=seg_path)
true_frame_segm = convert_time_segm_to_frame_segm(
time_seg=true_time_segm,
count_frames=count_frames,
fs=freq,
overlap=overlap)
true_frame_segm = 1 - true_frame_segm
####################################################
# 4 - Plot
T = np.arange(0, n_frames) * overlap / rate
E = np.sum(np.abs(X_spec), axis=1)
E = E / np.max(E)
plt.plot(T, E, T, true_frame_segm)
plt.show()
####################################################
# Filter signal
# S_spec = spectral_substract_filter(stft_main= X_spec , stft_ref= N_spec, alfa_PX = 0.01, alfa_PN = 0.99)
# S_spec = smb_filter(stft_main=X_spec, stft_ref=N_spec, gain_max=18)
####################################################
# ISFFT signal and write result
sig_out = istft(S_spec, overlap=2)
sf.write(r'./out/ADAPT_SAD/_result.wav', sig_out, rate)
####################################################
# initialize the filter
rls = pyroomacoustics.adaptive.RLS(30)
# run the filter on a stream of samples
for i in range(100):
rls.update(X_sig[i], N_sig[i])
# the reconstructed filter is available
print('Reconstructed filter:', rls.w)
# plt.imshow(show_mask[0,:,:])
# plt.xlabel('Time')
# plt.ylabel('Freq')
#
# plt.subplot(312)
# plt.imshow(show_mask[1,:,:])
# plt.xlabel('Time')
# plt.ylabel('Freq')
#
# plt.subplot(313)
# plt.imshow(spec_ch_0_0)
# plt.xlabel('Time')
# plt.ylabel('Freq')
#
# plt.show()
#################################################################
# 4 - Save result
result_spec = np.zeros((2, n_bins, n_frames), dtype=np.complex)
for k in range(2):
for f in range(n_bins):
for t in range(n_frames):
result_spec[k, f, t] = stft_all[f, 0, t] * perm_mask[k, f, t]
#result_spec[k, f, t] = stft_all[f, 0, t] * mask[k, f, t]
for k in range(2):
sig_out = istft(result_spec[k, :, :].T, overlap=2)
sf.write(r"out/out_CGMM_" + str(k) + ".wav", sig_out, sr)
spec_sp = ds_beamforming(stft_all, d_arr.T)
spec_inf = ds_beamforming(stft_all, d_arr_inf.T)
gain_correction = np.zeros((n_bins), dtype=np.complex)
for i in range(n_bins):
d1 = d_arr[:, i]
d2 = d_arr_inf[:, i]
eq_i = np.dot(np.conj(d2), d1)
gain_correction[i] = eq_i / n_sensors
spec_corr_inf = np.expand_dims(gain_correction, axis=1) * spec_inf
#result_spec = spectral_substract_filter(stft_main=spec_sp, stft_ref=spec_inf, alfa_PX=0.01, alfa_PN=0.099)
result_spec = spectral_substract_filter(stft_main=spec_sp,
stft_ref=spec_corr_inf,
alfa_PX=0.01,
alfa_PN=0.099)
#result_spec = smb_filter(stft_main=spec_sp, stft_ref=spec_corr_inf, gain_max=18)
sig_sp = istft(spec_sp.transpose((1, 0)), overlap=n_overlap)
sig_inf = istft(spec_inf.transpose((1, 0)), overlap=n_overlap)
sig_corr_inf = istft(spec_corr_inf.transpose((1, 0)), overlap=n_overlap)
sig_result = istft(result_spec.transpose((1, 0)), overlap=n_overlap)
sf.write(r"out/out_HARD_spk.wav", sig_sp, sr)
sf.write(r"out/out_HARD_inf.wav", sig_inf, sr)
sf.write(r"out/out_HARD_corr_inf.wav", sig_corr_inf, sr)
sf.write(r"out/out_HARD_result.wav", sig_result, sr)
psd_noise_matrix = get_power_spectral_density_matrix(stft_noise_arr)
print('Calc psd matrix done!')
print(' psd_noise_matrix.shape = ', psd_noise_matrix.shape)
#################################################################
# 6 - Apply MVDR
type_reg = 1
reg_p = 0.001
w = get_mvdr_vector_svd(d_arr.T,
psd_noise_matrix,
type_reg=type_reg,
r=reg_p)
result_spec = apply_beamforming_vector(w, stft_mix_arr)
#################################################################
# 6 inverse STFT and save
sig_out = istft(result_spec.transpose((1, 0)), overlap=2)
sf.write(r"out/out_mvdr_svd_type_{}_r_{}.wav".format(type_reg, reg_p),
sig_out, sr)
#################################################################
# 7.1 - Do align
align_stft_arr = ds_align(stft_mix_arr, d_arr.T)
#################################################################
# 7.2 save ds output
result_spec = align_stft_arr.sum(axis=1) / (hor_mic_count * vert_mic_count)
sig_out = istft(result_spec.transpose((1, 0)), overlap=2)
sf.write(r"out/ds.wav", sig_out, sr)
# f_ref = r'D:\REP\svn_MicArrAlgorithm2\MA_PY\out\out_GSC_Z.wav'
# f_out = r'out\out_MN_GSC_1.wav'
speech_distribution_coeff_path = r'mic_utils\alg_data\gg_params_freq_f_scale.npy'
#################################################################
# 1.0 - Read signal
y_main, sr = sf.read(f_main, dtype=np.float64)
y_ref, sr = sf.read(f_ref, dtype=np.float64)
#################################################################
# 2.0 - STFT signal
stft_main = stft(y_main, fftsize=512, overlap=2)
stft_ref = stft(y_ref, fftsize=512, overlap=2)
#################################################################
# 3.0 - Filter signal
#stft_out = maximize_kutrosis_filter(stft_main, stft_ref)
stft_out = maximize_negentropy_filter(
stft_main,
stft_ref,
speech_distribution_coeff_path=speech_distribution_coeff_path)
#################################################################
# 4.0 - ISFFT signal
sig_out = istft(stft_out, overlap=2)
#################################################################
# 5.0 - Write output
sf.write(f_out, sig_out, sr)
