Hi All. Im working on designing an instrument using the jit.conway object

I want to take the data it generates to be used as an argument for another object like an oscillator

How do I best manage the output data from the Matrix and/or jit.pwindow?

The idea is to have the CA running in the jit.conway object and have it output data

This data will be organised in some way to make it produce sounds via controlling an argument for oscillators (ideally I want 9 that divide up the ifno in the jit.pwindow

(eg for cells 0-9 across and 0-9 down = numbers to be organised for oscillator 1

...for cells 10-19 across and 0-9 down = numbers to be organised for oscillator 2

I want the evolution of the CA to be represented as a number to control something that generates sound

Any help, advice, links to other posts, objects, list manipulation help etc etc would be seriously helpfull

feel free to chop and change the patch as you see fit

Hi All.  Im working on designing an instrument using the jit.conway object

The idea is to have the CA running in the jit.conway object and have it output data
This data will be organised in some way to make it produce sounds via controlling an argument for oscillators (ideally I want 9 that divide up the ifno in the jit.pwindow
(eg for cells 0-9 across and 0-9 down = numbers to be organised for oscillator 1
...for cells 10-19 across and 0-9 down = numbers to be organised for oscillator 2
etc

how-do-i-manage-the-data-generated-by-jit-conway

Here's a link to a vid of my 'Life' instrument using jit.conway. I ended up using the RGB channels as the basis for three synths. They used a combination of jit.peek~ and ioscbank~ to 'sonify' each plane:

http://www.youtube.com/watch?v=YYYHWtpJQT0

You might want to look at my Boids one too. In this each boid represented an oscillator in a kind of additive synth. I took the x position to control things like panning, FX amount etc and the y position to control what note was played. They also controlled a bass synth and sort of controlled a couple of drum machines too, but it was more of a random thing.

http://www.youtube.com/watch?v=c9cEVYlAcbU

It sounds like additive synthesis might work for you too. So you use jit.spill to get your list of values from your matrix which could decide the levels/frequency of each oscillator in the additive synth. Just an idea…

Wow! thanks these are great! I'm not as advanced at Max as you are clearly but think I might be able to get my head round these. The maths for managing specific data is the part that drives me nuts. Is there any chance I can have a look at a patch you may have. I've been mucking arounfd with jit.peek and jit.spill for a while now and not really understanding how to correctly connect the objects or manage the numbers involved

In theory I assume I want to send a number to a number box and the maths behind the scenes determines the exact number but its the idea of mapping that I don't really get.

The boids instrument is awesome but I think that may be a bit advanced for me, although again if I could check out the patch it would help fill in a lot of the details.

If its not possible to see your patches I fully respect that, but if thats the case could I ask for some advice on how to use your idea of the RGB planes. I notice in the youtube video there are some subpatches involved. The idea of coloured pixels ties into the idea I originally had which was about emulating a chemical oscillator but thats proved to be too taxing for a reletive newbie like myself.

sorry for the rant but you seem to know how to do a lot of the things I've been trying to work out for some time. All advice greatly recieved.

Wow! thanks these are great!  I'm not as advanced at Max as you are clearly but think I might be able to get my head round these.  The maths for managing specific data is the part that drives me nuts.  Is there any chance I can have a look at a patch you may have.  I've been mucking arounfd with jit.peek and jit.spill for a while now and not really understanding how to correctly connect the objects or manage the numbers involved

If its not possible to see your patches I fully respect that, but if thats the case could I ask for some advice on how to use your idea of the RGB planes.  I notice in the youtube video there are some subpatches involved.  The idea of coloured pixels ties into the idea I originally had which was about emulating a chemical oscillator but thats proved to be too taxing for a reletive newbie like myself.

sorry for the rant but you seem to know how to do a lot of the things I've been trying to work out for some time.  All advice greatly recieved.


These were my first major Max projects from a few years back and there's some hideously bad patching in there (I hadn't even discovered send and receive for the boids one, patch cables everywhere!). I'll try and separate some of the helpful bits for you. I also made a bit of a tool with the matrixctrl object that lets you draw new patterns and save them into a coll so that might help you. The matrixctrl is a good example of how jit.conway can be used as a controller with jit.spill, so each cell has an on or off (0 or 255) and each cell could represent an oscillator, sample sound or loop, note, volume whatever. I'll fix you up some examples when I've got a bit more time.

awesome! I'll get stuck into the jit.spill , jit.peek etc families of objects to get up to speed. I haven't used the mtrixcntrl at all yet so will get into that one too.

Its a pretty open ended idea for a uni project but fundamental to me getting the instrument working is understanding all the relevant objects and the maths.

Thanks for your help again, I'll get stuck into the patches when they come, no major rush - but really looking forward to seeing them

awesome!  I'll get stuck into the jit.spill , jit.peek etc families of objects to get up to speed.  I haven't used the mtrixcntrl at all yet so will get into that one too.  

Here's something to get you started, watch your volume!

Getting some good ideas form your patch. Thanks very much!!

One question though about the jit peek subpatch...

If the 'jit.peek~ life2 2' takes two inputs.

left inlet = dimension 0 (choice of column) and,

Right inlet = dimension 1 (choice of row)

How does the data work in terms of sending data to each 'jit.peek~ life2 2'?

If a 'phasor' is attatched to the left inlet and the 'sig~' attatched to the right,

the 'sig~' object has the argument 1 then 2 then 3 etc for each 'sig~',

Does this mean row 1, row 2, row 3, etc as in this tells jit.peek that the value for its right inlet (choice of row) is to be 1,2,3 etc? If so is 'sig' herefore a way of saying 'I constantly want the value sent to the jit.peek right inlet to be 1, 2 for the next 'jit.peek', 3 etc?

Secondly if this is the case then as the phasor supplies data for the left inlet (choice of column) how does this actually specify a number for the left inlet to take?

Is it because this becasue the matrix we are using is only 1 plane?

I guess what im asking is how and why is the phasor involved? what data does it produce to provide a number fr the 'jit.peek life 2 2''s left inlet and how does

'jit.peek life 2 2' handle this data (translate it)?

If the 'jit.peek~ life2 2' takes two inputs.
left inlet = dimension 0 (choice of column) and,
Right inlet = dimension 1 (choice of row)
....
How does the data work in terms of sending data to each 'jit.peek~ life2 2'?

If a 'phasor' is attatched to the left inlet and the 'sig~' attatched to the right,
the 'sig~' object has the argument 1 then 2 then 3 etc for each 'sig~',
Does this mean row 1, row 2, row 3, etc as in this tells jit.peek that the value for its right inlet (choice of row) is to be 1,2,3 etc?  If so is 'sig' herefore a way of saying 'I constantly want the value sent to the jit.peek right inlet to be 1, 2 for the next 'jit.peek', 3 etc?

Is it because this becasue the matrix we are using is only 1 plane?
I guess what im asking is how and why is the phasor involved? what data does it produce to provide a number fr the 'jit.peek life 2 2''s left inlet and how does
'jit.peek life 2 2' handle this data (translate it)?


Yes the sig~ is effectively constantly sending a number and telling jit.peek to look at corresponding row. The phasor~ combined with [*~ 32] is effectively just counting through the columns for that row.

So jit.peek is looking at the named matrix 'life2', the 2 says how many dimension inputs we want the object to have and if we had more than one plane we could put the number of the plane we wanted to examine after that. jit.peek requires signal inputs so instead of something like [counter] to count the columns we have to use something like phasor~. It makes a good control signal and timer and you'll often see it being used in this way. We multiply its 0 to 1 signal by 32 so we are scanning through the columns on our chosen row to generate sound when we see a live pixel. The higher the frequency of phasor~ the faster it counts through the columns and the higher pitch the sound is.

How do I manage the data generated by jit.conway?