def expressionOLD(alignment):

    melody = tools.parseScore(melodyscore)
    lastnote = None
    lastscorenote = None

    mean_vel = 0.0
    skipped = 0
    for note in melody:
        scoreindex = note.annotation
        scorenote = melodyscore[scoreindex[0]][scoreindex[1]][scoreindex[2]][scoreindex[3]]
        deviation = alignment.alignment[scorenote.id, str(scorenote.pitch)]
        if not deviation:
            skipped += 1
            continue
        mean_vel += deviation[2] * 100.0

    mean_vel = mean_vel / float(len(melody) - skipped)

    expression = []
    lasttempo = float(alignment.deviations.bpm)
    lastdynamics = mean_vel
    lastdeviation = (0, 0, 1, 1)
    for note in melody:
        scoreindex = note.annotation
        scorenote = melodyscore[scoreindex[0]][scoreindex[1]][scoreindex[2]][scoreindex[3]]
        measure = melodyscore[scoreindex[0]][scoreindex[1]].number

        deviation = alignment.alignment[scorenote.id, str(scorenote.pitch)]

        if not deviation:
            deviation = lastdeviation
        attack = deviation[0]
        release = deviation[1]
        dynamics = deviation[2]
        relative_dynamics = dynamics * 100.0 / lastdynamics

        if (measure, int(scorenote.offset)) in alignment.deviations.tempo_deviations:
            tempo = alignment.deviations.tempo_deviations[measure, int(scorenote.offset)] * alignment.deviations.bpm
        else:
            print("{0} {1} not found in tempo deviations".format(measure, int(scorenote.offset)))
            tempo = lasttempo
        relative_tempo = tempo / lasttempo
        lasttempo = tempo
        lastdynamics = dynamics * 100.0
        expression.append((attack, release, dynamics, math.log(relative_tempo), math.log(relative_dynamics)))

        lastnote = note
        lastscorenote = scorenote
        lastdeviation = deviation
    return expression
Ejemplo n.º 2
0
def vanDerWeijFeatures(melodyscore, segments):
    # This is radically different, we only look at features at constituent level
    melody = tools.parseScore(melodyscore)

    features = []
    index = 0
    for i in range(len(segments)):
        #if i > 0:
        #  segments[i] = [segments[i-1][len(segments[i-1])-1]] + segments[i]
        length = len(segments[i])
        # Calculate features:

        pitch_int = structure.bare_deltalist(structure.pitch, segments[i])
        abs_pitch_int = structure.absolute_deltalist(structure.pitch, segments[i])
        pitches = [structure.pitch(segments[i], j) for j in range(len(segments[i]))]
        durations = [structure.duration(segments[i], j) for j in range(len(segments[i]))]

        avg_pitch = 1/float(length) * sum(pitches)
        dPitch = 1/float(length) * sum(pitch_int)
        abs_dPitch = 1/float(length) * sum(abs_pitch_int)
        ddPitch = 1/float(length) * sum(structure.second_order_deltalist(pitch_int))
        abs_ddPitch = 1/float(length) * sum(structure.second_order_deltalist(abs_pitch_int))

        avg_duration_ratio = 0
        avg_duration = 1/float(length) * sum(durations)
        dDuration = 1/float(length) * sum(structure.bare_deltalist(structure.duration, segments[i]))
        abs_dDuration = 1/float(length) * sum(structure.absolute_deltalist(structure.duration, segments[i]))
        ddDuration = 1/float(length) * sum(structure.second_order_deltalist(structure.bare_deltalist(structure.duration, segments[i])))
        abs_ddDuration = 1/float(length) * sum(structure.second_order_deltalist(structure.absolute_deltalist(structure.duration, segments[i])))

        silence = 1/float(length) * sum([structure.silence(segments[i], j+1) for j in range(len(segments[i])-1)])

        onsets = structure.normalize([n.on for n in segments[i]])
        pitches = structure.normalize([n.pitch for n in segments[i]])
        if len(onsets) == 1:
            pitch_direction = 0
        else:
            pitch_direction = pf.linear_fit(onsets, pitches)[1]

        # Polyfony?
        # Score markings?
        features.append((avg_pitch, dPitch, abs_dPitch, ddPitch, abs_ddPitch,\
            avg_duration, dDuration, abs_dDuration, ddDuration, abs_ddDuration,\
            silence, pitch_direction, length))

