«first  …23 24 25 26 27 28 29 last»


redFingerprint

2007-01-19 00:05:32 supercollider

A different plot for SuperCollider. Though it is actually more useful as an 'artistic' visualiser rather than a serious way to represent data. It works with collections like arrays, envelopes and wavetables. The technique is to translate them to length/angle pairs and then draw a shape from that.

redFingerprint screenshot 2 redFingerprint screenshot 3 redFingerprint screenshot 6 redFingerprint screenshot 7 redFingerprint screenshot 8 redFingerprint screenshot 9

It's distributed via SuperCollider's package system quarks. All open source.

Quarks.install("redUniverse");
//and then recompile

There's also some older code here that does similar drawings...

swiki.hfbk-hamburg.de:8888/MusicTechnology/833

Data?

redFingerprint screenshot 10 redFingerprint screenshot 11

And of course, it's always more fun when things break. Here the same thing with a nice bug...

redFingerprint screenshot 12 redFingerprint screenshot 13

Updates:

  • 090511: redFingerprint is now part of the redUniverse quark

Work with Mark: RedUniverse - A Simple Toolkit

2007-01-18 22:56:33 research, supercollider

I made a short demo/poster session at the LAM conference on 19 December 2006 in London. See livealgorithms.org (archive.org)).

Below is the handout describing the toolkit.

RedUniverse screenshot 01 RedUniverse screenshot 08 RedUniverse screenshot 09 RedUniverse screenshot 15

This toolkit is now distributed via SuperCollider's package system quarks. All open source.

How to install:

Quarks.install("redUniverse");

RedUniverse - a simple toolkit

Mark d'Inverno & Fredrik Olofsson

This is basically a set of tools for sonification and visualisation of dynamic systems. It lets us build and experiment with systems as they are running. With the help of these tools, we can quickly try out ideas around simple audiovisual mappings, as well as code very complex agents with strange behaviours.

The toolkit consists of three basic things... Objects, Worlds and a Universe. Supporting these are additional classes for things like particle systems, genetic algorithms, plotting, audio analysis etc. but preferably many of these functions you will want to code your self as a user.

We have chosen to work in the programming language SuperCollider (www.audiosynth.com) as it provides tight integration between real-time sound synthesis and graphics. It also allows for minimal classes that are easy to customise and extend. SuperCollider is also open for communication with other programs and it runs cross-platform.

So to take full advantage of our toolkit, good knowledge of this programming language is required. We do provide help files and examples as templates for exploration, but the more interesting features, like the ability to live-code agents, are hard to fully utilise without knowing this language.

Detailed overview

In SuperCollider we have the three base classes: RedObject, RedWorld and RedUniverse.

  • RedObject - things like particles, boids, agents, rocks, food etc.
  • RedWorld - provides an environment for objects.
  • RedUniverse - a global collection of all available worlds.

Objects all live in a world of some sort. There they obey a simplified set of physical laws. They have a location, velocity, acceleration, size and a mass. They know a little about forces and can collide nicely with other objects.

Pendulums are objects that oscillate. They have an internal oscillation or resonance of some sort.

Particles are objects that ages with time. They keep track of how long they have existed.

Boids are slightly more advanced particles. They have a desire and they can wander around independently seeking it.

Agents are boids that can sense and act. They also carry a state 'dictionary' where basically anything can be stored (sensory data, urges, genome, phenome, likes, dislikes, etc). Both the sense and act functions, as well as the state dictionary, can be manipulated on the fly. Either by the system itself or by the user in runtime.

Worlds provide an environment for the objects. They have properties like size, dimensions, gravity etc and they also keep a list of all objects currently in that world.

For now, there are three world classes:

  • RedWorld - endless in the sense that objects wrap around its borders.
  • RedWorld2 - a world with soft walls. Objects can go through but at a cost. How soft these walls are and how great the cost depends on gravity and world damping.
  • RedWorld3 - a world with hard walls. Objects bounce off the borders - how hard depends on gravity and world damping.

The Universe is there to keep track of worlds. It can interpolate between different worlds. It can sequence worlds, swap and replace, and also migrate objects between worlds. All this while the system is running.

The RedUniverse class also does a complete system store/recall to disk of all objects and worlds.

So the above are the basic tools. They should be flexible enough to work with e.g. objects can live in worlds of any number of dimensions. But as noted, one can easily extend the functionality of these classes by subclassing.

Conclusion

How the objects and worlds behave, sound and look like are open for experimentation. That is, this is left for the user to code. So while there is great potential for customisation, it also requires more work from its users.

The RedUniverse as a whole tries not to enforce a particular type of system. E.g. one can use it purely without any visual output or vice-versa.

We see it both as a playground for agent experiments as well as a serious tool for music composition and performance. We hope it is simple and straightforward and while there is nothing particularly novel about it, we have certainly had fun with it so far. Foremost it makes it easy to come up with interesting mappings between sound and graphics. In a way, we just joyride these simple dynamic systems to create interesting sounds.

The software and examples will be available online on the LAM site. Of course as open source.


Default Synth Hack

2007-01-18 18:10:34 supercollider

I recently implemented something Nick Collins and I discussed a long time ago (SC2 era - custom event class). It is a 'hack' of the default synth in SuperCollider. That is the one that many of the help and example files uses. So when you install my class, the default file will be overwritten and all the slightly daft pattern examples will from there on spring into new life.

Install it and then run some examples. Most of the ones in Streams-Patterns-Events5 and Streams-Patterns-Events6 work very well. See the RedDefault help file for more info.

(And yes, it is easy to uninstall and get back to the boring default synth)

Just to compare - here's first an example taken from a help file playing on the default synth...

And this is the exact same example with my hack installed...

