I was fired back in, think it was August? . I then had a three month “paid vaccination”(it was in my contract that in the event I was fired they had to pay me for 3 months but I didn’t have to come to work…sweet). Did some consulting work, mostly to have something to do. Then I thought to my self that this was an excellent time to set a dream of mine in motion. I come from a background in computer and electronic engineering.

In my Flash/Java work I always had this strange feeling in the back of my head going “At some point this is going to break or perform strangely, and I have no way, other that trial and error, to figure out why”. This is harshly put, but I have been used to dealing with µControllers, the C language and copper-wire  for a long time and even though I appreciate things that “just work” as much as the next guy, I also feel the complete despair when it does not and you have no way of getting “under the hood”.

Im probably being ignorant and if I would I could sit down and read up on every nook and cranny of the runtime, then I would be the all-omnipotent, all-mighty and know-it-all master of… a nook.

My previous job involved building Flash apps for the AIR  runtime environment, I know, I know, that is asking for trouble(2007-2009), and my only real choice of an editor was Eclipse. Im a Mac user and that just “grinds my gears” to have to use some “lowest common denominator” GUI for what I do with most of the hours Im awake.

I have a duality in my that dictates that I love building stuff for the internal intricacies and that I only can enjoy software, furniture, food TV series etc. if I know the order and beauty that governs the inside also governs the outside, i.e. I like good design on both the inside and the outside.

So how do I get to work with µControllers and hardware, beautiful interfaces and have a set of development tools that doesn’t hate me and gives me a stack dump when I ask for it?

I have become an iPhone developer!

OK, plan… by rationing my means I can sustain myself for almost a year. In that timeframe I should be able to (a) learn Objective C (b) get a few apps in the store (c) go down new roads and be happy:)

So for the last three months I have been developing an app that will _blank_ for _blank_ when you go _blank_, with a designer called Mino, which is a secretive guy, hence the _blank_

Now we are close to a Beta version and I my head is exploding with pieces of info that I would like to put on the blog. Im at the state of learning a new language where I bought the first “pattern book”, which means I did a lot of “ahh this seems to be the way to go” only to go “ahh so that is how I should have done it” a few hours later. Well, to cut it short, I don’t think there will be a lot of AS – Java stuff on the blog in the time to come, but I hope to keep doing the visual experiments and give out some code snippets.

I’ll surely move on to building some Mac software afterwards, I like the tools, the Apple frameworks has the standard of the Apple hardware (95% perfect and 5% “WTF, this took me forever and now it’s broken again”) also I get the “complete package experience” that I was missing in my other endeavors.

So please spread the word that Im up for crazy and exciting projects, both here in DK and abroad.

A small 5 min. run of the program

Example and code here

I have taken some time to get my Yamaha DTXplorer electronic drums to communicate nicely with my Mac, finally it worked out and I can now “harvest” the sweet, sweet MIDI coming from the drums. Im no Moby, so believe me when I say these last one and a half days of frustrations was not to immortalize the sound of my drumming. It was, of course to get the data into Processing. A friend of mine is a DJ and he wanted us to experiment with playing “live” drums along with the turntables. Furthermore, to make some sort of visualization that would be 100% true to the beat. This is very hard I found out, there are a lot of good sound libraries with beat detection out there, but they are never plug n’ play. You need to tweak your code for every single song and even that is no guarantee for a consistent output. I came up with a pretty straight forward solution, if we were to use the electronic drums anyway we could just as well use the MIDI for the beat detection and then have the turntables control the colors.

I found out that I needed a few different applications and a MIDI cable before I got the signal all the way through. First off is the ESI MidiMate cable, I actually had the old model, but I think it was broken and could not handle if the MIDI in was not connected to a ground plane. It was 295 Danish Kroner ( ≈$55 ). Then I needed MidiPipe. This a free application developed by Nico Wald and it is brilliant! Should I ever make any money with this setup I will run to a browser and donate some money to Nico.
The idea with MidiPipe is that it “hijacks” every single MIDI port it can detect on the system, you then drag the one you need to the pipe(ESI MIDIMATE Port 1 turn up in MidiPipe the second I connected it to the drumkit) you can then drag other stuff into the pipe. I dragged in “AList” from the “Modifier” and that gave me just what it says, a list of all midi signals passing through MidiPipe.

