«Generating Graphics and Music From The Dragon Curve» by 56228375

on 26 Jan'19 22:09 in minimalgenerativegraphicspanolalsystemdragon

This minimal music generator uses a Lindenmayer system to generate composition instructions. Interpreting those same instructions twice with some randomness yields a kind of 2-voiced minimal music.This code depends on the Panola quark and the LSystem quark. Install them with Quarks.install("https://github.com/shimpe/panola"); and Quarks.install("https://github.com/shimpe/sc-lsystem");

log fork json 
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
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
// if you have never done so, run the following code first
(
Quarks.install("https://github.com/shimpe/panola"); 
Quarks.install("https://github.com/shimpe/sc-lsystem");
)

// musical example
(
s.waitForBoot({
    var player;
    var lsys = LSystem(
        iterations:4,
        axiom:"FX",
        constants:Set[],
        rules:(\X : "X+YF+",
            \Y : "-FX-Y"));
    var interp = LSystemInterpreter(
        lsystem:lsys,
        globalstate:(
            \acceptablenotes : Set["c3", "d3", "e3", "g3", "a3", "c4", "d4", "e4", "g4", "a4"],
            \patternnotes : ["c3"],
            \transpose : 0,
            \tempo : 16,
        ),
        actions:(
            // whenever you encounter an F, extend the list of played notes
            'F' : [{ | glob, loc |
                // extend list notes being played (using some randomness :) )
                glob[\patternnotes] = glob[\patternnotes].add(glob[\acceptablenotes].choose.debug("add new note"));

                // always return state at the end
                [glob, loc];
            }, nil],
            // whenever you encounter a +, transpose up
            '+': [{ | glob, loc |
                glob[\transpose] = (glob[\transpose] + [1,2,3,4].choose.debug("transpose up")).clip(-12,12);
                // always return state at the end
                [glob, loc];
            }, nil],
            // whenever you encounter a -, transpose down
            '-': [{ | glob, loc |
                "transpose down".postln;
                glob[\transpose] = (glob[\transpose] - [1,2,3,4].choose.debug("transpose down")).clip(-12, 12);
                // always return state at the end
                [glob, loc];
            }, nil],
            // whenever you encounter an X, remove first note from the played notes
            'X' : [{ | glob, loc |
                "remove first note".postln;
                if (glob[\patternnotes].size > 1) {
                    // keep at least one note
                    glob[\patternnotes] = glob[\patternnotes].reverse;
                    glob[\patternnotes].pop;
                    glob[\patternnotes] = glob[\patternnotes].reverse;
                };
                // always return state at the end
                [glob, loc];
            }, nil],
            // whenever you encounter a Y, change tempo (randomly) )
            'Y' : [{ | glob, loc |
                glob[\tempo] = (glob[\tempo] * [0.3, 1.2, 1.4, 1.7, 2, 0.5, 3].choose.debug("tempo factor")).clip(8,32);
                // always return state at the end
                [glob, loc];
            }, nil],
        )
    );

    var interp2 = interp.deepCopy();

    SynthDef(\kalimba, {
        |out = 0, freq = 440, amp = 0.1, mix = 0.1|
        var snd, click;
        // Basic tone is a SinOsc
        snd = SinOsc.ar(freq) * EnvGen.ar(Env.perc(0.03, Rand(3.0, 4.0), 1, -7), doneAction: 2);
        snd = HPF.ar( LPF.ar(snd, 380), 120);
        // The "clicking" sounds are modeled with a bank of resonators excited by enveloped white noise
        click = DynKlank.ar(`[
            // the resonant frequencies are randomized a little to add variation
            // there are two high resonant freqs and one quiet "bass" freq to give it some depth
            [240*ExpRand(0.97, 1.02), 2020*ExpRand(0.97, 1.02), 3151*ExpRand(0.97, 1.02)],
            [-9, 0, -5].dbamp,
            [0.8, 0.07, 0.08]
        ], BPF.ar(PinkNoise.ar, 6500, 0.1) * EnvGen.ar(Env.perc(0.001, 0.01))) * 0.1;
        snd = (snd*mix) + (click*(1-mix));
        snd = Mix( snd );
        Out.ar(out, Pan2.ar(snd, 0, amp));
    }).add;

    SynthDef(\flute, {
		| out = 0, freq = 440, amp = 1.0, a = 0.1, r = 0.1|
		//var fmod = 1; // clean
		//var fmod = LFCub.kr(freq:1/12).range(1, LFNoise2.kr(freq:12.0).range(1,1.1)); // tone deaf flute
		var fmod = LFCub.kr(freq:1/12).range(1, LFNoise2.kr(freq:12.0).range(1,1.02)); // flute-like sound
		var env = EnvGen.ar(Env.perc(a, r), levelScale:0.5, doneAction:2);
		var snd = SinOsc.ar(freq * fmod)!2;
		Out.ar(bus:out, channelsArray:(env*(amp*snd).tanh));
	}).add;

    s.sync;

    fork {
        var skipfirstidx = 0; // increase to skip more steps at the beginning
        var sz = lsys.getCalculatedString.size();
        lsys.getCalculatedString.do({
            | chr, idx |
            var pattern;
            var transposedpattern;
            var transposition;
            var transposition2;
            ("*** PART" + (idx+1) + "OF" + sz + "***").postln;
            interp.step(idx);
            interp2.step(idx);
            // start playing from step skipfirstidx
            if (idx > skipfirstidx) {
                var repeats = inf;
                if (idx == (sz-1)) { repeats = 3; }; // don't repeat last pattern indefinitely
                transposition = interp.globalState()[\transpose].debug("transpose");
                transposition2 = interp2.globalState()[\transpose].debug("transpose2");
                pattern = Pn(
                    Ppar([
                        Padd(\midinote, Pfunc({transposition}),
                            Panola.new(
                                notation:interp.globalState()[\patternnotes].join(" ").debug("notes1"),
                                dur_default:interp.globalState()[\tempo]
                            ).asPbind(\kalimba)
                        ),
                        Padd(\midinote, Pfunc({transposition2}),
                            Panola.new(
                                notation:interp2.globalState()[\patternnotes].join(" ").debug("notes2"),
                                dur_default:interp2.globalState()[\tempo]*2,
                                playdur_default:1,
                                vol_default:0.1
                            ).asPbind(\flute),
                        )
                    ]),
                    repeats);
                if (player.notNil) { player.stop; };
                player = pattern.play();
                1.wait;
                if (idx == (sz-1)) {
                    "*** ABOUT TO FINISH ***".postln;
                };
            }
        });
    }
});
)

// The same LSystem can also be interpreted graphically
(
var win = Window("Example Graphical LSystem", bounds:Rect(0,0,1000,700));
var view = UserView(win, win.view.bounds.insetBy(50,50));
var lsys = LSystem(
    iterations:12,
    axiom:"FX",
    constants:Set[],
    rules:(\X : "X+YF+",
        \Y : "-FX-Y"));
var interp = LSystemInterpreter(
    lsystem:lsys,
    actions:(
        'F' : [{
            | globalstate, symbolstate |
            globalstate[\pos] = globalstate[\pos] + (globalstate[\dir]*globalstate[\len]);
            Pen.lineTo(globalstate[\pos]);
            [globalstate, symbolstate];
        }, nil],
        'X' : [{
            | globalstate, symbolstate |
            globalstate[\pos] = globalstate[\pos] + (globalstate[\dir]*globalstate[\len]);
            Pen.lineTo(globalstate[\pos]);
            [globalstate, symbolstate];
        }, nil],
        'Y' : [{
            | globalstate, symbolstate |
            globalstate[\pos] = globalstate[\pos] + (globalstate[\dir]*globalstate[\len]);
            Pen.lineTo(globalstate[\pos]);
            [globalstate, symbolstate];
        }, nil],
        '-' : [{| globalstate, symbolstate |
            globalstate[\dir] = (globalstate[\dir].rotate(globalstate[\angle].degrad));
            [globalstate, symbolstate];
        }, nil],
        '+' : [{| globalstate, symbolstate |
            globalstate[\dir] = (globalstate[\dir].rotate(globalstate[\angle].neg.degrad));
            [globalstate, symbolstate];
        }, nil]
    )
);

view.resize = 5;
view.background_(Color.white);
view.drawFunc_({
    |userview|
    Pen.use {
        interp.setGlobalState( globalstate:(
            \dir : 0@1.neg,
            \pos : (win.view.bounds.width/2)@(win.view.bounds.height/5),
            \len : 3,
            \angle: 90 ) );
        Pen.width = 2;
        Pen.strokeColor_(Color.black);
        Pen.fillColor_(Color.black);
        Pen.moveTo(interp.globalstate[\pos]);
        interp.run();
        Pen.stroke;
    };
});
win.front;
)
full graph
raw 8376 chars (focus & ctrl+a+c to copy)
reception
comments
g_montel ↪ user 06 Feb'19 18:42

Super interesting !! Thanks a lot !

lambda ↪ user 17 Jul'20 19:10

This is amazing. I love both the image and the sound. It starts so simple but at the end its crazy.

blueprint ↪ user 08 Mar'23 13:07

Fun. I've built a bunch of systems to (initially to add color) to: https://anvaka.github.io/lsystem

Try your code with: <pre> var lsys = LSystem( iterations:4, axiom:"Y", constants:Set[], rules:(\X : "X[-F+FF][+F-FF]FX", \Y : "YFX[+Y][-Y]")); </pre>

blueprint ↪ user 17 Mar'23 14:10

I made a bunch of variations on these, with links to the l-systems and pics. My https://github.com/poetaster/supercollider-lsystems/blob/main/weed-after-bourke.scd