Not only does it create a new synthesiser it also changes duration, attack/release times, amplitude etc. The pitches are mapped to a diminished chord in a somewhat strange way: the slower the duration - the greater the leap between the notes to quantise to. For example, if half or whole notes, only octaves will be heard.

Updates:

  • 111116: redDefault is no longer a quark. It's available on the page: /code/sc/#classes

A Tiny Little White One

2006-10-13 15:19:08 supercollider

This chunk of SuperCollider code will create a tiny but not so well behaved audiovisual creature.

(I must admit I stole the title from a.berthling's album on mitek)

a tiny little white one screenshot

/*a tiny little white one  /redFrik 061009*/
 
/*
GUI.cocoa;
GUI.swing;
*/
 
(
s.waitForBoot{
    n= 25;  /*number of arms*/
    b= {Buffer.alloc(s, 32, 1)}.dup(n);  /*length must be power of 2*/
    SynthDef(\wormsnd, {|out= 0, bufnum, freq= 60, amp= 0.01, pan= 0|
        Out.ar(out, Pan2.ar(OscN.ar(bufnum, freq, 0, amp), pan));
    }).send(s);
})
 
(
    var width= 300, height= 300, freqSpread= 100.rrand(1000).postln, muckProb= 0.0008,
        muck= 0, i= 0, j= 0, shapes, synths, pnt, w, u, freq,
        centerX= width/2, centerY= height/2, o= 0.1, frict= 1, lfo= 1, lfoSpeed= 0;
    w= Window("a tiny little white one", Rect(128, 64, width, height), false);
    u= UserView(w, Rect(0, 0, width, height));
    u.background= Color.black;
    w.onClose_({synths.do{|x| x.free}});
    CmdPeriod.doOnce({w.close});
    w.front;
    shapes= {|x| {1.0.rand}.dup(b[x].numFrames)}.dup(n);  /*init shapes*/
    synths= {|x| Synth(\wormsnd, [\bufnum, b[x].bufnum, \pan, x/(n-1)*2-1])}.dup(n);
    u.drawFunc= {
        shapes.do{|shape, x|  /*iterate shapes, x is index*/
            var dist;
            if((muckProb*0.1).coin, {muck= 4.rand});
            if(muck>0, {
                ([
                    {pnt= Point(x/n*10, x/n*10)},
                    {pnt= Point(x/n* -10, x/n*10); if(muckProb.coin {muck= 0})},
                    {pnt= Point(x.rand2, x.rand2); if(muckProb.coin {muck= 0})}
                ][muck-1]).value;
                if(i%2000==0, {muck= 0});
            }, {
                pnt= Point(0, 0)
            });
            lfo= (lfo+lfoSpeed).fold(0.05, 1);
            i= i+1;
            j= (j+10.rand2).fold(0, shape.size-1);
            shape.put(j, (shape[j]+o).fold(0.01, 1));
            if(muckProb.coin, {
                o= [0.15.rand2, -1, 1].wchoose(#[0.95, 0.025, 0.025]);
                frict= [0.997.rrand(1), 0.95.rrand(1.5)].wchoose(#[0.95, 0.05]);
                lfoSpeed= 0.0001.rand2;
                [
                    #[\o, \frict, \lfo, \lfoSpeed],
                    [o, frict, lfo, lfoSpeed].round(0.0001)
                ].lace(8).postln;
            });
            o= o*frict;
            b[x].sine1(shape.clip(0.01, 1));
            Pen.strokeColor= Color.grey(x+1/n);
            Pen.moveTo(Point(centerX, centerY));
            shape.clump(2).do{|ll, k|
                var distance, angle, temp;
                #distance, angle= ll;
                pnt= Point(distance, distance).rotate(angle*2pi*lfo)+pnt;
                Pen.lineTo(
                    Point(
                        (pnt.x*10+centerX).clip(0, width),
                        (pnt.y*10+centerY).clip(0, height)
                    )
                );
            };
            Pen.stroke;
            dist= pnt.dist(0).clip(0.1, 20);  /*distance from 0, 0*/
            freq= dist/20+lfoSpeed+muck+(lfo*0.01.rand)*freqSpread+60;
            synths[x].set(\freq, freq, \amp, (1/n)*dist/20);
        }
    };
    {while{w.isClosed.not} {u.refresh; (1/30).wait}}.fork(AppClock);
)
 
b.do{|x| x.free};

Skare - New Video Online

2006-09-27 16:02:11 visuals

I recently made my first short video for Skare. We like to make things a little bit complicated for ourselves and we also have a hook up on ice, snow and all other variations on cold water.

First - to get some cheap audiovisual correlation - I put an old CD in the freezer for two weeks. Then one night I took it out and placed it over the bass element of a speaker. As the piece of plastic slowly adapted to room temperature, I let it vibrate to the deep fat bass found in the track 'To the Other Shore' (released on glacial movements). This was all filmed twice, close up and in night shot mode.

I then wrote a little MaxMSPJitter patch that mixed the two takes, matched it with the audio file and saved the whole thing to disk. The resulting video is on http://www.inhospitable.se/skare/.

Screenshot of one of my uglier patches...

skare totheothershore screenshot


Useless SuperCollider Class no.1

2006-09-26 14:02:02 supercollider

Today I wrote a help file for an old SuperCollider class I had laying around. It simulates old telephone DTMF signals. Pretty silly must say and I forgot why I created it in the first place. But I bet someone can find some strange use for it. Jim?

RedDTMF is part of redSys quark. Install it by typing...

Quarks.install("redSys");
//and then recompile
s.boot;
{RedDTMF.dial("12AA34", 4)}.play;

«first  …23 24 25 26 27 28 29 last»