MidiPipe is a life-saver

This was a cool way of testing out the drums. Lastly I dragged a “MIDI out” into the Pipe, more about that in a second. Then I went out and finally bought that license for OSCulator. Osculator have been running my Wiimote, iPhone, Arduino and Make controller for the last year and I have been to lazy/cheap to just buy the license. Well Osculator is a $15 minimum, but Camille asks people nicely to pay $39, which I did, of course, having used his software for about a year now. What Osculator can do is just to much to explain here… I needed it to translate my MIDI into OSC (because OSC is the new MIDI ) and then relay the rewritten data to a port on localhost using UDP. This was done so I could have some control over the data, also I now get something along the lines of “snare – on – 0.6″ (thats the pad sending the message, that it was “on”/hit and the strength it was hit with) into Processing instead of some MIDI byte I have to bitwise shift around to get any data from it, it just makes debugging easier and sending something through Osculator opens a world of other possibilities.

It is just crazy how many features there can be in such a simple application

A note here, when I started Osculator, MidiPipe noticed Osculator was listening on port 8000 and stuffed that piece of information into the “MIDI out” I mentioned earlier, now I could just select it there. So now my MIDI came in through MidiPipe, was listed for me to see and then relayed on to Osculator. In Osculator I caught each MIDI event and by selecting the signal and going Osculator – Edit – Demux, I could split the signal into its components and rebroadcast them as OSC messages on the network. For handling OSC Protocol stuff in Processing Andreas Schlegel did a really great library, you can get it here along with some other goodies Andreas made.

I now had 8 different OSC messages, one for each drum pad, cymbal and foot pedal (Im going to do the high hat pedal later on) that I can read out in Processing. I did a small sketch as you see in the video and just started the “play along” feature on my DTXplorer kit, with some “Hard Rock” selected and and the computers microphone recording.

And as always if there is some code or help You need just leave a mail or comment.

A version not completely compressed by the geniuses over at youtube

Example and code here

This was just some “while Im doing nothing, let’s put whatever in the ‘fun’ category” but if anyone would like the code, throw me a comment and I’ll send it off. I is uncommented and messy.

]]> http://www.rickigregersen.com/2009/08/11/sporetree/feed/ 5 http://www.rickigregersen.com/2009/08/09/circle-intersection/ http://www.rickigregersen.com/2009/08/09/circle-intersection/#comments Sun, 09 Aug 2009 21:17:42 +0000 Ricki http://www.rickigregersen.com/?p=190

“What is the point”

was my first thought on this.
I had to do some calculations on the intersections between circles, that was pretty straight forward and I got a class written up in Processing that could do just that.
Then I started playing around and ended up moving 10 circles around the screen using Perlin noise and if any of them intersects, I draw a dot. Pointless? certainly!

Maybe there is someone out there with an idea on how to make this into something other that a cpu hogging math feast. I would love to hear from You:)

Well there is some Perlin movement, some ArrayList looping and of course that class that takes 2 circles and returns their intersection, maybe someone can use that for something useful.

Example and code here:

EDIT: forgot some int/float math that made the tentacles look bulky… better now.
Example and code here:

Thanks again to Justin.

The spore Class turned out to look like this, it needs going over, but I was thinking on porting it to Processing and really get my tentacles on

The code:

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