#featureset = ['avg_pitch', 'dPitch', 'abs_dPitch', 'ddPitch', 'abs_ddPitch',\
#    'avg_duration', 'dDuration', 'abs_dDuration', 'ddDuration',\
#    'abs_ddDuration', 'silence', 'pitch_direction']
    return features
def expressionWidmer(alignment):
    performance = alignment.expressiveMelody()
    melodyscore = alignment.melody()
    score = tools.parseScore(melodyscore)
    # The two above should be guaranteed to be of equal length.
    # However, better be safe than sorry
    if len(performance) != len(score):
        print('This shouldn\'t happen: melodyscore and performance lengths don\'t match: {0} and {1}'.format(len(score), len(performance)))
    else:
        print("This is good, performance length and score length match")

    # Mean loudness
    mean_l = 0.0
    for note in performance:
        mean_l += note.onvelocity

    mean_l = mean_l / float(len(performance))

    expression = []
    lasttempo = float(alignment.deviations.bpm)
    lastdynamics = mean_l

    # Assume same note order in score and performance (am I being naive?)
    for i in range(len(performance)):
        ioi_ratio = math.log(structure.ioi(performance, i) / float(structure.ioi(score, i)))
        loudness_ratio = math.log(performance[i].onvelocity / mean_l)

        # This obviously results in zero divisions
        #articulation = math.log(structure.silence(performance, i) / float(structure.silence(score, i)))
        articulation = 0

        if(structure.duration(performance, i) < 1):
            print("Invalid performance note :( skipping")
            continue
        duration_ratio = math.log(structure.duration(performance, i) / float(structure.duration(score, i)))

        # To be implemented: second order ioi loudness and articulation
        ioi_change = 0
        loudness_change = 0
        articulation_change = 0

        # E = (ioi_r, loudness_r, articulation, duration_r, ioi_ch, loundess_ch)
        e = (ioi_ratio, loudness_ratio, articulation, duration_ratio, ioi_change, loudness_change)
        expression.append(e)


    return expression
Ejemplo n.º 4
0
def features1(melodyscore):
    melody = tools.parseScore(melodyscore)
    onset_segments = structure.bestgrouping(melody, structure.second_order_tree(structure.onset, melody, 0.1))
    pitch_segments = structure.bestgrouping(melody, structure.second_order_tree(structure.pitch, melody, 0.1))
    features = [[] for i in range(len(melody))]

    index = 0
    for i in range(len(onset_segments)):
        start = onset_segments[i][0].on
        end = onset_segments[i][len(onset_segments[i])-1].off
        length = float(end - start)
        if not i+1 >= len(onset_segments):
            end = onset_segments[i+1][0].on

        for note in onset_segments[i]:
            pos = note.on - start
            rel_pos = discretize(0, 1, pos / length, 10)
            features[index] = [rel_pos]
            index += 1

    index = 0
    for i in range(len(pitch_segments)):
        start = pitch_segments[i][0].on
        end = pitch_segments[i][len(pitch_segments[i])-1].off
        length = float(end - start)
        if not i+1 >= len(pitch_segments):
            end = pitch_segments[i+1][0].on

        for note in pitch_segments[i]:
            pos = note.on - start
            rel_pos = discretize(0, 1, pos / length, 10)
            features[index].append(rel_pos)
            index += 1

    for i in range(len(melody)):
        features[i].append(pitch_interval(melody, i))
        features[i].append(duration_ratio(melody, i))

    return features
