def rir(self, fname, fs=16000, rir_nsamps=4096, v=340, gpu=False):
"""
Generate rir for current settings
"""
if gpu:
# self.beta: rt60
beta = pygpurir.beta_SabineEstimation(self.size, self.beta)
# NOTE: do not clear here
# diff = pygpurir.att2t_SabineEstimator(15, self.beta)
tmax = rir_nsamps / fs
nb_img = pygpurir.t2n(tmax, self.size)
# S x R x T
rir = pygpurir.simulateRIR(self.size,
beta,
np.array(self.spos)[None, ...],
np.array(self.rpos),
nb_img,
tmax,
fs,
mic_pattern="omni")
write_wav(fname, rir[0], fs=fs)
elif cpp_rir_available:
# format float
ffloat = lambda f: "{:.3f}".format(f)
# location for each microphone
loc_for_each_channel = [
",".join(map(ffloat, p)) for p in self.rpos
]
beta = ",".join(map(ffloat, self.beta)) if isinstance(
self.beta, list) else round(self.beta, 3)
run_command(
"rir-simulate --sound-velocity={v} --samp-frequency={sample_rate} "
"--hp-filter=true --number-samples={rir_samples} --beta={beta} "
"--room-topo={room_size} --receiver-location=\"{receiver_location}\" "
"--source-location={source_location} {dump_dest}".format(
v=v,
sample_rate=fs,
rir_samples=rir_nsamps,
room_size=",".join(map(ffloat, self.size)),
beta=beta,
receiver_location=";".join(loc_for_each_channel),
source_location=",".join(map(ffloat, self.spos)),
dump_dest=fname))
elif pyrirgen_available:
rir = pyrirgen.generateRir(self.size,
self.spos,
self.rpos,
soundVelocity=v,
fs=fs,
nDim=3,
nSamples=rir_nsamps,
nOrder=-1,
reverbTime=self.beta,
micType="omnidirectional",
isHighPassFilter=True)
if isinstance(rir, list):
rir = np.stack(rir)
write_wav(fname, rir, fs=fs)
else:
raise RuntimeError("Both rir-simulate and pyrirgen unavailable")
def rir(self, fname, fs=16000, rir_nsamps=4096, v=340):
"""
Generate rir for current settings
"""
if shutil.which("rir-simulate"):
# format float
ffloat = lambda f: "{:.3f}".format(f)
# location for each microphone
loc_for_each_channel = [
",".join(map(ffloat, p)) for p in self.rpos
]
beta = ",".join(map(ffloat, self.beta)) if isinstance(
self.beta, list) else round(self.beta, 3)
run_command(
"rir-simulate --sound-velocity={v} --samp-frequency={sample_rate} "
"--hp-filter=true --number-samples={rir_samples} --beta={beta} "
"--room-topo={room_size} --receiver-location=\"{receiver_location}\" "
"--source-location={source_location} {dump_dest}".format(
v=v,
sample_rate=fs,
rir_samples=rir_nsamps,
room_size=",".join(map(ffloat, self.size)),
beta=beta,
receiver_location=";".join(loc_for_each_channel),
source_location=",".join(map(ffloat, self.spos)),
dump_dest=fname))
elif pyrirgen_available:
rir = pyrirgen.generateRir(self.size,
self.spos,
self.rpos,
soundVelocity=v,
fs=fs,
nDim=3,
nSamples=rir_nsamps,
nOrder=-1,
reverbTime=self.beta,
micType="omnidirectional",
isHighPassFilter=True)
if isinstance(rir, list):
rir = np.stack(rir)
write_wav(fname, rir, fs=fs)
else:
raise RuntimeError("Both rir-simulate and pyrirgen unavailable")
import pyrirgen c = 340 # Sound velocity (m/s) fs = 16000 # Sample frequency (samples/s) r = [[2, 1.5, 2], [1, 1.5, 2]] # Receiver position [x y z] (m) s = [2, 3.5, 2] # Source position [x y z] (m) L = [5, 4, 6] # Room dimensions [x y z] (m) rt = 0.4 # Reverberation time (s) n = 4096 # Number of samples mtype = 'omnidirectional' # Type of microphone order = -1 # Reflection order dim = 3 # Room dimension orientation = 0 # Microphone orientation (rad) hp_filter = True # Enable high-pass filter h = pyrirgen.generateRir(L, s, r, soundVelocity=c, fs=fs, reverbTime=rt, nSamples=n, micType=mtype, nOrder=order, nDim=dim, isHighPassFilter=hp_filter) print(len(h), len(h[0]), len(h[1]))
print(os.environ.get('LD_LIBRARY_PATH'))
# TODO model IR36
c = 340 # Sound velocity (m/s)
fs = 16000 # Sample frequency (samples/s)
r = [2, 1.5, 2] # Receiver position [x y z] (m)
s = [2, 3.5, 2] # Source position [x y z] (m)
L = [10, 20, 3] # Room dimensions [x y z] (m)
rt = 3. # Reverberation time (s)
n = 2 * 2048 # Number of samples
h = pyrirgen.generateRir(L,
s,
r,
soundVelocity=c,
fs=fs,
reverbTime=rt,
nSamples=n)
print(len(h))
soundfile.write('ir.wav', h, fs)
# plt.figure()
# plt.plot(h)
# plt.show()
def convolve(signal, response):
"""Convolves two waves.
Note: this operation ignores the timestamps; the result
has the timestamps of self.
c = 340 # Sound velocity (m/s)
fs = 16000 # Sample frequency (samples/s)
r = [2, 1.5, 2] # Receiver position [x y z] (m)
s = [2, 3.5, 2] # Source position [x y z] (m)
L = [5, 4, 6] # Room dimensions [x y z] (m)
rt = 0.4 # Reverberation time (s)
n = 2048 # Number of samples
mtype = 'omnidirectional' # Type of microphone
order = 2 # Reflection order
dim = 3 # Room dimension
orientation = 0 # Microphone orientation (rad)
hp_filter = True # Enable high-pass filter
h = pyrirgen.generateRir(L,
s,
r,
soundVelocity=c,
fs=fs,
reverbTime=rt,
nSamples=n,
micType=mtype,
nOrder=order,
nDim=dim,
isHighPassFilter=hp_filter)
# Uncomment if you want to save the generated RIR.
#import numpy as np
#outfile = 'example_2'
#h = np.array(h)
#np.savez(outfile, filter=h)
def __call__(self, nspeakers=2, info_as_display_style=False):
success = False
while not success:
# Randomly sample room dimensions.
L = np.array([
np.random.uniform(*self._roomdim_range_x),
np.random.uniform(*self._roomdim_range_y),
np.random.uniform(*self._roomdim_range_z)
])
# Randomly sample T60.
rt = np.random.uniform(*self._t60_range)
rirlen = int(rt * self._fs)
# validity check
V = np.prod(L)
S = 2 * (L[0] * L[2] + L[1] * L[2] + L[0] * L[1])
alpha = 24 * V * np.log(10) / (self._sound_velocity * S * rt)
if alpha < 1:
success = True
# Randomly sample a mic array location.
if self._micpos == 'center':
room_center = L / 2
r = np.array([
np.random.uniform(
room_center[0] - self._roomcenter_mic_dist_max_x,
room_center[0] + self._roomcenter_mic_dist_max_x),
np.random.uniform(
room_center[1] - self._roomcenter_mic_dist_max_y,
room_center[1] + self._roomcenter_mic_dist_max_y),
np.random.uniform(*self._micpos_range_z)
])
r = np.maximum(r, 0)
r = np.minimum(r, L)
R = self._micarray + r
elif self._micpos == 'corner':
corner_x = 'origin' if np.random.choice([0, 1]) == 1 else 'end'
corner_y = 'origin' if np.random.choice([0, 1]) == 1 else 'end'
r = np.array([
np.random.uniform(0.0425, self._corner_mic_dist_max_x)
if corner_x == 'origin' else np.random.uniform(
L[0] - self._corner_mic_dist_max_x, L[0] - 0.0425),
np.random.uniform(0.0425, self._corner_mic_dist_max_y)
if corner_y == 'origin' else np.random.uniform(
L[1] - self._corner_mic_dist_max_y, L[1] - 0.0425),
np.random.uniform(*self._micpos_range_z)
])
r = np.maximum(r, 0)
r = np.minimum(r, L)
R = self._micarray + r
else:
raise ValueError(
'micpos must be either center or corner: {}'.format(
self._micpos))
# Randomly sample an ellipse on which sources will be located.
ellipse_xaxis = np.random.uniform(*self._spkr_mic_dist_range_x)
ellipse_yaxis = np.random.uniform(*self._spkr_mic_dist_range_y)
# Randomly sample a base height.
base_height = np.random.uniform(*self._spkr_mic_dist_range_z)
mic2src_vecs = []
h = []
spkr_locations = []
for i in range(nspeakers):
max_trials = 1000
for trial in range(max_trials):
# Randomly draw a speaker location.
theta = np.random.uniform(0, 2 * np.pi)
x_offset = ellipse_xaxis * np.cos(theta)
y_offset = ellipse_yaxis * np.sin(theta)
z_offset = base_height + np.random.uniform(
-0.1, 0.1) # allow small fluctuation in height
if self._micpos == 'corner':
x_offset = np.abs(
x_offset
) if corner_x == 'origin' else -np.abs(x_offset)
y_offset = np.abs(
y_offset
) if corner_y == 'origin' else -np.abs(y_offset)
s = np.array(
[r[0] + x_offset, r[1] + y_offset, r[2] + z_offset])
s = np.maximum(s, 0)
s = np.minimum(s, L)
mic2src = s[:2] - r[:2]
mic2src = mic2src / np.linalg.norm(mic2src)
# Check if the direction of the new source is valid with respect to the previously generated ones.
valid = True
for m2s in mic2src_vecs:
angle_diff = math.degrees(
np.arccos(np.clip(np.dot(mic2src, m2s), -1, 1)))
if angle_diff < self._min_angle_diff:
valid = False
if angle_diff > self._max_angle_diff:
valid = False
if valid:
break
if not valid:
raise RuntimeError('Failed to generate valid RIRs.')
# print('Tried {} times.'.format(trial))
mic2src_vecs.append(mic2src)
angle = math.degrees(np.arctan2(s[1] - r[1], s[0] - r[0])) + 180
dist_2d = np.linalg.norm(s[:2] - r[:2])
dist_3d = np.linalg.norm(s - r)
height = s[2] - r[2]
h0 = np.array(
pyrirgen.generateRir(L,
s,
R,
soundVelocity=self._sound_velocity,
fs=self._fs,
reverbTime=rt,
nSamples=rirlen))
#import matplotlib.pyplot as plt
#plt.figure()
#plt.plot(h0[0])
#plt.show()
h.append(h0)
spkr_locations.append([angle, dist_2d, dist_3d, height])
# Print the simulated enviroment.
print('Room dimensions: [{:6.3f} m, {:6.3f} m, {:6.3f} m]'.format(
L[0], L[1], L[2]))
print('T60: {:6.3f} s'.format(rt))
print('Mic-array: [{:6.3f} m, {:6.3f} m, {:6.3f} m]'.format(
r[0], r[1], r[2]))
for i in range(nspeakers):
print(
'Speaker {}: [angle, distance from mic (2d), distance from mic (3d), height relative to mic] = [{:6.3f} deg, {:6.3f} m, {:6.3f} m, {:6.3f} m]'
.format(i, spkr_locations[i][0], spkr_locations[i][1],
spkr_locations[i][2], spkr_locations[i][3]))
print('', flush=True)
# return
if info_as_display_style:
info = [('t60', rt), ('angles', [l[0] for l in spkr_locations])]
return h, info
else:
return h, rt, spkr_locations
# [mic_middle_point[0]-mic_distance*0.5, mic_middle_point[1], mic_middle_point[2]],
# [mic_middle_point[0]+mic_distance*0.5, mic_middle_point[1], mic_middle_point[2]],
# [mic_middle_point[0]+mic_distance*1.5, mic_middle_point[1], mic_middle_point[2]],
# [mic_middle_point[0]+mic_distance*2.5, mic_middle_point[1], mic_middle_point[2]],
# [mic_middle_point[0]+mic_distance*3.5, mic_middle_point[1], mic_middle_point[2]],]
mic_pattern = "omnidirectional" # Receiver polar pattern
T60 = np.random.uniform(
0.2, 0.8) # Time for the RIR to reach 60dB of attenuation [s]
RIRs1 = pyrirgen.generateRir(
room_sz,
pos_src1,
pos_rcv,
soundVelocity=c,
fs=fs,
reverbTime=T60,
nSamples=8000,
micType=mic_pattern,
nOrder=-1,
nDim=3,
isHighPassFilter=True) #source * mic * time
RIRs2 = pyrirgen.generateRir(
room_sz,
pos_src2,
pos_rcv,
soundVelocity=c,
fs=fs,
reverbTime=T60,
nSamples=8000,
micType=mic_pattern,
nOrder=-1,
import pyrirgen c = 340 # Sound velocity (m/s) fs = 16000 # Sample frequency (samples/s) r = [2, 1.5, 2] # Receiver position [x y z] (m) s = [2, 3.5, 2] # Source position [x y z] (m) L = [5, 4, 6] # Room dimensions [x y z] (m) rt = 0.4 # Reverberation time (s) n = 2048 # Number of samples h = pyrirgen.generateRir(L, s, r, soundVelocity=c, fs=fs, reverbTime=rt, nSamples=n) print(len(h))