package 
{
	import flash.display.Graphics;
	import flash.display.Sprite;
	import flash.geom.Point;
	import flash.utils.setTimeout;
 
	public class Spore extends Sprite
	{
		private static const LENGTH:int = 90;
		private var _posX:Vector.<Number>;
		private var _posY:Vector.<Number>;
		private var angStep:Number;
		private var posStep:Number;
		private var curl:Number;
		private var n:Number = 0;
		private var a:Number = Math.random() * Math.PI * 2;
		private var _index:int;
		private var _g:Graphics;
 
		public function Spore()
		{
			_posX = new Vector.<Number>( LENGTH, true );
			_posY = new Vector.<Number>( LENGTH, true );
			_g = graphics;
			this.generate( range( 0.01, 0.05 ), range( 2.0, 3.0 ), range( 0.2, 1.0 ) );
		}
 
		public function generate( aStep:Number, pStep:Number, c:Number ):void
		{
			_index = 0;
			angStep = aStep;
			posStep = pStep;
			curl = c;			
			var loc:Point = new Point( 0, 0 );
			while( _index < LENGTH )
			{
				n += Math.random() * (angStep - -angStep) + -angStep;
				n *= 0.9 + curl * 0.1;
				a += n;
				loc.x += Math.cos( a ) * posStep;
				loc.y += Math.sin( a ) * posStep;
				_posX[ _index ] = loc.x;
				_posY[ _index ] = loc.y;
				_index++;
			}
			_index = 0;
		}
		public function step():void
		{
			_g.clear();
			_g.lineStyle( 0, 0x000000, 0.7 );
			var c:int = 0;
			var radius:Number;
			while( c < _index )
			{
				radius = _index / c; 				
				if( radius > 10 ) radius = 10;
				_g.beginFill( 0xFF6600, 0.4 );
				_g.drawCircle( _posX[ c ], _posY[ c ], radius );
				_g.endFill();
				c++;
			}
			_index++;
			if( _index >= LENGTH )
			{
				this.generate( range( 0.01, 0.05 ), range( 2.0, 3.0 ), range( 0.2, 1.0 ) );
			}
		}
		private function range(min:Number, max:Number = NaN):Number
		{
			if(isNaN(max)) {max = min; min = 0}
				return min + (Math.random() * (max - min));
		}		
	}
}

The code:

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

//playing around with something Zevan Rosser from http://actionsnippet.com/?p=1236 did
//on his blog
 
package {
 
	import flash.display.*;
	import flash.events.*;
 
	[SWF( width="512", height = "512", backgroundColor = "0x222222", frameRate = "120" )]
 
	public class RandomWalk extends Sprite 
	{
		private var _canvas:BitmapData;
		private var _count:int = 100;
		private var _movers:Vector.<Mover>;
 
		public function RandomWalk()
		{
			var w:Number = 512;
			var h:Number = 512;
			scaleX=scaleY = 0.25;
			_canvas = new BitmapData( w * 4, h * 4, false, 0x222222 );
			addChild( new Bitmap( _canvas ));
 
			_movers = new Vector.<Mover>();
 
			for ( var i:int = 0; i < _count; i++ ) 
			{
				_movers[ i ] = new Mover( _canvas, w * 1.5 + Math.random() * w, h * 1.5 + Math.random() * h );
			}
			addEventListener( Event.ENTER_FRAME, onRun );
		}
		private function onRun( evt:Event ):void 
		{
			for (var i:int = 0; i < 200; i++) 
			{
				for (var j:int = 0; j < _count; j++) 
				{
					_movers[ j ].run();
				}
			}
		}
	}
}
 
import flash.display.BitmapData;
class Mover 
{
	public var x:Number;
	public var y:Number;
	public var velX:Number;
	public var velY:Number;
	public var speed:Number;
	private var _canvas:BitmapData;
	private var _color:uint;
 
	public function Mover( canvas:BitmapData, xp:Number, yp:Number ) 
	{
		_color = 0xFF6600;//Math.random() * 0xFFFFFF;
		_canvas = canvas;
		x = xp;
		y = yp;
		velX = 0;
		velY = 0;
		speed=Math.random() * 5 - 2.5;
	}
 
	public function run():void 
	{
		x += velX;
		y += velY;
		_canvas.setPixel( x, y, _color );
 
		var dir:Number = int( Math.random() * 4 );
 
		if (dir == 0) 
		{
			velX = 0;
			velY =- speed;
		} 
		else if (dir == 1) 
		{
			velX = 0;
			velY = speed;
		} 
		else if (dir == 2) 
		{
			velX =- speed;
			velY = 0;
		} 
		else if (dir == 3) 
		{
			velX = speed;
			velY = 0;
		}
	}
}

