Life-based Systems Project Update 05

Since I'd like to carry on this project for my final, I began looking for more references and previous work for exploration. Here's a short list from the massive amounts I've culled off Google Scholar searches.

More references

http://www.csse.monash.edu.au/~jonmc/research/Papers/L-systemsMusic.pdf

http://portal.ku.edu.tr/~megunal/articles/cellular.pdf

http://teacher.kfcdc.edu.tw/kf94008/design-history/algorithm1.pdf

http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.6.3882&rep=rep1&type=pdf

Life-base Systems Presentation

Note:

Unfortunately I've had to roll back my past two days worth of work on this project, so the presentation images are still from Monday. There was a lot of work that needed and still needs to be done to isolate all of the data structures I have, and I just kept running in to errors. I will continue to iron those out in the coming days.

Concept

Create a sound "garden" where plant-like structures are interpreted as musical notes and chords.

The installation takes up considerable gallery wall-space and is meant to feel immersive.

The sound played back by each of the "L-Sound-Systems" is panned relative to their position on screen

The structures are drawn in real time, and visualize leaf-like structures at the nodes of each note

Progress

A single structure can be drawn and shown at once. Only the pitch is currently driven directly by the L-system. The empty space should be filled by other structures.

Future Work

• Bug fixes
• Draw (i.e. reveal) plant structure in real time as it is "played"
• Allow for multiple plants to grow
• Match note groups from parser with node groupings in visualizer (incorrect green circles are currently drawn due to mismatch)
• Time MIDI events properly
• Draw radial sine "leaves" (or other visualization) instead of debugging circles
• Expand the L-system grammar and parameters to be more flexible and carry more information
• Add genetic wrapper to evolve variable input structures according to pleasing chord structures, note progressions, rhythms, etc.
• Explore audience interaction via keyboard, where users can input short sequences or entire pieces and watch them grow in to a forest.
  alternatively:
• Consider allowing input of midi files to be interpreted 
• Consider audience interaction via touchscreen to allow users to draw out their own plants 

Life-based Systems Project Update 04

AH! IT WORKS!

I finally have a working version that actually plays back music!

The green circles are temporary, and are meant just to point out which nodes on the tree correspond to which notes being played. In the future, I would like them to appear more as "leaves", and I'm thinking about playing with radiating sine waves that pulse out when the nodes play.

NOTE: In the non-debug mode, the text overlay is not present and the display is full screen.

This gets me closer, but I still have a long way to go.

Issues

• The code is such that (because I was in a rush for critique) only one of these systems can exist at once. I very much want a whole garden of these, but I'm taking it a step at a time.
• The system is static; I want for the tree to draw itself as the notes play, but right now, the entire tree is displayed all at once. 
• The input L-system is fixed, and requires changes in code to make new systems.
• Visibly, circles will hilite for the wrong notes, or not hilite at all when they should. I think it's disparity between when I initially build the tree and when I parse it incrementally later (two different functions)
• My data structures do not represent all of the MIDI parameters I would like to use. Several parameters are fixed or arbitrarily randomized.

[Aside] Sierpinski Strikes Again!

While working on my Digital Image homework last night for VIZA654, I inadvertently created a Sierpinski triangle in the green channel of my image.

I'm still pretty ecstatic, and I'm looking forward to figuring out exactly why the image was generated, if it works for all image resolutions and aspect ratios, and how I can better control it.

That's all for now!

Life-based Systems Project Update 03

Progress feels good. I'm finally making sense of my components.
Also, the ofxMidi exampleOut project is very informative

• The reason I was having problems integrating MIDI into my project (and considering using wav) is that the openFrameworks ProjectGenerator script does not successfully add the ofxMidi addon package to a new project (most likely the fault of the maintainer, not the ProjectGenerator).
• The MIDI backend for windows is RtMidi when using the ofxMidi addon. This makes setting up and using JACK or another MIDI backend unnecessary, and makes my sketch much more portable.
• Microsoft (at least my build) does have a default MIDI port that routes to the Microsoft GS Wavetable Synth. Fortunately, ofxMidi is able to map to this port by default.
  Not to mention, I don't need another program to also output the audio.
• The example projects for ofxMidi now compile properly on my machine, significantly reducing the amount of code I need to figure out myself

More soon...

Life-based Systems Project Critique Day | Out Sick

Regrettably I was unable to attend class today. I came down sick in the afternoon.

Life-based Systems Project Update 02

Thoughts

• Should I use branch depth or specific rules to build chords?

I  --> I IV V I
ii --> ii V I IV
IV --> IV V I ii
V  --> V I ii V

Which looks like this in code, btw

lsystem.addRule("1", "1451")
lsystem.addRule("2", "2514")
lsystem.addRule("4", "4512")
lsystem.addRule("5", "5125")

This would make the chords more portable to different keys, but might take too much control away from the system.

Life-based Systems Project Update 01

I have decided to use openFrameworks and the openFrameworksExtensions (ofx-) for my project. For those not familiar with openFrameworks, think of it as the C++ brother of Processing. It doesn't hide nearly as much from you, which presents a steeper learning curve for non-programmers but allows more control and efficiency as a tradeoff.

openFrameworks for Processing Users

Libraries

L-systems

I've been working on gathering together the libraries I will need to accomplish my goals

First I found a basic L-system library that I will be modeling my L-systems after. For the time being, it accomplishes the basics of what I need and has a simple draw class for debugging, which makes it convenient.

LSys/ofxLSys: https://github.com/daanvanhasselt/snippets/tree/master/LSystem

Audio Output

The idea is to eventually route MIDI output to a MIDI application where I can potentially run filters on the code. I will probably use Abelton for this work, but for the meantime I do not want that to slow down my development of the actual program

Ableton Extension: https://github.com/tassock/ofxAbleton
Generic MIDI Extension: https://github.com/danomatika/ofxMidi



In the meantime, I have alternatively downloaded some audio files of a sampled piano, modified, and exported them as wave from here:

University of Iowa Music Instrument Samples: http://theremin.music.uiowa.edu/MIS.html

Progress

I've got openFrameworks up and running (as seen in image above)

I figured out how to install addons

I've rounded up the initial addons I need for my base proposition, and started looking at addons for my stretch goals

I'm working on modifying the parser from LSys to play music back while it reads the l-system, but that is going to need to be modified further so that the sounds play back appropriately

I'm currently just working with a subset of the C-major scale (C, F, G, A, D) because it's easy to make something more coherent, and it limits my inputs and axioms.

Notes

• I'm worried about the MIDI side of things. If the wav side is fast enough, I may just run with it for this project, though it wouldn't be ideal
• I need to make a decision about what I want the visuals to be so I can begin developing them as well. I feel very behind right now because of the weekend (family came in to visit, birthday)
• I'm worried about the length of the strings getting too long, so I need to do a better job of encoding my 

Life-based Systems Project Idea

Idea

Generate and play "music" by interpreting L-system nodes as notes and same-level branches as chords

Proposal

• The backend will be an L-system interpreter
• Input will be fixed based on my experimentation
• The resulting L-System will be interpreted and played-back as music

Goals

• Find or write a C++-based L-system interpreter
• Experiment with L-systems that produce tree-like structures normally, but replace the F (forward) symbols with letters.
• lowercase = transitions
• uppercase = notes?
• Modify the drawing l-system parser to play the l-system instead

Stretch Goals

• Realtime playback of visuals in OpenFrameworks
• MIDI Output / Streaming to 3rd party application
• Randomization of input
• Genetics and fitness to breed "better" L-systems for sound

Reference

http://www.tursiops.cc/fm/