Ejemplo n.º 5
0
def widmerFeatures(melodyscore):
    melody = tools.parseScore(melodyscore)
    onset_segments = structure.bestgrouping(melody, structure.second_order_tree(structure.onset, melody, 0.1))
    pitch_segments = structure.bestgrouping(melody, structure.second_order_tree(structure.pitch, melody, 0.1))
    features = [[] for i in range(len(melody))]

    index = 0
    for i in range(len(onset_segments)):
        start = onset_segments[i][0].on
        end = onset_segments[i][len(onset_segments[i])-1].off
        length = float(end - start)
        if not i+1 >= len(onset_segments):
            end = onset_segments[i+1][0].on

        for note in onset_segments[i]:
            nearest_border = min(end - note.on, note.on - start)
            features[index] = [nearest_border]
            index += 1

    index = 0
    for i in range(len(pitch_segments)):
        start = pitch_segments[i][0].on
        end = pitch_segments[i][len(pitch_segments[i])-1].off
        length = float(end - start)
        if not i+1 >= len(pitch_segments):
            end = pitch_segments[i+1][0].on

        for note in pitch_segments[i]:
            nearest_border = min(end - note.on, note.on - start)
            features[index].append(nearest_border)
            index += 1

    for i in range(len(melody)):
        features[i].append(pitch_interval(melody, i))
        features[i].append(duration_ratio(melody, i))
    print(features[10])
    return features
Ejemplo n.º 6
0
def train(trainset):

    expression = {}
    features = {}
    const = 0
    Max = 0
    Min = None
    count = 0
    print(">>> Loading scores and deviations, this will take hours and may eat all you memory")

    for query in trainset:
        print(">>> Loading: {0}".format(query))
        score = db.getScore1(query)
        deviations = db.getDeviation1(query)
        alignment = Alignment(score, deviations)
        melody = alignment.melody()
        #segments = structure.newSegmentation(tools.parseScore(melody))
        segments = structure.noteLevel(tools.parseScore(melody))
        const += len(segments)
        lengths = sum([len(s) for s in segments])
        m = max([len(s) for s in segments])
        mi = min([len(s) for s in segments])
        if m > Max:
            Max = m
        if not Min:
            Min = mi
        if mi < Min:
            Min = mi
        print('>>> Extracting features')
        expression[query] = performancefeatures.vanDerWeijExpression(alignment, segments)
        features[query] = scorefeatures.vanDerWeijFeatures(melody, segments)
        count += 1
        print('{0}/{1} done'.format(count, len(trainset)))

    print("Done, {0} segments found with an average length of: {1} (min: {2} max: {3})".format(const, lengths / float(const), Min, Max))
    tools.saveFeatures(features, expression)
Ejemplo n.º 7
0
if __name__ == '__main__':
    import sys
    if len(sys.argv) > 1:
        l = [int(x) for x in sys.argv[1:]]
        print(relative_deltalist(test, l))
        print(second_order_tree(test, l, 0.0, deltalist_function=relative_deltalist))
        print(second_order_tree(test, l, 0.0))
        sys.exit(0)

    import database as db
    import tools
    w = db.select()
    score = Score(db.getScore1(w))
    melodyscore = score.melody()
    #melodyscore.show()
    melody = tools.parseScore(melodyscore, list(range(1, 9)))
    trees = [second_order_tree(onset, melody, 0.5), second_order_tree(pitch, melody, 0.0, ), first_order_tree(onset, melody, 0.0), first_order_tree(pitch, melody)]

    for tree in trees:
        print("Tree")
        print(tools.recursive_print(tree))


    for i in range(5):
        for j in range(len(trees)):
            groups = groupings(list_to_tree(trees[j]), i)
            avg_group = 0
            for group in groups:
                avg_group += len(group)
            avg_group /= float(len(groups))
            print("Tree: {0} Level {1} group size {2}".format(j, i, avg_group))