The Soulwire Tentacles was an experiment in PixelBender speed and usability, so he makes it look as if the tentacles are really growing, i.e. starts out small and each “joint” grows as the tentacles grows. Mine is just a look into the random-organic way they grow. Also I was trying to see what kinds of speed I would get by using the Bitmap approach.

Here are the Soulwire Tentacles

And here are my Tentacles… that came out wrong…

The code:

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

/**
*
 * @BitmapSpore.as	:	inspired by http://blog.soulwire.co.uk/flash/actionscript-3/pixel-bender-growing-tentacles/
 * @Date  08/06-09
 * @Ricki Gregersen
*/
 
package
{
	import flash.display.Bitmap;
	import flash.display.BitmapData;
	import flash.display.Sprite;
	import flash.events.Event;
	import flash.filters.BlurFilter;
	import flash.geom.ColorTransform;
	import flash.geom.Point;
 
	[SWF( width="512", height = "512", backgroundColor = "0x222222", frameRate = "30" )]
 
	public class BitmapSpore extends Sprite
	{
		private static var fading : ColorTransform = new ColorTransform( 1, 1, 1, 0.99999 );
		private static var _blur : BlurFilter = new BlurFilter( 1, 1, 2 );
 
		private var _bmd:BitmapData;
		private var _bmp:Bitmap;
		private var _container:Sprite;
 
		public function BitmapSpore()
		{
			_bmd = new BitmapData( 512, 512, true, 0x222222 );
			_bmp = new Bitmap( _bmd );
			addChild( _bmp );
			var s:Spore;
			addChild( _container = new Sprite() );
			for( var i:int = 0; i < 500; i++ )
			{
				s = new Spore( 256, 256, range( 0.01, 0.05 ), range( 2.0, 3.0 ), range( 0.2, 1.0 ));
				s.scaleX = s.scaleY = Math.random() * 2;
				_container.addChild( s );
			}
			addEventListener( Event.ENTER_FRAME, update );
		}
 
		private function update( event:Event ):void
		{
			var n:int = _container.numChildren;
			var s:Spore;
 
			for( var i:int = 0; i < n; i++ )
			{
				s = Spore( _container.getChildAt( i ));
				s.move();
				s.x = s.loc.x;
				s.y = s.loc.y;
			}			
			_bmp.filters = [  _blur ];
			_bmd.colorTransform( _bmd.rect, fading ); 			
			_bmd.draw( _container );
		}
 
		private function range(min:Number, max:Number = NaN):Number
		{
			if(isNaN(max)) {max = min; min = 0}
				return min + (Math.random() * (max - min));
		} 
 
	}
}
	import flash.geom.Point;
	import flash.display.Shape;
 
	class Spore extends Shape
	{
		public var loc:Point;
 
		private var angStep:Number;
		private var posStep:Number;
		private var curl:Number;
		private var n:Number = 0;
		private var a:Number = Math.random() * Math.PI * 2;
 
		function Spore( xPos:Number, yPos:Number, aStep:Number, pStep:Number, c:Number )
		{
			loc = new Point( xPos, yPos );
			angStep = aStep;
			posStep = pStep;
			curl = c;
			graphics.lineStyle( 0, 0x222222, 0.7 );
			graphics.beginFill( 0xFF6600, 0.7 );
			graphics.drawCircle( 0, 0, 5 );
			graphics.endFill();	
		}
		public function move():void
		{
			n += Math.random() * (angStep - -angStep) + -angStep;
			n *= 0.9 + curl * 0.1;
			a += n;
			loc.x += Math.cos( a ) * posStep;
			loc.y += Math.sin( a ) * posStep;			
			this.scaleX = this.scaleY *= 0.98;
			var s:Number = this.scaleX = this.scaleY;
			if( s < 0.1 )
			{
				loc.x = loc.y = 256;
				this.scaleX = this.scaleY = Math.random() * 2;
			}
		}
	}