Hello folks, just sharing a small datavis project I worked on recently - it compares the percentage of each countries population that have internet access with the percentage of the population that use Facebook. 

Hello folks.

Was messing around with Mike Davis' Conway code, and decided to see how it works in 3d with cubes. Often it initially produces some interesting patterns, but then gets pretty chaotic. Here's the code anyway, it requires the PeasyCam library but if you comment those few lines out it will still run fine.

If anyone has any more suggestions on how to get better results and/or spot any mistakes do let me know!

1. /*
2. Game of Life (in 3d!)
3. Based on Mike Davis' Conway sketch.
4. Press a key to regenerate, control cam with mouse.
5. */
6. import processing.opengl.*;
7. import peasy.*;
8. PeasyCam cam;
9. PFont font;
10. int generations;
11. ArrayList lives;
12. void setup(){
13.   size(1000, 800, OPENGL);
14.   frameRate(12);
15.   generations = 0;
16.   font = loadFont("Monaco-12.vlw");
17.   textFont(font, 12);
18.   cam = new PeasyCam(this, 400);
19.  
20.   lives = new ArrayList();
21.   lives.add(new Life(80, 80, 80, 0.135, 5, 0));
22. }
23. void draw(){
24.   background(0);
25.  
26.   generations++;
27.   rotateX(radians(45));
28.   rotateZ(radians(45));
29.  
30.   fill(255);
31.   cam.beginHUD();
32.   text("Generations: "+generations, width-150, height-20);
33.   cam.endHUD();
34.  
35.   noFill();
36.   for(int i=lives.size()-1; i>=0; i--){
37.     Life life = (Life)lives.get(i);
38.     life.render();
39.     if(keyPressed == true){
40.       generations = 0;
41.       lives.remove(i);
42.       lives.add(new Life(80, 80, 80, 0.135, 5, 0));
43.     }
44.   }
45. }
46. class Life{
47.   int w, h;
48.   int depth;
49.   float density = 0.8;
50.   int sz = 3;
51.   int[][][][] world;
52.   color layer;
53.   Life(int _w, int _h, int _d, float _density, int _sz, color _layer){
54.     w = _w;
55.     h = _h;
56.     depth = _d;
57.     density = _density;
58.     sz = _sz;
59.     color layer = _layer;
60.     world = new int[w][h][depth][2];
61.     for(int i=0; i<density*w*h*depth; i+=sz){
62.       world[(int)random(w)][(int)random(h)][(int)random(depth)][0]=1;
63.     }
64.   }
65.   void render(){
66.     fill(0, 100);
67.     for(int i=0; i<w; i+=sz){
68.       for(int j=0; j<h; j+=sz){
69.         for(int k=0; k<depth; k+=sz){
70.           if((world[i][j][k][1] == 1) || (world[i][j][k][1] == 0 && world[i][j][k][0] == 1)){
71.             world[i][j][k][0]=1;
72.             stroke(255-i*2.5, j*2.5, k*2.5);
73.             pushMatrix();
74.             translate(i, j, k);
75.             box(sz);
76.             popMatrix();
77.           }
78.           if(world[i][j][k][1] == -1){
79.             world[i][j][k][0] = 0;
80.           }
81.           world[i][j][k][1] = 0;
82.         }
83.       }
84.     }
85.     for(int i=0; i<w; i+=sz){
86.       for(int j=0; j<h; j+=sz){
87.         for(int k=0; k<depth; k+=sz){
88.           int count = neighbours(i, j, k);
89.           if(count == 4 && world[i][j][k][0] == 0){
90.             world[i][j][k][1] = 1;
91.           }
92.           if((count < 3 || count > 4) && world[i][j][k][0] == 1){
93.             world[i][j][k][1] = -1;
94.           }
95.         }
96.       }
97.     }
98.   }
99.   int neighbours(int x, int y, int z){
100.     return world[(x+sz) % w][y][z][0] +
101.       world[x][(y+sz) % h][z][0] +
102.       world[(x+w-sz) % w][y][z][0] +
103.       world[x][(y+h-sz) % h][z][0] +
104.       world[(x+sz) % w][(y+sz) % h][z][0] +
105.       world[(x+w-sz) % w][(y+sz) % h][z][0] +
106.       world[(x+sz) % w][(y+h-sz) % h][z][0] +
107.       world[(x+w-sz) % w][(y+h-sz) % h][z][0] +
108.       world[(x+sz) % w][y][(z+sz) % depth][0] +
109.       world[x][(y+sz) % h][(z+sz) % depth][0] +
110.       world[(x+w-sz) % w][y][(z+sz) % depth][0] +
111.       world[x][(y+h-sz) % h][(z+sz) % depth][0] +
112.       world[(x+sz) % w][(y+sz) % h][(z+sz) % depth][0] +
113.       world[(x+w-sz) % w][(y+sz) % h][(z+sz) % depth][0] +
114.       world[(x+sz) % w][(y+h-sz) % h][(z+sz) % depth][0] +
115.       world[(x+w-sz) % w][(y+h-sz) % h][(z+sz) % depth][0] +
116.       world[(x+sz) % w][y][(z+depth-sz) % depth][0] +
117.       world[x][(y+sz) % h][(z+depth-sz) % depth][0] +
118.       world[(x+w-sz) % w][y][(z+depth-sz) % depth][0] +
119.       world[x][(y+h-sz) % h][(z+depth-sz) % depth][0] +
120.       world[(x+sz) % w][(y+sz) % h][(z+depth-sz) % depth][0] +
121.       world[(x+w-sz) % w][(y+sz) % h][(z+depth-sz) % depth][0] +
122.       world[(x+sz) % w][(y+h-sz) % h][(z+depth-sz) % depth][0] +
123.       world[(x+w-sz) % w][(y+h-sz) % h][(z+depth-sz) % depth][0];
124.   }
125. }

Strictly speaking this is an arduino based project, but I used processing to handle the incoming data and create the visuals. I built a small device consisting of an ultrasonic distance sensor attached to a rotating assembly - which when switched on would scan a room and produce a 2-dimensional map of the space the device is placed in. The distance data was sent to processing in order to generate a kind of graphic score, and also via OSC to pure data which would then synthesize responsive audio in realtime.

Here are some images of the project installed:




Also you can watch a video of the project on vimeo here: http://vimeo.com/12763642

There were a few things I could do with improving the work, so let's hope for a 3.0! Initially I had a bit of trouble as the motor would not exactly correspond to the visuals after running for an hour or so. I was thinking about a foolproof way of keeping the visuals in sync with the rotation of the motor, so perhaps a hall-effect sensor (detects a magnet) that would count the time of one full rotation of the sensor - thus setting the graphic score's rotation speed.

It was a fun project anyway! For more information/source code:
http://hendersonsix.com/#212455/Radius-Music
http://hendersonmedia.wordpress.com