def convolve_cycle(self, audio_frame):
'''
Processing each track of the frame using the scipy overlap and add convolution, but also performing overlap and on the whole
thing since we are processing the input by frames.
'''
# Setting up output arrays.
audio_left = np.zeros((self.tracks_num, self.frame_count + self.M_left - 1), dtype=self.input_array.dtype)
audio_right = np.zeros((self.tracks_num, self.frame_count + self.M_right - 1), dtype=self.input_array.dtype)
for i in range(audio_frame.shape[0]):
try:
audio_left[i] = ss.oaconvolve(audio_frame[i], self.IR_left[i], mode='full') + self.leftover_left[i]
audio_right[i] = ss.oaconvolve(audio_frame[i], self.IR_right[i], mode='full') + self.leftover_right[i]
except ValueError:
print(audio_frame[i].shape)
print(self.IR_left[i].shape)
# Saving last self.M - 1 elements for next cycle.
self.leftover_left = np.hstack((audio_left[:, self.frame_count:],
np.zeros((self.tracks_num, self.frame_count), dtype=self.input_array.dtype)))
self.leftover_right = np.hstack((audio_right[:, self.frame_count:],
np.zeros((self.tracks_num, self.frame_count), dtype=self.input_array.dtype)))
# Discarding last self.M - 1 elements.
audio_left = audio_left[:, :self.frame_count]
audio_right = audio_right[:, :self.frame_count]
return (audio_left, audio_right)
def add_room_response(spk, rir, early_energy=True, sr=16000):
"""
Convolute source signal with selected rirs
Args
spk: S
rir: N x R
Return
revb: N x S
"""
if spk.ndim != 1:
raise RuntimeError(f"Can not convolve rir with {spk.ndim}D signals")
S = spk.shape[-1]
# revb = [ss.fftconvolve(spk, r)[:S] for r in rir]
revb = ss.oaconvolve(spk[None, ...], rir)[..., :S]
revb = np.asarray(revb)
if early_energy:
rir_ch0 = rir[0]
rir_peak = np.argmax(rir_ch0)
rir_beg_idx = max(0, int(rir_peak - 0.001 * sr))
rir_end_idx = min(rir_ch0.size, int(rir_peak + 0.05 * sr))
early_rir = rir_ch0[rir_beg_idx:rir_end_idx]
early_rev = ss.oaconvolve(spk, early_rir)[:S]
return revb, np.mean(early_rev**2)
else:
return revb, np.mean(revb[0]**2)
def start_blocking_processing(self):
# Setting up output arrays.
audio_left = np.zeros((self.tracks_num, self.L + self.M_left - 1), dtype=self.input_array.dtype)
audio_right = np.zeros((self.tracks_num, self.L + self.M_right - 1), dtype=self.input_array.dtype)
# Processing each track of the frame using the scipy overlap and add convolution, but also performing overlap and on the whole thing since we are processing the input by frames.
for i in range(self.input_array.shape[0]):
audio_left[i] = ss.oaconvolve(self.input_array[i], self.IR_left[i], mode='full')
audio_right[i] = ss.oaconvolve(self.input_array[i], self.IR_right[i], mode='full')
# Saving last self.M - 1 elements for next cycle.
self.leftover_left = np.hstack(
(audio_left[:, self.L:], np.zeros((self.tracks_num, self.L), dtype=self.input_array.dtype)))
self.leftover_right = np.hstack(
(audio_right[:, self.L:], np.zeros((self.tracks_num, self.L), dtype=self.input_array.dtype)))
# Discarding last self.M - 1 elements.
audio_left = audio_left[:, :self.L]
audio_right = audio_right[:, :self.L]
# Mixing tracks.
audio_left = self.mixing_gain * np.sum(audio_left, axis=0)
audio_right = self.mixing_gain * np.sum(audio_right, axis=0)
# Preparing data to send to PyAudio.
out_data = np.empty((audio_left.size + audio_right.size), dtype=self.input_array.dtype)
# Odd elements are going to the left channel.
out_data[1::2] = audio_left
# Even elements are going to the right channel.
out_data[0::2] = audio_right
if self.save_output:
self.output_array = np.hstack((audio_left, audio_right))
def add_reverb(cln_wav, rir_wav, channels=8, predelay=50, sample_rate=16000):
"""
add reverberation
args:
cln_wav: L
rir_wav: L x C
rir_wav is always [Lr, C]
predelay is ms
return:
wav_tgt: L x C
"""
rir_len = rir_wav.shape[0]
wav_tgt = np.zeros([channels, cln_wav.shape[0] + rir_len - 1])
dt = np.argmax(rir_wav, 0).min()
et = dt + (predelay * sample_rate) // 1000
et_rir = rir_wav[:et]
wav_early_tgt = np.zeros(
[channels, cln_wav.shape[0] + et_rir.shape[0] - 1])
for i in range(channels):
wav_tgt[i] = sps.oaconvolve(cln_wav, rir_wav[:, i])
wav_early_tgt[i] = sps.oaconvolve(cln_wav, et_rir[:, i])
# L x C
wav_tgt = np.transpose(wav_tgt)
wav_tgt = wav_tgt[:cln_wav.shape[0]]
wav_early_tgt = np.transpose(wav_early_tgt)
wav_early_tgt = wav_early_tgt[:cln_wav.shape[0]]
return wav_tgt, wav_early_tgt
def morlet_wavelet(input_signal, dt=1, R=7, freq_interval=(), drawplot=1, eps=.0001, quick=False,COI = True):
Ns = len(input_signal)
try:
minf = max(freq_interval[0], R / (Ns * dt)) # avoid wavelets with COI longer than the signal
except:
minf = R / (Ns * dt)
try:
maxf = min(freq_interval[1], .5 / dt) # avoid wavelets above the Nyquist frequency
except:
maxf = .5 / dt
try:
Nf = freq_interval[2]
except:
Nf = int(np.ceil(np.log(maxf / minf) / np.log(1 / R + 1))) # make spacing aproximately equal to sigma f
alfa = (maxf / minf) ** (1 / Nf) - 1; # According to the expression achived by fn = ((1+1/R)^n)*f0 where 1/R = alfa
vf = ((1 + alfa) ** np.arange(0, Nf)) * minf;
result = np.zeros((Nf, Ns), dtype='complex')
# These for loops reaaally should be paralelied...
if quick:
for k in range(Nf):
result[k, :] = exp_filter(input_signal, vf[k], dt, R) # use the IIR filter exponetial wavelet instead of Morlet
else:
for k in range(Nf):
N = int(2 * R / vf[k] / dt) # Compute size of the wavelet
wave = sg.morlet(N, w=R, s=1, complete=0) / N * np.pi * 2 # Normalize de amplitude returned by sg.morlet
result[k, :] = sg.oaconvolve(input_signal, wave, mode='same')
if drawplot: # beautiful plots for matplotlib... too bad pyecog uses pyqtgraph! X'(
plot_wavelet(result, dt, R, (minf,maxf,Nf), eps, COI)
return result
def SpectralShiftFiltering(I1, I2, look_angles, ground_slope, opt_str):
"""
INPUT
I1: [Nr x Nc] baseband SLC
I2: [Nr x Nc] baseband SLC
look_angles: [Nr x Nc x 2] look angles associated with each SLC
ground_slope: [Nr x Nc] ground slope in range direction
opt_str.
dt: sampling interval
f0: central frequency
B: bandwidth
OUTPUT
I1_filt: [Nr x Nc] baseband spectral shift filtered SLC
I2_filt: [Nr x Nc] baseband spectral shift filtered SLC"""
# Spectral shift (Hz)
Df = opt_str.f0 * np.squeeze(np.diff(look_angles, axis=2)) / np.tan(np.mean(look_angles, axis=2) - ground_slope)
# Space-varying demodulation phases (half)
phi_half = np.pi * np.cumsum(Df * opt_str.dt, axis=0)
# Demodulation
I1_filt = I1 * np.exp(-1j * phi_half)
I2_filt = I2 * np.exp(1j * phi_half)
# Building filter
if not (hasattr(opt_str, "Nfilter")):
opt_str.Nfilter = int(np.round(I1.shape[0] / 4))
curr_filter = firwin(numtaps=opt_str.Nfilter, cutoff=opt_str.B * opt_str.dt)
curr_filter = curr_filter / np.sqrt(np.sum(np.abs(curr_filter) ** 2))
curr_filter = curr_filter.reshape(opt_str.Nfilter, 1)
# Filtering
I1_filt = oaconvolve(I1_filt, curr_filter, mode="same", axes=0)
I2_filt = oaconvolve(I2_filt, curr_filter, mode="same", axes=0)
# Back to baseband
I1_filt = I1_filt * np.exp(1j * phi_half)
I2_filt = I2_filt * np.exp(-1j * phi_half)
return I1_filt, I2_filt
def get_energy(x, win_size=100):
"""
get energy of signal at each index from a given window size
:param x: signal
:param win_size: length of window
:return: signal energy at each index
"""
temp = (x / np.max(np.abs(x)))**2
energy = signal.oaconvolve(temp, np.ones(win_size), mode='same') / win_size
return energy
def morlet_wavelet(input_signal,
dt=1,
R=7,
freq_interval=(),
progress_signal=None,
kill_switch=None):
if kill_switch is None:
kill_switch = [False]
print('morlet_wavelet called')
Ns = len(input_signal)
if len(freq_interval) > 0:
minf = max(freq_interval[0], R /
(Ns * dt)) # avoid wavelets with COI longer than the signal
else:
minf = R / (Ns * dt)
if len(freq_interval) > 1:
maxf = min(freq_interval[1],
.5 / dt) # avoid wavelets above the Nyquist frequency
else:
maxf = .5 / dt
if len(freq_interval) > 2:
Nf = freq_interval[2]
else:
Nf = int(np.ceil(
np.log(maxf / minf) /
np.log(1 / R + 1))) # make spacing aproximately equal to sigma f
alfa = (maxf / minf)**(
1 / Nf
) - 1 # According to the expression achived by fn = ((1+1/R)^n)*f0 where 1/R = alfa
vf = ((1 + alfa)**np.arange(0, Nf)) * minf
print(Nf, Ns)
result = np.zeros((Nf, Ns), dtype='complex')
for k in range(Nf):
if kill_switch[0]:
break
N = int(2 * R / vf[k] /
dt) # Compute size of the wavelet: 2 standard deviations
wave = sg.morlet(
N, w=R, s=1, complete=0
) / N * np.pi * 2 # Normalize de amplitude returned by sg.morlet
# result[k, :] = sg.fftconvolve(input_signal, wave, mode='same')
result[k, :] = sg.oaconvolve(input_signal, wave, mode='same')
if progress_signal is not None:
progress_signal.emit(int(100 * k / Nf))
mask = np.zeros(result.shape)
Nlist = (.5 * R / vf / dt).astype('int') # 3 sigma COI
for k in range(len(Nlist)):
mask[k, :Nlist[k]] = np.nan
mask[k, -Nlist[k]:] = np.nan
return (result, mask, vf, kill_switch)
def filter(self, x):
"""
convolve signal x with impulse response h
:param x: 1-D signal
:return: filtered signal
"""
assert (isinstance(x, np.ndarray)), 'x must be numpy array'
assert (x.ndim == 1), 'x must be one dimensional'
assert (len(x) >=
self.length), 'x must be at least as long as filter response'
return signal.oaconvolve(x, self.h, mode='same')
def add_reverb(cln_wav, rir_wav):
"""
Args:
:@param cln_wav: the clean wav
:@param rir_wav: the rir wav
Return:
:@param wav_tgt: the reverberant signal
"""
rir_wav = np.array(rir_wav)
rir_wav = rir_wav[:, np.newaxis]
wav_tgt = np.zeros([cln_wav.shape[0]+(len(rir_wav)-1), rir_wav.shape[1]])
for i in range(1):
wav_tgt[:, i] = ss.oaconvolve(cln_wav, rir_wav[:,i]/np.max(np.abs(rir_wav[:,i])))
return wav_tgt
def add_reverb(cln_wav, rir_wav, channels=8):
"""
add reverberation
args:
cln_wav: L
rir_wav: L x C
rir_wav is always [Lr, C]
return:
wav_tgt: L x C
"""
rir_len = rir_wav.shape[0]
wav_tgt = np.zeros([channels, cln_wav.shape[0] + rir_len - 1])
for i in range(channels):
wav_tgt[i] = sps.oaconvolve(cln_wav, rir_wav[:, i])
# L x C
wav_tgt = np.transpose(wav_tgt)
wav_tgt = wav_tgt[:cln_wav.shape[0]]
return wav_tgt
def __init__(self, x, filter=None, k=.01, spring_type = 'quadratic', projected = True,mapfile = 'final.tif'
):
self.x , self.spring_type, self.k, self.projected = x, spring_type, k, projected
self.mapfile = mapfile
self.m = x.shape[0]
self.n = x.shape[1]
self.solved = False
self.eps = 1e-5
self.image = np.array(Image.open(self.mapfile))
self.original = np.copy(self.image)
if filter is not None:
numtaps = 129
filt = remez(numtaps, [0,filter-.02,filter+.02, .5],desired = [1,1e-4])
filt = np.outer(filt,filt)
# plt.imshow(filt)
# plt.show()
self.image = oaconvolve(self.image, filt,mode='same')
self.map = RGI([np.linspace(0,self.image.shape[1]-1,self.image.shape[1]),
np.linspace(0,self.image.shape[0]-1,self.image.shape[0])],
self.image.T)
def filtering(self, xin):
# filtering process via overlap add convolution, using scipy > 1.4.1
return signal.oaconvolve(xin, self.bz, axes=0)[0: - self.nth]
def calc_csr_kick(
beam,
charges,
Np=None,
gamma=None,
rho=None,
Nz=100,
sigma_z=1e-3,
Nx=100,
sigma_x=1e-3,
reuse_psi_grids=False,
psi_s_grid_old=None,
psi_x_grid_old=None,
verbose=True,
):
"""
"""
(x_b, xp_b, y_b, yp_b, z_b, zp_b) = beam
zx_positions = np.stack((z_b, x_b)).T
# Fix the grid here
# The grid needs to enclose most particles in z-x space
mins = np.array([-6 * sigma_z, -6 * sigma_x]) # Lower bounds of the grid
maxs = np.array([6 * sigma_z, 6 * sigma_x]) # Upper bounds of the grid
sizes = np.array([Nz, Nx])
(zmin, xmin) = mins
(zmax, xmax) = maxs
(Nz, Nx) = sizes
(dz, dx) = (maxs - mins) / (sizes - 1) # grid steps
# indexes, contrib = split_particles(zx_positions, charges, mins, maxs, sizes)
# t1 = time.time();
# charge_grid = deposit_particles(Np, sizes, indexes, contrib)
# t2 = time.time();
# Remi's fast code
t1 = time.time()
charge_grid = histogram_cic_2d(z_b, x_b, charges, Nz, zmin, zmax, Nx, xmin, xmax)
t2 = time.time()
# Normalize the grid so its integral is unity
norm = np.sum(charge_grid) * dz * dx
lambda_grid = charge_grid / norm
# Apply savgol filter
lambda_grid_filtered = np.array(
[savgol_filter(lambda_grid[:, i], 13, 2) for i in np.arange(Nx)]
).T
# Differentiation in z
lambda_grid_filtered_prime = central_difference_z(
lambda_grid_filtered, Nz, Nx, dz, order=1
)
zvec = np.linspace(zmin, zmax, Nz)
xvec = np.linspace(xmin, xmax, Nx)
beta = (1 - 1 / gamma ** 2) ** (1 / 2)
t3 = time.time()
if reuse_psi_grids == True:
psi_s_grid = psi_s_grid_old
psi_x_grid = psi_x_grid_old
else:
# Creating the potential grids
zvec2 = np.linspace(2 * zmin, 2 * zmax, 2 * Nz)
xvec2 = np.linspace(2 * xmin, 2 * xmax, 2 * Nx)
zm2, xm2 = np.meshgrid(zvec2, xvec2, indexing="ij")
# psi_s_grid = psi_s(zm2,xm2,beta)
beta_grid = beta * np.ones(zm2.shape)
with cf.ProcessPoolExecutor(max_workers=12) as executor:
temp = executor.map(psi_s, zm2 / 2 / rho, xm2, beta_grid)
psi_s_grid = np.array(list(temp))
temp2 = executor.map(psi_x, zm2 / 2 / rho, xm2, beta_grid)
psi_x_grid = np.array(list(temp2))
t4 = time.time()
if verbose:
print("Depositting particles takes:", t2 - t1, "s")
print("Computing potential grids take:", t4 - t3, "s")
# Compute the wake via 2d convolution
conv_s = oaconvolve(lambda_grid_filtered_prime, psi_s_grid, mode="same")
conv_x = oaconvolve(lambda_grid_filtered_prime, psi_x_grid, mode="same")
Ws_grid = (beta ** 2 / rho) * (conv_s) * (dz * dx)
Wx_grid = (beta ** 2 / rho) * (conv_x) * (dz * dx)
# Interpolate Ws and Wx everywhere within the grid
Ws_interp = RectBivariateSpline(zvec, xvec, Ws_grid)
Wx_interp = RectBivariateSpline(zvec, xvec, Wx_grid)
r_e = 2.8179403227e-15
q_e = 1.602176634e-19
Nb = np.sum(charge_grid) / q_e
kick_factor = r_e * Nb / gamma
# Calculate the kicks at the paritcle locations
delta_kick = kick_factor * Ws_interp.ev(z_b, x_b)
xp_kick = kick_factor * Wx_interp.ev(z_b, x_b)
return {
"zvec": zvec,
"xvec": xvec,
"delta_kick": delta_kick,
"xp_kick": xp_kick,
"Ws_grid": Ws_grid,
"Wx_grid": Wx_grid,
"psi_s_grid": psi_s_grid,
"psi_x_grid": psi_x_grid,
"charge_grid": charge_grid,
}
def time_convolve2d(self, mode, size):
signal.oaconvolve(self.a, self.b, mode=mode)
def csr2d_kick_calc(
z_b,
x_b,
weight,
*,
gamma=None,
rho=None,
nz=100,
nx=100,
xlim=None,
zlim=None,
reuse_psi_grids=False,
psi_s_grid_old=None,
psi_x_grid_old=None,
map_f=map,
species="electron",
debug=False,
):
"""
Calculates the 2D CSR kick on a set of particles with positions `z_b`, `x_b` and charges `charges`.
Parameters
----------
z_b : np.array
Bunch z coordinates in [m]
x_b : np.array
Bunch x coordinates in [m]
weight : np.array
weight array (positive only) in [C]
This should sum to the total charge in the bunch
gamma : float
Relativistic gamma
rho : float
bending radius in [m]
if neagtive, particles with a positive x coordinate is on the inner side of the magnet
nz : int
number of z grid points
nx : int
number of x grid points
zlim : floats (min, max) or None
z grid limits in [m]
xlim : floats (min, max) or None
x grid limits in [m]
map_f : map function for creating potential grids.
Examples:
map (default)
executor.map
species : str
Particle species. Currently required to be 'electron'
debug: bool
If True, returns the computational grids.
Default: False
Returns
-------
dict with:
ddelta_ds : np.array
relative z momentum kick [1/m]
dxp_ds : np.array
relative x momentum kick [1/m]
"""
assert species == "electron", "TODO: support species {species}"
# assert np.sign(rho) == 1, 'TODO: negative rho'
rho_sign = np.sign(rho)
if rho_sign == -1:
rho = -rho
x_b = -x_b # flip the beam x coordinate
# Grid setup
if zlim:
zmin = zlim[0]
zmax = zlim[1]
else:
zmin = z_b.min()
zmax = z_b.max()
if xlim:
xmin = xlim[0]
xmax = xlim[1]
else:
xmin = x_b.min()
xmax = x_b.max()
dz = (zmax - zmin) / (nz - 1)
dx = (xmax - xmin) / (nx - 1)
# Charge deposition
# Old method
# zx_positions = np.stack((z_b, x_b)).T
# indexes, contrib = split_particles(zx_positions, charges, mins, maxs, sizes)
# t1 = time.time();
# charge_grid = deposit_particles(Np, sizes, indexes, contrib)
# t2 = time.time();
# Remi's fast code
t1 = time.time()
charge_grid = histogram_cic_2d(z_b, x_b, weight, nz, zmin, zmax, nx, xmin,
xmax)
if debug:
t2 = time.time()
print("Depositing particles takes:", t2 - t1, "s")
# Normalize the grid so its integral is unity
norm = np.sum(charge_grid) * dz * dx
lambda_grid = charge_grid / norm
# Apply savgol filter
lambda_grid_filtered = np.array(
[savgol_filter(lambda_grid[:, i], 13, 2) for i in np.arange(nx)]).T
# Differentiation in z
lambda_grid_filtered_prime = central_difference_z(lambda_grid_filtered,
nz,
nx,
dz,
order=1)
# Grid axis vectors
zvec = np.linspace(zmin, zmax, nz)
xvec = np.linspace(xmin, xmax, nx)
beta = np.sqrt(1 - 1 / gamma**2)
t3 = time.time()
if reuse_psi_grids == True:
psi_s_grid = psi_s_grid_old
psi_x_grid = psi_x_grid_old
else:
# Creating the potential grids
#zvec2 = np.linspace(2 * zmin, 2 * zmax, 2 * nz)
#xvec2 = np.linspace(2 * xmin, 2 * xmax, 2 * nx)
zvec2 = np.arange(-nz, nz, 1) * dz # center = 0 is at [nz]
xvec2 = np.arange(-nx, nx, 1) * dx # center = 0 is at [nx]
zm2, xm2 = np.meshgrid(zvec2, xvec2, indexing="ij")
beta_grid = beta * np.ones(zm2.shape)
# Map (possibly parallel)
temp = map_f(psi_s, zm2 / 2 / rho, xm2 / rho, beta_grid)
psi_s_grid = np.array(list(temp))
temp2 = map_f(psi_x, zm2 / 2 / rho, xm2 / rho, beta_grid)
psi_x_grid = np.array(list(temp2))
# Replacing the fake zeros along the x_axis ( due to singularity) with averaged value from the nearby grid
psi_x_grid[:, nx] = psi_x_where_x_equals_zero(zvec2, dx / rho, beta)
if debug:
t4 = time.time()
print("Computing potential grids take:", t4 - t3, "s")
# Compute the wake via 2d convolution
conv_s = oaconvolve(lambda_grid_filtered_prime, psi_s_grid, mode="same")
conv_x = oaconvolve(lambda_grid_filtered_prime, psi_x_grid, mode="same")
if debug:
t5 = time.time()
print("Convolution takes:", t5 - t4, "s")
Ws_grid = (beta**2 / rho) * (conv_s) * (dz * dx)
Wx_grid = (beta**2 / rho) * (conv_x) * (dz * dx)
# Interpolate Ws and Wx everywhere within the grid
Ws_interp = RectBivariateSpline(zvec, xvec, Ws_grid)
Wx_interp = RectBivariateSpline(zvec, xvec, Wx_grid)
# Overall factor
Nb = np.sum(weight) / e_charge
kick_factor = r_e * Nb / gamma # m
# Calculate the kicks at the particle locations
delta_kick = kick_factor * Ws_interp.ev(z_b, x_b)
xp_kick = kick_factor * Wx_interp.ev(z_b, x_b)
if debug:
t6 = time.time()
print("Interpolation takes:", t6 - t5, "s")
if rho_sign == -1:
xp_kick = -xp_kick
result = {"ddelta_ds": delta_kick, "dxp_ds": xp_kick}
if debug:
result.update({
"zvec": zvec,
"xvec": xvec,
"zvec2": zvec2,
"xvec2": xvec2,
"Ws_grid": Ws_grid,
"Wx_grid": Wx_grid,
"psi_s_grid": psi_s_grid,
"psi_x_grid": psi_x_grid,
"charge_grid": charge_grid,
"lambda_grid_filtered_prime": lambda_grid_filtered_prime,
})
return result
#
parser = argparse.ArgumentParser(
description='overlap-add convolve with impulse response waveform')
parser.add_argument('--wav_file',
'-w',
default='test.wav',
help='wav file name(16bit)')
parser.add_argument(
'--wav_32_file',
'-i',
default='impulse_1sec_100_1sec_44100-TwoTube-output-rtwdf.wav',
help='impulse response wav file name (mono 32bit)')
args = parser.parse_args()
path0 = args.wav_file
# overwrite path0
# path0='test_882.wav'
yg, sr = load_wav(path0)
path2 = args.wav_32_file
# overwrite path2
# path2='impulse_1sec_10_1sec_88200-output-rtwdf.wav
yg2, sr2 = load_wav32(path2, 0.150, yg)
# overlap-add convolve with impulse response waveform
out1 = signal.oaconvolve(yg, yg2, axes=0) # need scipy > 1.4.1
# set output file name
path_out0 = os.path.splitext(
os.path.basename(path0))[0] + '_overlapadd_out.wav'
save_wav(path_out0, out1, sr, normalize=True)
import numpy as np
import pandas as pd
from scipy.signal import remez, oaconvolve, savgol_filter
# import sys
# from os import path
# sys.path.append(path.abspath('../..'))
import smooth_component_analysis as sca
hrv_lf_h = remez(25, [0., 0.1, 0.15, 1.],[1., 0.],fs =2.)
hrv_rms_filter = lambda y: savgol_filter(y, 11, 2)
filter_hrv_lf = lambda y: oaconvolve(y, hrv_lf_h, 'valid')
ecg_lf_filter = sca.dataframe_filter(
filter_hrv_lf,
naming_func=lambda s: s.replace('_raw','_lf'),
pad_output=[12,12]
)
ecg_rms_filter = sca.dataframe_filter(
hrv_rms_filter,
naming_func=lambda s: s.replace('_hf','_rms'),
pad_output=None
)
INTERPOLATION_SERIES_ID_FOR_HRV = 3
# 1005 does not have cohesions so removed for now
valid_ecg_groups = [1004, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014,
1016, 1019, 1020, 1022, 1024, 1025, 1026, 1027, 1028, 1029, 1030,
# yy = np.expand_dims(yy, axis=2)
yy = np.tile(yy, (n_points, 1, 1))
kernel = (np.square(xx) + np.square(yy)) / np.square(sigmas.reshape(n_points, 1, 1))
kernel = np.exp(-0.5 * kernel)
kernel /= kernel.max()
print("kernel shape", kernel.shape)
plt.figure()
plt.title("ker")
plt.imshow(kernel[3, :])
image = np.zeros((n_points, 50,50))
points = np.random.randint(0, 50, size=(2, n_points))
points = np.vstack([points, np.arange(n_points).reshape(1, n_points)])
print(image.shape)
print(points.shape)
print(points[2], points[0], points[1], "end")
image[points[2], points[0], points[1]] = 1
conv_image = oaconvolve(image, kernel, mode="same", axes=(1, 2))
print(conv_image.shape)
plt.figure()
plt.title("im")
plt.imshow(conv_image.sum(axis=0))
plt.colorbar()
plt.show()
import numpy as np
import soundfile as sf
from scipy.signal import oaconvolve
from scipy.io.wavfile import write
rir = './circle_n8_az210_el0_r1.5.npz'
audio = './p229_008.wav'
rir = np.load(rir, allow_pickle=True)
rir = dict(zip(("data1{}".format(k) for k in rir),
(rir[k] for k in rir)))['data1rir'] * 4
audio, sr = sf.read(audio)
result = []
for i in range(rir.shape[-1]):
data = oaconvolve(audio, rir[:, i], mode='same')
result.append(data)
result = np.array(result).T * 5
print(result.shape[1])
write('test.wav', sr, result)
# sf.write(result,'test.wav', sr)
def synthesize_reverb(mode):
if mode == 'tr':
save_loc = './dataset/tr/'
audio_csv = pd.read_csv('tr_audio.csv')
rir_csv = pd.read_csv('tr_rir.csv')
noise_csv = pd.read_csv('noise_train.csv')
input_prefix = 'train_input_'
label_prefix = 'train_label_'
out_csv = 'tr.csv'
elif mode == 'cv':
save_loc = './dataset/cv/'
audio_csv = pd.read_csv('cv_audio.csv')
rir_csv = pd.read_csv('cv_rir.csv')
noise_csv = pd.read_csv('noise_cv.csv')
input_prefix = 'cv_input_'
label_prefix = 'cv_label_'
out_csv = 'cv.csv'
elif mode == 'tt':
save_loc = './dataset/tt/'
audio_csv = pd.read_csv('test_audio.csv')
rir_csv = pd.read_csv('./test_rir.csv')
noise_csv = pd.read_csv('noise_test.csv')
input_prefix = 'test_input_'
label_prefix = 'test_label_'
out_csv = 'tt.csv'
del rir_csv['Unnamed: 0']
# print(noise_csv)
# exit()
audio_csv = sklearn.utils.shuffle(audio_csv)
rir_csv = sklearn.utils.shuffle(rir_csv)
noise_csv = sklearn.utils.shuffle(noise_csv)
len_rir = len(rir_csv)
len_noise = len(noise_csv)
data_dict = {
'input_path': [],
'label_path': [],
'speech_path': [],
'speech_RIR': [],
'noise_path': [],
'noise_RIR': [],
'room': [],
'SNR': [],
'vad_path': []
}
SNR_list = [0, 5, 10, 15]
for num in range(len(audio_csv)):
first = True
# print(len(rir_csv))
audio = audio_csv.iloc[num]
rir = rir_csv.iloc[num % len_rir]
# print(rir)
# exit()
noise = noise_csv.iloc[num % len_noise]
audio_file, fs = sf.read(audio['audio_directory'])
noise_file, fs = sf.read(noise['noise_directory'])
audio_rir_file = np.load(rir['rir_directory'])['rir']
room = rir['room']
noise_rir = rir_csv.drop([num % len_rir], axis=0)
noise_rir = noise_rir.loc[rir_csv['room'] == room]
# print(noise_rir, room)
noise_rir = noise_rir.sample()['rir_directory']
noise_rir_file = np.load(noise_rir.item())['rir']
input_name = save_loc + 'input/' + input_prefix + str(num) + '.wav'
output_name = save_loc + 'label/' + label_prefix + str(num) + '.wav'
data_dict['input_path'].append(input_name)
data_dict['label_path'].append(output_name)
data_dict['speech_path'].append(audio['audio_directory'])
data_dict['speech_RIR'].append(rir['rir_directory'])
data_dict['noise_path'].append(noise['noise_directory'])
data_dict['noise_RIR'].append(noise_rir.item())
data_dict['room'].append(room)
data_dict['vad_path'].append(audio['VAD_directory'])
SNR = random.choice(SNR_list)
data_dict['SNR'].append(SNR)
# print(SNR)
# exit()
long_noise = True
if noise_file.shape[0] > audio_file.shape[0]:
start = np.random.randint(
0, noise_file.shape[0] - audio_file.shape[0])
noise_file = noise_file[start:start + audio_file.shape[0], ]
else:
pad_front = np.random.randint(
0, audio_file.shape[0] - noise_file.shape[0])
# print(pad_front)
# pad_front=np.random.randint(0, audio_file.shape[0]-noise_file.shape[0])
long_noise = False
# print(audio_file.shape, noise_file.shape)
# exit()
for n in range(audio_rir_file.shape[-1]):
audio_rired = oaconvolve(audio_file,
audio_rir_file[:, n],
mode='full')
noise_rired = oaconvolve(noise_file,
noise_rir_file[:, n],
mode='full')
audio_rired = audio_rired[:audio_file.shape[0], ]
noise_rired = noise_rired[:audio_file.shape[0], ]
if first == True:
sf.write(output_name, audio_rired, fs)
snr_mul = snr_count(audio_rired, noise_rired, SNR)
result = np.zeros(
(audio_rired.shape[0], audio_rir_file.shape[-1]))
first = False
if long_noise == False:
result[:, n] = audio_rired
result[pad_front + noise_rired.shape[0],
n] += noise_rired * snr_mul
else:
result[:, n] = audio_rired + noise_rired * snr_mul
sf.write(input_name, result, fs)
# break
# exit()
pd.DataFrame(data_dict).to_csv('./dataset/' + out_csv)
from scipy.signal import convolve, fftconvolve, oaconvolve
import matplotlib.pyplot as plt
speaker=[276, 274, 246, 244, 262, 260, 227, 225]
rir_list=['ellipsoid_n8_az120_el0_r1.5.npz', 'ellipsoid_n8_az270_el0_r1.0.npz', 'ellipsoid_n8_az60_el0_r0.5.npz', 'ellipsoid_n8_az0_el0_r1.5.npz', 'ellipsoid_n8_az300_el0_r1.5.npz', 'ellipsoid_n8_az210_el0_r1.5.npz', 'ellipsoid_n8_az180_el0_r1.0.npz']
total_data=[]
length=0
for wav, rir in zip(speaker, rir_list):
wav_name='p'+str(wav)+'_004.wav'
wav_data, fs=sf.read(wav_name)
rir_data=np.load(rir, allow_pickle=True)
rir_data=rir_data['rir']
final=None
for num in range(rir_data.shape[1]):
result=oaconvolve(wav_data, rir_data[:,num])
result=np.expand_dims(result, axis=-1)
if num==0:
final=result
else:
final=np.concatenate((final, result), axis=1)
length+=final.shape[0]
total_data.append(final)
white_rir='ellipsoid_n8_az240_el0_r1.5.npz'
white_rir=np.load(white_rir, allow_pickle=True)
white_rir=white_rir['rir']
white_noise = np.random.normal(0, 0.04, size=length)
for z in range(white_rir.shape[1]):
def extract_features(self, image):
grayscale_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
if self.smoothing_radius is not None:
grayscale_image = signal.oaconvolve(grayscale_image, self.smoothing_kernel, mode="same")
print(grayscale_image.shape, self.feature_mask.shape)
print(grayscale_image.dtype, self.feature_mask.dtype)
keypoints = self.keypoint_detector.detect(grayscale_image, self.feature_mask)
# Take a subset of the key points in random order
shuffle(keypoints)
keypoints = keypoints[0:min(len(keypoints), self.n_samples_per_image)]
x_length = self.kernel_a.shape[0]
y_length = self.kernel_a.shape[1]
if x_length % 2 != 1:
exit("ERROR: even kernel dimension cannot be centered")
if y_length % 2 != 1:
exit("ERROR: even kernel dimension cannot be centered")
x_radius = int((x_length - 1) / 2)
y_radius = int((y_length - 1) / 2)
features = numpy.zeros([self.n_samples_per_image, self.n_samples_per_kernel])
i = 0
for n in range(self.n_samples_per_image):
x = int(keypoints[i].pt[0])
y = int(keypoints[i].pt[1])
i += 1
if i == len(keypoints):
break
a = grayscale_image[y - y_radius:y + y_radius + 1, x - x_radius:x + x_radius + 1]
b = grayscale_image[y - y_radius:y + y_radius + 1, x - x_radius:x + x_radius + 1]
# fig, axes = pyplot.subplots(ncols=2)
# axes[0].imshow(grayscale_image)
# r = pyplot.Rectangle(xy=(x-x_radius,y-y_radius), width=x_radius*2+1, height=y_radius*2+1, linewidth=1,edgecolor='r',facecolor='none')
# axes[0].add_patch(r)
# axes[1].imshow(a)
# pyplot.show()
# pyplot.close()
# print(a.shape)
# print(b.shape)
# print(self.kernel_a.shape)
# print(self.kernel_b.shape)
a = a[self.kernel_a]
b = b[self.kernel_b]
features[n] = (a > b)
return keypoints, features
