def test_read_write_wav():
"""Test reading and writing WAV files
"""
fname = op.join(tempdir, 'temp.wav')
data = np.r_[np.random.rand(1000), 1, -1]
fs = 44100
# Use normal 16-bit precision: not great
write_wav(fname, data, fs)
data_read, fs_read = read_wav(fname)
assert_equal(fs_read, fs)
assert_array_almost_equal(data[np.newaxis, :], data_read, 4)
# test our overwrite check
assert_raises(IOError, write_wav, fname, data, fs)
# test forcing fs dtype to int
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
write_wav(fname, data, float(fs), overwrite=True)
assert_equal(len(w), 1)
# Use 64-bit int: not supported
assert_raises(RuntimeError, write_wav, fname, data, fs, dtype=np.int64,
overwrite=True)
# Use 32-bit int: better
write_wav(fname, data, fs, dtype=np.int32, overwrite=True)
data_read, fs_read = read_wav(fname)
assert_equal(fs_read, fs)
assert_array_almost_equal(data[np.newaxis, :], data_read, 7)
if _has_scipy_version('0.13'):
# Use 32-bit float: better
write_wav(fname, data, fs, dtype=np.float32, overwrite=True)
data_read, fs_read = read_wav(fname)
assert_equal(fs_read, fs)
assert_array_almost_equal(data[np.newaxis, :], data_read, 7)
# Use 64-bit float: perfect
write_wav(fname, data, fs, dtype=np.float64, overwrite=True)
data_read, fs_read = read_wav(fname)
assert_equal(fs_read, fs)
assert_array_equal(data[np.newaxis, :], data_read)
else:
assert_raises(RuntimeError, write_wav, fname, data, fs,
dtype=np.float32, overwrite=True)
# Now try multi-dimensional data
data = np.tile(data[np.newaxis, :], (2, 1))
write_wav(fname, data[np.newaxis, :], fs, overwrite=True)
data_read, fs_read = read_wav(fname)
assert_equal(fs_read, fs)
assert_array_almost_equal(data, data_read, 4)
# Make sure our bound check works
assert_raises(ValueError, write_wav, fname, data * 2, fs, overwrite=True)
def test_read_write_wav(tmpdir):
"""Test reading and writing WAV files."""
fname = op.join(str(tmpdir), 'temp.wav')
data = np.r_[np.random.rand(1000), 1, -1]
fs = 44100
# Use normal 16-bit precision: not great
write_wav(fname, data, fs)
data_read, fs_read = read_wav(fname)
assert_equal(fs_read, fs)
assert_array_almost_equal(data[np.newaxis, :], data_read, 4)
# test our overwrite check
pytest.raises(IOError, write_wav, fname, data, fs)
# test forcing fs dtype to int
with pytest.warns(UserWarning, match='rate is being cast'):
write_wav(fname, data, float(fs), overwrite=True)
# Use 64-bit int: not supported
pytest.raises(RuntimeError, write_wav, fname, data, fs, dtype=np.int64,
overwrite=True)
# Use 32-bit int: better
write_wav(fname, data, fs, dtype=np.int32, overwrite=True)
data_read, fs_read = read_wav(fname)
assert_equal(fs_read, fs)
assert_array_almost_equal(data[np.newaxis, :], data_read, 7)
if _has_scipy_version('0.13'):
# Use 32-bit float: better
write_wav(fname, data, fs, dtype=np.float32, overwrite=True)
data_read, fs_read = read_wav(fname)
assert_equal(fs_read, fs)
assert_array_almost_equal(data[np.newaxis, :], data_read, 7)
# Use 64-bit float: perfect
write_wav(fname, data, fs, dtype=np.float64, overwrite=True)
data_read, fs_read = read_wav(fname)
assert_equal(fs_read, fs)
assert_array_equal(data[np.newaxis, :], data_read)
else:
pytest.raises(RuntimeError, write_wav, fname, data, fs,
dtype=np.float32, overwrite=True)
# Now try multi-dimensional data
data = np.tile(data[np.newaxis, :], (2, 1))
write_wav(fname, data[np.newaxis, :], fs, overwrite=True)
data_read, fs_read = read_wav(fname)
assert_equal(fs_read, fs)
assert_array_almost_equal(data, data_read, 4)
# Make sure our bound check works
pytest.raises(ValueError, write_wav, fname, data * 2, fs, overwrite=True)
def run_trial(ti, feedback=False):
"""Run a trial, optionally with feedback"""
samples = read_wav(op.join(stim_dir, p['stim_names'][ti]))[0]
ec.load_buffer(samples)
id_ = decimals_to_binary(p['cond_mat'][ti], [1, 2, 2, 1])
ec.identify_trial(ec_id=id_, ttl_id=id_, el_id=id_)
ec.listen_presses()
t0 = ec.start_stimulus(flip=False)
wait_dur = p['trial_durs'][ti]
wait_dur -= p['inter_trial_dur'] - 0.5 if feedback else 0
presses = ec.wait_for_presses(wait_dur, relative_to=t0)
ec.stop()
ec.trial_ok()
correct = True
if feedback:
press_times = [pp[1] for pp in presses]
p['targ_pos'][ti][0]
t = p['stim_times'][p['cond_mat'][ti][3]][2:]
targ = t[p['targ_pos'][ti][0].astype(bool)]
foil = t[p['targ_pos'][ti][1].astype(bool)]
hmfc = press_times_to_hmfc(press_times, targ, foil, tmin, tmax)
correct = (hmfc[1] == hmfc[2] == hmfc[4] == 0)
if correct:
msg = 'Correct!\n\n'
else:
msg = 'Incorrect:\n'
if hmfc[1] > 0:
pl = 's' if hmfc[1] != 1 else ''
msg += '\n - Missed %s target "O"%s\n' % (hmfc[1], pl)
x = hmfc[2] + hmfc[4]
if x > 0:
pl = 's' if x != 1 else ''
msg += '\n - Pressed to %s non-target "O"%s' % (x, pl)
ec.screen_prompt(msg + continue_msg, color=fcolor)
fix.draw()
ec.flip()
return correct
bi = get_keyboard_input('Enter block number (%s): ' % 1, 1, int) - 1
session = int(ec.session) - 1 if ec.session != '' else 0
while 0 <= bi < len(p['block_trials']):
# start of each block
ec.start_noise()
ec.set_visible(True)
ec.write_data_line('block', bi)
fix.draw()
ec.flip()
ec.wait_for_presses(5.0)
# each trial
trials = p['block_trials'][p['blocks'][session][bi]]
for ti in trials:
# stimulus
samples = read_wav(op.join(stim_dir, p['stim_names'][ti]))[0]
ec.load_buffer(samples)
stamp = np.concatenate([p['cond_mat'][ti], p['which_targ'][ti]])
id_ = decimals_to_binary(stamp, [1, 2, 2, 1, 2, 2])
ec.identify_trial(ec_id=id_, ttl_id=id_)
ec.listen_presses()
fix.draw()
t0 = ec.start_stimulus()
# response
fix.draw()
circ.draw()
targ_text.draw()
ec.flip(t0 + p['resp_onset'])
ec.stamp_triggers([2])
assert n_dpc + n_npc == n_tpc
##############################################################################
# Load letter WAV files
all_spatials = [s.split('x') for s in spatials]
for s in all_spatials[1:]:
all_spatials[0] += s
all_spatials = all_spatials[0]
all_spatials = list(np.unique([float(s) for s in all_spatials]))
letter_dir = op.join(work_dir, 'letters')
wavs = np.zeros((len(talkers), len(letters), len(all_spatials), 2, letter_ns))
for li, letter in enumerate(letters):
for ti, talker in enumerate(talkers):
data, fs_in = read_wav(op.join(letter_dir, talker, '%s.wav' % letter),
verbose=False)
data = resample(data[0], fs, fs_in)
for si, angle in enumerate(all_spatials):
dd = convolve_hrtf(data, fs, angle)
dd *= 0.01 / np.mean(rms(data))
idx = min(dd.shape[1], letter_ns)
wavs[ti, li, si, :, :idx] = dd[:, :idx]
##############################################################################
# Randomization
n_trials = n_tpc * len(attns) * run_matrix.sum() * len(gap_durs)
trial_dur = (letter_dur * (n_cue_let + n_targ_let) + cue_targ_gap +
np.mean(gap_durs) + inter_trial_dur)
exp_dur = trial_dur * n_trials
print('Experiment duration: %s min (%s blocks)' %
def demo_trial(ti, title, tstr):
ec.screen_prompt(demo_instr, color=fcolor)
samples = read_wav(op.join(stim_dir, p['stim_names'][ti]))[0]
ec.load_buffer(samples)
these_letters = [[p['letters'][ii] for ii in row]
for row in p['letter_mat'][ti]]
# init and draw letters
let_times = p['stim_times'][p['cond_mat'][ti][3]]
xs = (let_times - let_times[0]) / (let_times[-1] - let_times[0])
xs = xs / 2.
ys = [0.1, -0.1]
let_colors = [(0.25, ) * 3, 'w', (0., 1., 0.)]
sw_trial = (p['cond_mat'][ti, 0] == sw_id)
assert tstr in ('male', 'female')
strs = ['Male:', 'Female:'] if tstr == 'male' else ['Female:', 'Male:']
cues = [
visual.Text(ec,
s, [-0.1, y],
anchor_x='right',
font_size=48,
color=let_colors[1 - ii])
for ii, (s, y) in enumerate(zip(strs, ys))
]
title = visual.Text(ec,
title, [-0.1, 0.4],
font_size=36,
color='w',
anchor_x='left')
for ii, y in enumerate(ys):
for jj, x in enumerate(xs):
if ii == 0 or jj >= p['n_cue_let']:
if jj >= p['n_cue_let']:
let = these_letters[ii][jj]
else:
let = 'A' if jj == 0 or not sw_trial else 'U'
letters[ii][jj] = visual.Text(ec,
let, [x, y],
font_size=48,
anchor_x='left',
color=let_colors[0])
letters[ii][jj].draw()
title.draw()
[c.draw() for c in cues]
ec.flip()
ec.wait_secs(2.0) # show stim for a bit
for tidx, t in enumerate(let_times):
color = let_colors[1]
ii = 0
if tidx >= p['n_cue_let'] and \
p['targ_pos'][ti][0][tidx-p['n_cue_let']]:
color = let_colors[2]
if sw_trial and tidx >= p['n_cue_let'] + p['gap_after']:
ii = 1
letters[ii][tidx].set_color(color)
for jj in range(len(let_times)):
for ii in range(2):
if ii == 0 or jj >= p['n_cue_let']:
letters[ii][jj].draw()
title.draw()
[c.draw() for c in cues]
if tidx == 0:
t0 = ec.start_stimulus(flip=True, start_of_trial=False)
else:
ec.flip(t0 + t)
ec.flip(t0 + p['trial_durs'][ti])
ec.stop()
ec.screen_prompt('Press a button to continue.', color=fcolor)
def recordTrial(wheel_matrix_info, preblock, block_ind, bnum, instr, ec,
stimdir, final_datadir, record_pupil, record_correct,
save_correct):
""" Takes the indice of all current condition types and the binary
name of the condition to find the trial wav. Displays instructions
according to instr() and plays stimuli while recording and logging
pupillometry data. """
# identify paradigm and trial number
#start_time = timeit.default_timer()
trial_vars = getTrialInfo(block_ind, bnum)
#elapsed = timeit.default_timer() - start_time
#print 'load mat ' + str(elapsed) + '\n'
data_file_name = 'b' + str(bnum) + '_tr' + str(block_ind[bnum])
stim_file_name = 'b' + str(bnum) + '_tr' + str(block_ind[bnum]) + '.wav'
trial_stim_path = op.join(stimdir, stim_file_name)
# UNLOAD TRIAL VARS (AVOIDS AWKWARD INDEXING)
# Creates dict of vars: 'target_letter', 'target_time',
# 'tot_wav_time', 'paradigm', 'possible_letters' 'tot_cyc'
target_cycles = trial_vars['target_cycles']
id_list = trial_vars['trial_id'][0].tolist()
target_letter = trial_vars['target_letter'][0][0][0].encode('ascii')
possible_letters = trial_vars['possible_letters'][0]
final_vars = dict()
final_vars['trial_id'] = id_list
# load WAVs for this block
#start_time = timeit.default_timer()
stims = []
stims.append(read_wav(trial_stim_path)[0]) # ignore fs
stim_dur = stims[0].shape[-1] / ec.stim_fs
#elapsed = timeit.default_timer() - start_time
ec.clear_buffer()
ec.load_buffer(stims[0])
#elapsed = timeit.default_timer() - start_time
#print 'load stimuli ' + str(elapsed) + '\n'
# draw visual primer
drawPrimer(wheel_matrix_info, target_letter, possible_letters)
# make screenshots
#screenshot = ec.screenshot()
#screen_obj = op.join(edf_outputdir, str(block_ind[bnum]) +
#'screenshot.obj')
#screenshot_file = open(screen_obj, 'w')
#pck.dump(screenshot, screenshot_file)
# edf stamped for epoch starts
ec.identify_trial(ec_id=id_list, el_id=id_list, ttl_id=id_list)
#if record_pupil:
#ec.identify_trial(ec_id=id_list, el_id=id_list, ttl_id=id_list)
#else:
#try:
#ec.identify_trial(ec_id=id_list, ttl_id=id_list)
#except:
#ec.identify_trial(ec_id=id_list, el_id=id_list, ttl_id=id_list)
ec.start_stimulus(flip=True) # the visual primer is displayed
if debug:
ec.wait_secs(2)
else:
ec.wait_secs(vPrimerLen)
# Draw fixation dot to visual buffer
fix = visual.FixationDot(ec, colors=['whitesmoke', 'whitesmoke'])
fix.draw()
ec.flip() # the fixation dot is displayed
if debug:
ec.wait_secs(1)
else:
# wait until stim has finished
ec.wait_secs(stim_dur - vPrimerLen)
ec.wait_secs(postblock)
# clear screen
ec.flip()
#write all pertinent data as a safety
if record_pupil:
ec.write_data_line('target_letter', target_letter)
ec.write_data_line('target_cycles', target_cycles)
ec.stop()
ec.trial_ok()
# update indexer
block_ind[bnum] += 1
if (record_correct):
response = promptResponse(ec)
if (response == target_cycles):
correct = 1
else:
correct = 0
ec.write_data_line('correct: ', correct)
if save_correct:
final_dfn = data_file_name + 'final'
# save with other edf files for exp
out_path = op.join(edf_outputdir, final_dfn)
# add in an extra 'correct' data field
final_vars['correct'] = correct
sio.savemat(out_path, final_vars)
return correct
else:
return 0
def test_read_write_wav():
"""Test reading and writing WAV files
"""
fname = op.join(tempdir, 'temp.wav')
data = np.r_[np.random.rand(1000), 1, -1]
fs = 44100
# Use normal 16-bit precision: not great
write_wav(fname, data, fs)
data_read, fs_read = read_wav(fname)
assert_equal(fs_read, fs)
assert_array_almost_equal(data[np.newaxis, :], data_read, 4)
# test our overwrite check
assert_raises(IOError, write_wav, fname, data, fs)
# test forcing fs dtype to int
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
write_wav(fname, data, float(fs), overwrite=True)
assert_equal(len(w), 1)
# Use 64-bit int: not supported
assert_raises(RuntimeError,
write_wav,
fname,
data,
fs,
dtype=np.int64,
overwrite=True)
# Use 32-bit int: better
write_wav(fname, data, fs, dtype=np.int32, overwrite=True)
data_read, fs_read = read_wav(fname)
assert_equal(fs_read, fs)
assert_array_almost_equal(data[np.newaxis, :], data_read, 7)
if _has_scipy_version('0.13'):
# Use 32-bit float: better
write_wav(fname, data, fs, dtype=np.float32, overwrite=True)
data_read, fs_read = read_wav(fname)
assert_equal(fs_read, fs)
assert_array_almost_equal(data[np.newaxis, :], data_read, 7)
# Use 64-bit float: perfect
write_wav(fname, data, fs, dtype=np.float64, overwrite=True)
data_read, fs_read = read_wav(fname)
assert_equal(fs_read, fs)
assert_array_equal(data[np.newaxis, :], data_read)
else:
assert_raises(RuntimeError,
write_wav,
fname,
data,
fs,
dtype=np.float32,
overwrite=True)
# Now try multi-dimensional data
data = np.tile(data[np.newaxis, :], (2, 1))
write_wav(fname, data[np.newaxis, :], fs, overwrite=True)
data_read, fs_read = read_wav(fname)
assert_equal(fs_read, fs)
assert_array_almost_equal(data, data_read, 4)
# Make sure our bound check works
assert_raises(ValueError, write_wav, fname, data * 2, fs, overwrite=True)