spiffyscore

Diff
Login

Differences From Artifact [8500dd2d15]:

To Artifact [3dbac50436]:


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
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
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
100
101
102
103
104
105
106







-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

-
+
+
+
+


+
+
+
+
+
+
+
+
+
+
-
+





-
+




+












-
+
-
-
+
+







    key = "A"
    bps = 60/60
    tempo = 1/bps
    max_duration = 1

    composition = {
        "a": {  # Movement block 'a' for reuse throughout the piece
            "bassline": {  # Instrument 'melody'
                "score_line": "i1 %(time)f %(duration)f 10000 %(octave)d.%(note)s",
                "octave": 5,
            "melody": {  # Instrument 'melody'
                "score_line": "i2 %(time)f %(duration)f 7000 %(octave)d.%(note)s 2",
                "octave": 8,
                "grammars": {  # Notes for this instrument to use in this piece
                    "u": ["I V/2 V/2 V/2 I VII, IV' x u", "I IV w w", "I VII IV u u"  , "e"],
                    "w": ['VII I IV V VI u', 'w w', "e"],
                    "x": ['VI/4 III/4 II/4 I/4 w', 'x x', "e"],
                    "e": [""],
                },
                "score": "u u u u u",
            },
            "rhythm": {
                "score_line": "i1 %(time)f %(duration)f 7000 %(octave)d.%(note)s %(octave)d.%(note)s 0 6",
                "octave": 7,
                "grammars": {
                    "u": ['"I" "ii"/4 "ii"/4 "IV"/2 "V"2 "IV" "ii" x u', '"I" "vii" "III" y u', '"I" "v" "IV" u u', "e"],
                    "w": ['"i" "VII"2 "VI"/4 "V"/4 "i"/4 "VII"2 "VI" "V" w u', "e"],
                    "x": ['"III/2" "VI"/2 "III"/2 "vii"2 "i"2 "V" u', "e"],
                    "y": ['"I" "vi"2 "IV" "V" y y u', "e"],
                    "e": [""]
                },
                "score": "u x u y x w u",
            },
#            "bass": {
#                "score_line": "i2 %(time)f %(duration)f 7000 %(octave)d.%(note)s 2",
#                "octave": 5,
#                "grammars": {  # Notes for this instrument to use in this piece
#                    "u": ['"I" "V" "vi" "iii" "IV" "I" "IV" "V" u u' , "e"],
#                    "e": [""],
#                },
#                "score": "u u u u u",
#            },
        },
        "b": {  # Movement block 'a' for reuse throughout the piece
            "melody": {  # Instrument 'melody'
                "score_line": "i2 %(time)f %(duration)f 7000 %(octave)d.%(note)s 2",
                "octave": 8,
                "grammars": {  # Notes for this instrument to use in this piece
                    "u": ["I/2 z/2 I/2 z/2 I/2 z/2 V/2 z/2 u u", "e"],
                    "u": ['I VII V III u', "y", "e"],
                    "w": ['VII I IV V VI u', 'w w', "e"],
                    "x": ['VI/4 III/4 II/4 I/4 w', 'x x', "e"],
                    "y": ["III/4 VI/4 II/4 V/4 VI/4 IV/4 VII2", "e"],
                    "e": [""],
                },
                "score": "w w x x w",
            },
            "rhythm": {
                "score_line": "i1 %(time)f %(duration)f 7000 %(octave)d.%(note)s %(octave)d.%(note)s 0 6",
                "octave": 7,
                "grammars": {
                    "u": ['"I" "V" "vi" "iii" "IV" "I" "IV" "V" u u', "y", "e"],
                    "y": ['"I" "vi"2 "IV" "V" y y u', "e"],
                    "e": [""]
                },
                "score": "u u u u u",
                "score": "u u y y u",
            },
        },
    }

    max_t = 0  # max time encountered so far. Used for movement timing
    progression = "a"
    progression = "a b"
    for comp_name in progression.split():
        instr_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
            score = parse.parse(generated_score, default_octave=instr["octave"])  # Return Node/Chord objects

            # Generate timestamps for the notes 
            t = instr_start_time
            for note in range(len(score)):
                score[note].time = t
                score[note].duration *= tempo
                t += score[note].duration
                max_t = t if t > max_t else max_t
            composition[comp_name][instr_name]["score"] = score

    # Must be done after all note times keyed in, else you can't coordinate melodies with the rhythm chords
    print "f1  0  512  10  1"
    print '''f1  0  512  10  1
#    print "f1  0   513 9 1 1 0 3 .33 180 5 .2 0 7 .143 180 9 .111 0"
#    print "f2 0 8192 10 .24 .64 .88 .76 ,96 .5 .24 .08"
            f2 0 8192 10 .24 .64 .88 .76 .06 .5 .34 .08
    '''
    for comp_name in progression.split():
        for instr_name, instr in composition[comp_name].iteritems():
            composition[comp_name][instr_name]["score"] = transliterate_score(composition[comp_name][instr_name]["score"], key)
#            print "\nMovement %s instrument %s" % (comp_name, instr_name)
#            print composition[comp_name][instr_name]["score"] 
            final_score = generate_csound_score(composition[comp_name][instr_name]["score"], composition[comp_name][instr_name]["score_line"])
            for line in final_score:
75
76
77
78
79
80
81
82
83


84
85
86
87
88
89
90
123
124
125
126
127
128
129


130
131
132
133
134
135
136
137
138







-
-
+
+







        found_substitution = False
        for key,value in grammars.iteritems():
            if score.find(key) != -1:
                found_substitution = True
                while score.find(key) != -1:
                    score = score.replace(key, random.choice(grammars[key]), 1)
                    if len(score.split()) > 200:
                        score = score.replace("u", "")
                        score = score.replace("e", "")
                        for k in grammars.keys():
                            score = score.replace(k, "")
                        return score
        if found_substitution is False:
            break
    return score

def transliterate_score(score, key):
    scale = make_scale(key)
102
103
104
105
106
107
108

109
110


111
112
113

114
115
116
117
118
119
120
150
151
152
153
154
155
156
157


158
159
160


161
162
163
164
165
166
167
168







+
-
-
+
+

-
-
+







    for i in range(len(score)):
        if isinstance(score[i], parse.Note):
            score[i].value = scale[scale_conversion[score[i].value]-1]
        elif isinstance(score[i], parse.Chord):
            chord = []
            root_note_index = scale.index(key) + scale_conversion[score[i].value]
            chord.append(scale[root_note_index])
            chord.append(scale[(root_note_index+3) % 8])
            if score[i].chord_type == "m":  # Minor chords, flat the 3rd
                chord.append(scale[(root_note_index+2) % 8])
            if score[i].chord_type == "m":  # Minor chords, flat the 5th
                chord.append(scale[(root_note_index+4) % 8])
            else:
                chord.append(scale[(root_note_index+3) % 8])
            chord.append(scale[(root_note_index+5) % 8])
                chord.append(scale[(root_note_index+5) % 8])
            score[i].chord = chord
        elif isinstance(score[i], parse.Rest):
            pass
    return score


def generate_csound_score(score, score_line):