spiffyscore

Changes On Branch 299ddec90ea4a6b7
Login

Changes On Branch 299ddec90ea4a6b7

Changes In Branch tree Excluding Merge-Ins

This is equivalent to a diff from 9f4c4666c5 to 299ddec90e

2011-10-11
15:31
Merged in rewrite of core functionality check-in: 192b8b1639 user: brian tags: develop
2011-09-13
18:28
[Broken] Trying to get the tree structuse working Closed-Leaf check-in: 299ddec90e user: brian tags: tree
2011-06-12
20:32
Made some changes to the parser. Don't remember what. check-in: 60bf1cfb19 user: brian tags: tree
20:31
Create new branch named "tree" check-in: 2beaf09ad7 user: brian tags: tree
20:31
Create new branch named "develop" check-in: 9f4c4666c5 user: brian tags: develop
2011-02-10
23:50
Program generates a render order for the instruments based on their sync order check-in: 689adc054e user: brian@linux-85dd.site tags: master

Modified cfg.py from [e9b556b4f3] to [967482cdda].

1
2
3
4

5
6
7
8
9
10
11
12


13
14
15
16
17
18
19
20
21
22
23

24
25
26
27
28
29
30
31
32
33
34

























35
36
37
38
39
40
41
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70




+








+
+











+











+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+







#!/usr/bin/env python

from __future__ import division
import os
import pdb
import random
import sys
import time
random.seed(time.time())

import parse
import topsort
import yaml

from tree import *

def main():
    key = "A"
    bps = 60/60
    tempo = 1/bps
    max_duration = 1

    composition = yaml.load(open("score.yaml"))

    max_t = 0  # max time encountered so far. Used for movement timing
    progression = "chorus"
    timeline = {}

    for movement in progression.split():
        for section in ["intro", "core", "outro"]:
            if section in composition[movement].keys():
                try:
                    render_order = topsort.topsort([[composition[movement][section][instrument]["sync"], instrument] if "sync" in composition[movement][section][instrument].keys() else [None, instrument] for instrument in composition[movement][section]])
                except topsort.CycleError as ex:
                    print "Your instruments are synced in a circle! This makes no sense!"
                    print movement, section
                    print ex
                    sys.exit(1)
                while None in render_order:
                    render_order.remove(None)
                for instrument in render_order:
                    grammars = composition[movement][section][instrument]["grammars"]
                    for grammar in grammars:
                        if isinstance(grammars[grammar], list):
                            for option in range(len(grammar)):
                                grammars[grammar][option] = parse.parse(grammars[grammar][option])
                        else:
                            grammars[grammar] = parse.parse(grammars[grammar])
                    print section, movement, instrument
                    print grammars
                    for grammar in grammars:
                        t = Tree()
                        pdb.set_trace()
                        while reduce(lambda x, y: x+y, [node.time for node in t.traverse_depth_first()]) < instrument["max_duration"]:
                            pass
                        timeline[movement][section][instrument] = Tree()


def generate_score_phrase(grammar, grammars):
#    count_length = 
#    while count_length < 100000:
    

                

#    for comp_name in progression.split():
#        comp_start_time = max_t
#        for instr_name, instr in composition[comp_name].iteritems():
#            generated_score = generate_score(instr["score"], instr["grammars"])  # Fill in the scores by generating them based on the grammars
##            print generated_score

Modified parse.py from [3ec57c3fbe] to [c06717e335].

13
14
15
16
17
18
19
20

21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

40
41
42
43
44
45
46
47
48
49

50
51


52
53
54
55
56
57
58
13
14
15
16
17
18
19

20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

45
46
47
48

49
50
51
52
53
54
55
56
57
58
59
60







-
+



















+




-




-
+


+
+







class Chord():
    def __init__(self, value, duration=.5, chord_type="major", octave=5):
        self.value = value
        self.duration = duration
        self.chord_type = chord_type
        self.octave = octave
    def __repr__(self):
        return "Chord %s %s %s" % (self.value, self.duration, self.chord_type, self.octave)
        return "Chord %s %d %s %s" % (self.value, self.duration, self.chord_type, self.octave)

class Rest():
    def __init__(self, duration=.25):
        self.duration = duration
    def __repr__(self):
        return "Rest node %s" % self.duration


def parse(score, default_octave=8):
    # Tokenize (lex)
    tokens = (
        "NOTE_LENGTH",
        "BASENOTE",
        "ACCIDENTAL",
        "REST",
        "OCTAVE",
        "CHORD_TYPE",
        "PAREN",
        "SYNCOPATE",
        "NODE",
    )

    t_ignore = " |"

    #t_BASENOTE = r"[A-Ga-g]"
    t_BASENOTE = r"I+V?|VI*|i+v?|vi*"
    t_ACCIDENTAL = r"\^{1,2}|_{1,2}|="
    t_REST = r"z"
    t_OCTAVE = r"'+|,+"
    t_CHORD_TYPE = r"m|7|m7|0|o|\+|mb5|sus|sus4|maj7|mmaj7|7sus4|dim|dim7|7b5|m7b5|6|b6|m6|mb6|46|maj9|9|add9|7b9|m9"
    t_CHORD_TYPE = r"m|7|m7|0|o|mb5|sus|sus4|maj7|mmaj7|7sus4|dim|dim7|7b5|m7b5|6|b6|m6|mb6|46|maj9|9|add9|7b9|m9"
    t_PAREN = "\(|\)"
    t_SYNCOPATE = "\+|-"
#    t_NODE = "\w*(?!(([Vv][Ii]{0,3})|([Ii][Vv]?)))\w+"
    t_NODE = "\S+"

    def t_NOTE_LENGTH(t):
        r"/?\d+"
        multiplier = float(t.value.strip("/"))
        if t.value.startswith("/"):
            multiplier = 1/multiplier
        t.value = multiplier
67
68
69
70
71
72
73

74
75
76
77
78
79
80
81
82
83






84
85
86
87
88
89
90
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99







+










+
+
+
+
+
+








    # Parse (yacc)

    def p_note_list(p):
        '''score : score note
                 | score chord
                 | score rest
                 | score node
        '''
        p[0] = p[1] + [p[2]]

    def p_score(p):
        '''score : note
                 | chord
                 | rest
        '''
        p[0] = [p[1]]


    def p_node(p):
        '''node : NODE
        '''
        p[0] = p[1]


    def p_chord_length(p):
        ''' chord : chord NOTE_LENGTH
        '''
        new_note = p[1]
        new_note.duration = p[2]
        p[0] = new_note
101
102
103
104
105
106
107
108

109
110
111
112
113
114
115


116
117
118
119
120
121
122
110
111
112
113
114
115
116

117
118
119
120
121
122
123

124
125
126
127
128
129
130
131
132







-
+






-
+
+







    def p_chord(p):
        '''chord : PAREN note PAREN
                 | PAREN note CHORD_TYPE PAREN
        '''
        pitch = p[2].value
        pitch = pitch.upper()
        p[0] = Chord(value=pitch, octave=default_octave)
        if len(p) > 3:
        if len(p) > 4:
            p[0].chord_type = p[3]


    def p_note_syncopate(p):
        ''' note : note SYNCOPATE
        '''
        note.syncopate = p[2]
        p[1].syncopate = p[2]
        p[0] = p[1]


    def p_accidental(p):
        '''note : ACCIDENTAL note
        '''
        p[2].accidental = p[1]
        p[0] = p[2]