Ejemplo n.º 8
0
import database as db
from alignment import *
from representation import *
from sequencer import *
from score import *
import tools

selection = db.select()
score = db.getScore1(selection)
notes = tools.parseScore(score)
seq = Sequencer()
seq.play(notes)
#s = Score(alignment.score, alignment)
Ejemplo n.º 9
0
import database as db
from sequencer import *
from alignment import *
import structure, tools
import scorefeatures as sf
import performancefeatures as pf
import perform

s = db.select()
a = Alignment(db.getScore1(s), db.getDeviation1(s))
melodyscore = a.melody()
melody = tools.parseScore(melodyscore)
onset = structure.groupings(structure.list_to_tree(structure.first_order_tree(structure.onset, melody, 0.1)), 1)
score = sf.vanDerWeijFeatures(melodyscore, onset)
performance = pf.vanDerWeijExpression(a, onset)

print(score)
print(performance)

seq = Sequencer()
seq.play(perform.vanDerWeijPerformSimple(a.score, melodyscore, onset, performance, bpm=a.deviations.bpm, converter=melody))
Ejemplo n.º 10
0
 def getNoteList():
     return tools.parseScore(self.score)
Ejemplo n.º 11
0
    for i in l:
        result.append(i*i)
    return result

if len(sys.argv) > 1:
    notes = sys.argv[1]
    deltas = [int(x) for x in sys.argv[2]]
    s3 = structure.second_order_deltarule(notes, deltas, 0)
    print(tools.recursive_print(s3))
    sys.exit(0)


selection = db.select()
score = Score(db.getScore1(selection).stripTies())
melody = score.melody()
notes = tools.parseScore(melody)
deltas = []


print("COMBINED DELTA TREES")
#for feature in [structure.pitch, structure.onset]:
#  deltas.append(normalize(structure.repetition(feature, notes)))

for feature in [structure.onset, structure.duration, structure.pitch]:
    print(">>>> {0} absolute:".format(feature))
    print(structure.absolute_deltalist(feature, notes))
    print(">>>> {0} relative:".format(feature))
    print(structure.relative_deltalist(feature, notes))


#deltas.append(normalize(square(structure.absolute_deltalist(structure.onset, notes))))
Ejemplo n.º 12
0
# Load all the scores and notelists

#while True:
#  print db.select()
print(">>>> Loading materials.....")

schumann = ('Schumann', 'kdz007', 'ashke', 'GPO-Concert-Steinway-ver2.sf2')
mozart1 = ('Mozart', 'snt331-3', 'nakam', 'GPO-Concert-Steinway-ver2.sf2')
chopin1 = ('Chopin', 'wlz010', 'ashke', 'Bosendorfer PIANO / GIGA')
mozart2 = ('Mozart', 'snt331-1', 'mo', None)
lastig = ('Bach', 'wtc219-f', 'richt', 'GPO-Concert-Steinway-ver2.sf2')

score = Score(db.getScore1(chopin1).stripTies())
melody = score.melody()
chopinnotes = tools.parseScore(melody)
delta = structure.absolute_deltalist(structure.onset, chopinnotes)
sodelta1 = structure.normalize(structure.second_order_deltalist(delta))

score = Score(db.getScore1(mozart2).stripTies())
melody = score.melody()
mozartnotes = tools.parseScore(melody)
delta2 = structure.square(structure.absolute_deltalist(structure.pitch, mozartnotes))
sodelta2 = structure.normalize(structure.second_order_deltalist(delta2))

s1 = structure.second_order_deltarule(chopinnotes, sodelta1, 0.1)
s2 = structure.second_order_deltarule(mozartnotes, sodelta2, 0.1)

while True:
    choice = util.menu("Select", ['Schumann exp', 'Schumann score', 'Schumann noexp', 'chopin struct', 'lastig struct bach', 'struct moz'])
    if choice == 0: