def single_file(filename, x):
controller.reset()
controller.filesNew(filename, st)
finger_midi = 0.0
controller.comment("attack inst %i st %i dyn %i finger_midi %.3f"
% (inst_type, st, dyn, finger_midi))
begin = vivi_controller.NoteBeginning()
begin.physical.string_number = st
begin.physical.bow_force = fbi
begin.physical.dynamic = prev_dyn
begin.physical.bow_bridge_distance = dynamics.get_distance(
inst_type, prev_dyn)
begin.physical.bow_velocity = dynamics.get_velocity(
inst_type, prev_dyn)
end = vivi_controller.NoteEnding()
for i in range(REPS):
controller.reset(True)
finger_midi = prev_fmi
begin.physical.finger_position = utils.midi2pos(finger_midi)
controller.note(begin, NOTE_LENGTH, end)
#controller.rest(0.1)
begin.physical.dynamic = dyn
begin.physical.bow_bridge_distance = dynamics.get_distance(
inst_type, dyn)
begin.physical.bow_velocity = dynamics.get_velocity(
inst_type, dyn)
finger_midi = 0.0
begin.physical.bow_force = x
begin.physical.finger_position = utils.midi2pos(finger_midi)
begin.physical.bow_velocity *= -1
controller.note(begin, NOTE_LENGTH, end)
controller.filesClose()
def single_file(filename, x):
controller.reset()
controller.filesNew(filename, st)
finger_midi = 0.0
controller.comment("attack inst %i st %i dyn %i finger_midi %.3f" %
(inst_type, st, dyn, finger_midi))
begin = vivi_controller.NoteBeginning()
begin.physical.string_number = st
begin.physical.bow_force = fbi
begin.physical.dynamic = prev_dyn
begin.physical.bow_bridge_distance = dynamics.get_distance(
inst_type, prev_dyn)
begin.physical.bow_velocity = dynamics.get_velocity(
inst_type, prev_dyn)
end = vivi_controller.NoteEnding()
for i in range(REPS):
controller.reset(True)
finger_midi = prev_fmi
begin.physical.finger_position = utils.midi2pos(finger_midi)
controller.note(begin, NOTE_LENGTH, end)
#controller.rest(0.1)
begin.physical.dynamic = dyn
begin.physical.bow_bridge_distance = dynamics.get_distance(
inst_type, dyn)
begin.physical.bow_velocity = dynamics.get_velocity(inst_type, dyn)
finger_midi = 0.0
begin.physical.bow_force = x
begin.physical.finger_position = utils.midi2pos(finger_midi)
begin.physical.bow_velocity *= -1
controller.note(begin, NOTE_LENGTH, end)
controller.filesClose()
def audio_params_to_physical(audio_params, dyn, physical):
physical.string_number = audio_params.string_number
physical.dynamic = dyn
physical.finger_position = utils.midi2pos(audio_params.finger_midi)
physical.bow_force = audio_params.bow_force
physical.bow_bridge_distance = audio_params.bow_bridge_distance
physical.bow_velocity = audio_params.bow_velocity
return None # it's done with pass-by-reference
def audio_params_to_physical(audio_params, dyn, physical):
physical.string_number = audio_params.string_number
physical.dynamic = dyn
physical.finger_position = utils.midi2pos(audio_params.finger_midi)
physical.bow_force = audio_params.bow_force
physical.bow_bridge_distance = audio_params.bow_bridge_distance
physical.bow_velocity = audio_params.bow_velocity
return None # it's done with pass-by-reference
def single_file(bow_force, count, K):
finger_midi = basic_training.FINGER_MIDIS[self.fmi]
# FIXME: oh god ick
ap = vivi_types.AudioParams( self.st,
finger_midi,
dynamics.get_distance(self.inst_type,
self.dyn),
bow_force,
dynamics.get_velocity(self.inst_type,
self.dyn))
attack_filename = self.files.make_attack_filename(
self.taskname+'-%.2f' % K,
ap, count)
#print attack_filename
self.controller.reset()
self.controller.filesNew(attack_filename, self.st)
self.controller.comment("attack inst %i st %i dyn %i finger_midi %.3f"
% (self.inst_type, self.st, self.dyn, finger_midi))
begin = vivi_controller.NoteBeginning()
begin.physical.string_number = self.st
begin.physical.dynamic = self.dyn
begin.physical.finger_position = utils.midi2pos(finger_midi)
begin.physical.bow_force = bow_force
begin.physical.bow_bridge_distance = dynamics.get_distance(
self.inst_type, self.dyn)
begin.physical.bow_velocity = dynamics.get_velocity(
self.inst_type, self.dyn)
orig_velocity = begin.physical.bow_velocity
end = vivi_controller.NoteEnding()
#if finger_midi != 0:
# self.process_step.emit()
# return
#print "------"
for i, bow_direction in enumerate([1, -1]*RAPS):
self.controller.reset(True)
#print i, bow_direction
begin.physical.bow_velocity = orig_velocity * bow_direction
self.controller.note(begin, ATTACK_LENGTH, end)
#if i % 4 < 2:
# self.controller.note(begin, ATTACK_LENGTH, end)
#else:
# self.controller.note(begin, SHORT_ATTACK_LENGTH, end)
#if i % 4 == 3:
#if i % 2 == 1:
#if True:
#print "reset"
# self.controller.reset(True)
self.controller.filesClose()
self.kept_files.append(attack_filename)
self.process_step.emit()
def make_file_force(bow_force, fmi, count):
self.controller.set_stable_K(self.st, self.dyn, fmi, K)
self.controller.set_stable_K_main(self.st, self.dyn, fmi, K_main)
finger_midi = basic_training.FINGER_MIDIS[fmi]
# FIXME: oh god ick
ap = vivi_types.AudioParams( self.st,
finger_midi,
dynamics.get_distance(self.inst_type,
self.dyn),
bow_force,
dynamics.get_velocity(self.inst_type,
self.dyn))
attack_filename = self.files.make_attack_filename(
self.taskname,
ap, count)
#print attack_filename
self.controller.reset()
self.controller.filesNew(attack_filename, self.st)
self.controller.comment("verify inst %i st %i dyn %i finger_midi %.3f"
% (self.inst_type, self.st, self.dyn, finger_midi))
begin = vivi_controller.NoteBeginning()
begin.physical.string_number = self.st
begin.physical.dynamic = self.dyn
begin.physical.finger_position = utils.midi2pos(finger_midi)
begin.physical.bow_force = bow_force
begin.physical.bow_bridge_distance = dynamics.get_distance(
self.inst_type, self.dyn)
begin.physical.bow_velocity = dynamics.get_velocity(
self.inst_type, self.dyn)
end = vivi_controller.NoteEnding()
#end.keep_bow_velocity = True
for bow_direction in [1, -1, 1, -1]:
self.controller.reset(True)
begin.physical.bow_velocity *= bow_direction
#begin.physical.bow_force = bow_force
#begin.keep_ears = False
#begin.keep_bow_force = False
#self.controller.note(begin, ATTACK_LENGTH, end)
#begin.physical.bow_force = bow_force*0.8
#begin.keep_ears = True
#begin.keep_bow_force = True
#self.controller.note(begin, STABLE_LENGTH-ATTACK_LENGTH, end)
self.controller.note(begin, STABLE_LENGTH, end)
self.controller.filesClose()
#self.process_step.emit()
return attack_filename
def make_file_force(bow_force, fmi, count):
self.controller.set_stable_K(self.st, self.dyn, fmi, K)
self.controller.set_stable_K_main(self.st, self.dyn, fmi, K_main)
finger_midi = basic_training.FINGER_MIDIS[fmi]
# FIXME: oh god ick
ap = vivi_types.AudioParams(
self.st, finger_midi,
dynamics.get_distance(self.inst_type, self.dyn), bow_force,
dynamics.get_velocity(self.inst_type, self.dyn))
attack_filename = self.files.make_attack_filename(
self.taskname, ap, count)
#print attack_filename
self.controller.reset()
self.controller.filesNew(attack_filename, self.st)
self.controller.comment(
"verify inst %i st %i dyn %i finger_midi %.3f" %
(self.inst_type, self.st, self.dyn, finger_midi))
begin = vivi_controller.NoteBeginning()
begin.physical.string_number = self.st
begin.physical.dynamic = self.dyn
begin.physical.finger_position = utils.midi2pos(finger_midi)
begin.physical.bow_force = bow_force
begin.physical.bow_bridge_distance = dynamics.get_distance(
self.inst_type, self.dyn)
begin.physical.bow_velocity = dynamics.get_velocity(
self.inst_type, self.dyn)
end = vivi_controller.NoteEnding()
#end.keep_bow_velocity = True
for bow_direction in [1, -1, 1, -1]:
self.controller.reset(True)
begin.physical.bow_velocity *= bow_direction
#begin.physical.bow_force = bow_force
#begin.keep_ears = False
#begin.keep_bow_force = False
#self.controller.note(begin, ATTACK_LENGTH, end)
#begin.physical.bow_force = bow_force*0.8
#begin.keep_ears = True
#begin.keep_bow_force = True
#self.controller.note(begin, STABLE_LENGTH-ATTACK_LENGTH, end)
self.controller.note(begin, STABLE_LENGTH, end)
self.controller.filesClose()
#self.process_step.emit()
return attack_filename
def make_zoom_file(self, start, dur, files):
print "make_zoom_file, range of seconds from orig: %.3f %.3f" % (
start, dur)
self.files = files
force = 0.0
### get params from note
#print starthop, endhop
### quantify based on hopsize
starthop = int((start - self.note_start) * HOP_SECONDS)
endhop = int((start + dur - self.note_start) * HOP_SECONDS)
# no, *don't* make this based on the note,
# otherwise it won't work in music!
start = float(int(start * HOP_SECONDS)) / HOP_SECONDS
dur = float(int(endhop - starthop)) / HOP_SECONDS
print "starthop, endhop:\t%i\t%i" % (starthop, endhop)
print "Should have lines:\t%i" % (endhop - starthop + 1)
#print "start, dur:\t%i\t%i" % (start, dur)
#for l in self.note_lines:
# print l
#print start, dur
### initial note estimates
# assume string doesn't change
fm = self.note_finger
bbd = 0.0
force = 0.0
bv = 0.0
#for i in range(0, starthop+1):
for i in range(0, starthop + 1):
line = self.note_lines[i].split()
if line[0] == 'b' or line[0] == 'a':
bbd = float(line[3])
force = float(line[4])
bv = float(line[5])
if line[0] == 'f':
fm = utils.pos2midi(float(line[3]))
bbd = [bbd]
force = [force]
bv = [bv]
for i in range(0, starthop + 1):
line = self.note_lines[i].split()
if line[0] == 'b' or line[0] == 'a':
bbd.append(float(line[3]))
force.append(float(line[4]))
bv.append(float(line[5]))
if line[0] == 'f':
fm = utils.pos2midi(float(line[3]))
audio_params = vivi_types.AudioParams(self.note_st, fm,
numpy.median(bbd),
numpy.median(force),
numpy.median(bv))
### filename
filename = self.files.make_zoom_filename(audio_params)
print "ZOOM file:\t", filename
# create .wav
cmd = 'sox %s -t wavpcm %s trim %f %f' % (self.basename + '-s%i.wav' %
(self.note_st), filename +
'.wav', start, dur)
#print cmd
os.system(cmd)
# create .forces..wav
cmd = 'sox %s -t wavpcm %s trim %f %f' % (
self.basename + '-s%i.forces.wav' %
(self.note_st), filename + '.forces.wav', start, dur)
#print cmd
os.system(cmd)
# create .actions
out = open(filename + '.actions', 'w')
out.write(self.note_prelim_line)
# TODO: clean this up!
#first_seconds = -1
printed_finger = False
#num_lines = 0
for line in self.note_lines:
splitline = line.split()
seconds = float(splitline[1])
#print seconds, first_seconds, start, start+dur
if line[0] == 'f':
fm = float(splitline[3])
if seconds >= (start - 0.001):
#if first_seconds < 0:
# first_seconds = seconds
#seconds = seconds - first_seconds
if seconds <= (start + dur + 0.001):
now = round(seconds - start, 3)
if now == -0.0:
now = 0.0
splitline[1] = str(now)
if not printed_finger:
if splitline[0][0] == 'f':
pass
else:
data = [
'f',
str(now),
str(self.note_st),
str(utils.midi2pos(fm))
]
finger_line = "\t".join(data) + "\n"
print finger_line,
out.write(finger_line)
printed_finger = True
done_line = "\t".join(splitline) + "\n"
print done_line,
out.write(done_line)
out.close()
return filename
def make_zoom_file(self, start, dur, files):
print "make_zoom_file, range of seconds from orig: %.3f %.3f" % (start, dur)
self.files = files
force = 0.0
### get params from note
#print starthop, endhop
### quantify based on hopsize
starthop = int((start-self.note_start) * HOP_SECONDS)
endhop = int((start+dur-self.note_start) * HOP_SECONDS)
# no, *don't* make this based on the note,
# otherwise it won't work in music!
start = float(int(start * HOP_SECONDS)) / HOP_SECONDS
dur = float( int(endhop-starthop)) / HOP_SECONDS
print "starthop, endhop:\t%i\t%i" % (starthop, endhop)
print "Should have lines:\t%i" %(endhop-starthop+1)
#print "start, dur:\t%i\t%i" % (start, dur)
#for l in self.note_lines:
# print l
#print start, dur
### initial note estimates
# assume string doesn't change
fm = self.note_finger
bbd = 0.0
force = 0.0
bv = 0.0
#for i in range(0, starthop+1):
for i in range(0, starthop+1):
line = self.note_lines[i].split()
if line[0] == 'b' or line[0] == 'a':
bbd = float(line[3])
force = float(line[4])
bv = float(line[5])
if line[0] == 'f':
fm = utils.pos2midi(float(line[3]))
bbd = [bbd]
force = [force]
bv = [bv]
for i in range(0, starthop+1):
line = self.note_lines[i].split()
if line[0] == 'b' or line[0] == 'a':
bbd.append( float(line[3]) )
force.append( float(line[4]) )
bv.append( float(line[5]) )
if line[0] == 'f':
fm = utils.pos2midi(float(line[3]))
audio_params = vivi_types.AudioParams(
self.note_st, fm,
numpy.median(bbd),
numpy.median(force),
numpy.median(bv))
### filename
filename = self.files.make_zoom_filename(audio_params)
print "ZOOM file:\t", filename
# create .wav
cmd = 'sox %s -t wavpcm %s trim %f %f' % (
self.basename+'-s%i.wav' % (self.note_st),
filename+'.wav', start, dur)
#print cmd
os.system(cmd)
# create .forces..wav
cmd = 'sox %s -t wavpcm %s trim %f %f' % (
self.basename+'-s%i.forces.wav' % (self.note_st),
filename+'.forces.wav', start, dur)
#print cmd
os.system(cmd)
# create .actions
out = open(filename+'.actions', 'w')
out.write(self.note_prelim_line)
# TODO: clean this up!
#first_seconds = -1
printed_finger = False
#num_lines = 0
for line in self.note_lines:
splitline = line.split()
seconds = float(splitline[1])
#print seconds, first_seconds, start, start+dur
if line[0] == 'f':
fm = float(splitline[3])
if seconds >= (start - 0.001):
#if first_seconds < 0:
# first_seconds = seconds
#seconds = seconds - first_seconds
if seconds <= (start + dur + 0.001):
now = round(seconds - start, 3)
if now == -0.0:
now = 0.0
splitline[1] = str(now)
if not printed_finger:
if splitline[0][0] == 'f':
pass
else:
data = ['f', str(now),
str(self.note_st),
str(utils.midi2pos(fm))]
finger_line = "\t".join(data) + "\n"
print finger_line,
out.write(finger_line)
printed_finger = True
done_line = "\t".join(splitline) + "\n"
print done_line,
out.write(done_line)
out.close()
return filename
def note(note_midi, direction):
#violin.bow(0, bp, force, direction*velocity)
#violin.bow(0, bp, force, direction*velocity)
violin.finger(0, utils.midi2pos(note_midi))
out = wavfile.request_fill(samples)
violin.wait_samples(out, samples)
