package {
	import flash.display.*;
	import flash.media.*;
	import flash.events.*;
	import flash.geom.*;
	import flash.filters.ColorMatrixFilter;
	
	public class MotionTracker extends Sprite {
		private var cam:Camera;
		private var video:Video;
		private var videoHolder:MovieClip = new MovieClip();
		private var holder:MovieClip = new MovieClip();
		private var graph:MovieClip = new MovieClip();
		public var bmd:BitmapData = new BitmapData(550, 400, false, 0x000000);
		public var bm:Bitmap;
		
		private var allfilter:ColorMatrixFilter;
		private var allcmx:Array = new
		Array(1,-1,-1,0,
		0,-1,1.5,-1,
		0,0,-1,-1,
		1,0,0,0,
		0,0,1,0);
		
		private var trackingRed:Boolean = false;
		
		private var oldRedX:Number = new Number();
		private var oldRedY:Number = new Number();
		private var deltaRedX:Number = new Number();
		private var deltaRedY:Number = new Number();
		
		private var tekstveld:TextField;
		public function MotionTracker():void{
			video = new Video(550,400);
			cam = Camera.getCamera();
			cam.setMode(550,400,30);
			video.attachCamera(cam);
			videoHolder.addChild(video);
			bm = new Bitmap(bmd);
			holder.addChild(bm);
			addChild(holder);
			addChild(graph);
			
			allfilter = new ColorMatrixFilter(allcmx);
			
			addEventListener(Event.ENTER_FRAME, loop);
			holder.addEventListener(MouseEvent.CLICK, clickHandler);
			
			tekstveld = new TextField();
			tekstveld.width = 550;
			tekstveld.height = 30;
			tekstveld.textColor = 0xFFFFFFFF;
			tekstveld.y = 370;
			tekstveld.text = "tekst";
			addChild(tekstveld);
		}
		
		private function loop(e:Event):void{
			bmd.draw(videoHolder);
			bmd.applyFilter(bmd, bmd.rect, new Point(), allfilter);
			
			graph.graphics.clear();
			bmd.threshold(bmd,bmd.rect,new Point(), ">", 0xFF330000, 0xFFFF0000, 0xFFFF0000);
			bmd.threshold(bmd,bmd.rect,new Point(), ">", 0xFF003300, 0xFF00FF00, 0xFF00FF00);
			bmd.threshold(bmd,bmd.rect,new Point(), ">", 0xFF000033, 0xFF0000FF, 0xFF0000FF);
			
			
			var redrect:Rectangle = bmd.getColorBoundsRect(0xFFFFFFFF, 0xFF0000);
			var bluerect:Rectangle = bmd.getColorBoundsRect(0xFFFFFFFF, 0x0000FF);
			var greenrect:Rectangle = bmd.getColorBoundsRect(0xFFFFFFFF, 0x00FF00);
			if(redrect.width != 0 || bluerect.width != 0 || greenrect.width != 0){
				drawColorBoundsRect(greenrect, 0x00FF00);
				drawColorBoundsRect(redrect, 0xFF0000);
				drawColorBoundsRect(bluerect, 0x0000FF);
				
				var distances:Object = colorDistances(redrect, greenrect, bluerect);
				
				if(distances.redToGreen < 50){
					trace("click");
					//stuur data naar socket
				}
				if(distances.redToBlue < 50){
					trace("right click");
				}
			}
			
			// Deze code (de if-statement) is alleen nodig als je met een socket werkt die de data vervolgens verwerkt.
			if(redrect.width != 0){
				if(trackingRed){
					deltaRedX = int((redrect.x + redrect.width / 2) - oldRedX);
					deltaRedY = int((redrect.y + redrect.height / 2) - oldRedY);
					//stuur ook deze data naar de socket
				}
				trackingRed = true;
				oldRedX = redrect.x + redrect.width / 2;
				oldRedY = redrect.y + redrect.height / 2;
			} else {
				trackingRed = false;
				deltaRedX = 0;
				deltaRedY = 0;
			}
		}
		
		private function colorDistances(redrect:Rectangle, greenrect:Rectangle, bluerect:Rectangle):Object{
			var greenRectCenter:Point = new Point(greenrect.x + greenrect.width /2, greenrect.y + greenrect.height /2);
			var redRectCenter:Point = new Point(redrect.x + redrect.width /2, redrect.y + redrect.height /2);
			var blueRectCenter:Point = new Point(bluerect.x + bluerect.width /2, bluerect.y + bluerect.height /2);
			
			graph.graphics.lineStyle(1, 0xFFFF00);
			graph.graphics.moveTo(greenRectCenter.x, greenRectCenter.y);
			graph.graphics.lineTo(redRectCenter.x , redRectCenter.y);
			graph.graphics.lineStyle(1, 0xFF00FF);
			graph.graphics.moveTo(redRectCenter.x, redRectCenter.y);
			graph.graphics.lineTo(blueRectCenter.x , blueRectCenter.y);
			graph.graphics.lineStyle(1, 0x00FFFF);
			graph.graphics.moveTo(blueRectCenter.x, blueRectCenter.y);
			graph.graphics.lineTo(greenRectCenter.x , greenRectCenter.y);
			
			var distances:Object = new Object();
			
			distances.redToGreen = calculateDistance(greenRectCenter, redRectCenter);
			distances.redToBlue = calculateDistance(blueRectCenter, redRectCenter);
			
			return(distances);
		}
		
		private function calculateDistance(p1:Point, p2:Point):Number{
			return(Math.sqrt((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y)));
		}
		
		private function drawColorBoundsRect(rect:Rectangle, color:uint){
			graph.graphics.lineStyle(1, color, 1);
			graph.graphics.beginFill(color, 0.3);
			graph.graphics.drawRect(rect.x, rect.y, rect.width, rect.height);
			graph.graphics.endFill();
		}
	}
}

private var allcmx:Array = new 
Array(1,-1,-1,0,
        0,-1,1.5,-1,
        0,0,-1,-1,
        1,0,0,0,
        0,0,1,0);

bmd.threshold(bmd,bmd.rect,new Point(), ">", 0xFF330000, 0xFFFF0000,  0xFFFF0000);
var redrect:Rectangle = bmd.getColorBoundsRect(0xFFFFFFFF, 0xFF0000);

//In plaats van

var v1:Number = 10;
var v2:Number = 20;
var v3:Number = Math.max(v1,v2);

//prefereer ik (± 8.5x zo snel)

var v1:Number = 10;
var v2:Number = 20;
var v3:Number = (v1 >= v2) ? v1 : v2;

//In plaats van

var v1:Number = -10;
var v2:Number = Math.abs(v1);

//prefereer ik (± 7.5x zo snel)

var v1:Number = -10;
var v2:Number = (v1 < 0) ? -v1 : v1;

var v1:Number = 10.5;
var v2:int;

//In plaats van
v2 = Math.floor(v1);

//prefereer ik (± 3.5x zo snel)
v2 = int(v1);

var v1:Number = 10.5;
var v2:int;

v2 = v1>>0;

v2 = (v1>0) ? v1 >>0 : (v1>>0)-1;

var v1:Number = 10.5;
var v2:int;

//In plaats van
v2 = Math.ceil(v1);

//prefereer ik (± 2.5x zo snel)
v2 = (int(v1) == v1) ? v1 : int(v1) + 1;

var v1:Number = 10.5;
var v2:int;

v2 = (v1 >> 0 == v1) ? v1 : (v1 >> 0) + 1;

v2 = (v1 >> 0 == v1) ? v1 : (v1 < 0) ? (v1 >> 0) : (v1 >> 0) + 1;

20 / 2 
//is ± 7% langzamer dan 
20 * .5;

var v1:Number = 20;
var v2:Number;

v2 = v1 * .5;
//is ± 1.4x zo snel als
v2 = v1 >> 1;

var v1:int = 20;
var v2: int;

v2 = v1 >> 1;
//is ± 1.6x zo snel als
v2 = v1 * .5;

_txt.x = width-_txt.width >> 1;

//delen door 2
value >> 1;

//vermenigvuldigen met 2
value << 1;

//positief/negatief omdraaien (± 1.2x zo snel)
~value + 1; // is gelijk aan: value * -1; //en is gelijk aan:  -value

//even/oneven controleren
(value & 1) == 0; //is gelijk aan: (value % 2) == 0;

var v1:int = -11;
var v2:int;
//dit:
v2 = v1*-1;
//is sneller dan
v2 = -v1;

var v1:Number = -11;
var v2: Number;
//is dit ± 15% sneller:
v2 = -v1;
//dan:
v2 = v1*-1;

for(var i:uint = 0; i<100; i++)
ipv
for(var i:int = 0; i<100; i++)
en ipv
for(var i:Number = 0; i<100; i++)

var arr:Array = [];

for(var a:uint = 0; a < 10000000; a++)
{
	arr[a] = a ;
}

var arr:Array = [];

for(var a:uint = 0; a < 10000000; a++)
{
	arr.push(a);
}

var arr:Vector.<uint> = new Vector.<uint>();

for(var a:uint = 0; a < 10000000; a++)
{
	arr[a] = a ;
}

var arr:Array = [];

for(var a:uint = 0; a < 10000000; a++)
{
	arr[a] = a;
}

var l:Number = arr.length;
for (var i:uint = 0; i < l; i++ )
{
	v2 = arr[i];
}

for (var i:uint = 0; i < arr.length; i++ )
{
	v2 = arr[i];
}

var mc:MovieClip = new MovieClip();
mc.data = {};
mc.data.x = 10;

var value:Number;

var prop:Number = mc.data.x;

for(var a:uint = 0; a < 10000000; a++)
{
value = prop;
}

var mc:MovieClip = new MovieClip();
mc.data = {};
mc.data.x = 10;

var value:Number;

for(var a:uint = 0; a < 10000000; a++)
{
value = mc.data.x;
}

result = (value1==value2) ? x : y;
//ipv
result = value1==value2 ? x : y;

var v1:Number = -10;
var v2:Number;

//dit:
v2 = (v1 < 0) ? -v1 : v1;
// is iets langzamer dan:
(v1 < 0) ? v2 = -v1 : v2 = v1;

package
{
	import flash.events.MouseEvent;
	import flash.display.Bitmap;
	import flash.display.BitmapData;
	import flash.display.BitmapDataChannel;
	import flash.display.Sprite;
	import flash.display.StageAlign;
	import flash.display.StageScaleMode;
	import flash.events.Event;
	import flash.filters.BlurFilter;
	import flash.geom.ColorTransform;
	
	
	public class FFparticles extends Sprite
	{
		private var bmd : BitmapData;
		private var bmdPerlin : BitmapData;
		private var sizeH : int = 400;
		private var sizeW : int = 600;
		private var particles : Vector.<Particle> = new Vector.<Particle>();
		
		
		private var colorTransform : ColorTransform = new ColorTransform(0.999, 0.95, 0.6, 1, 0, 0, 0, 0);
		private var filter : BlurFilter = new BlurFilter(2,2, 1);
		
		
		
		public function FFparticles()
		{
			stage.scaleMode = StageScaleMode.NO_SCALE;
			stage.align = StageAlign.TOP_LEFT;
			
			bmd = new BitmapData(sizeW, sizeH, false, 0);
			var bm : Bitmap = new Bitmap(bmd);
			
			addChild(bm);
			
			bmdPerlin = new BitmapData(sizeW, sizeH, false, 0);
			
			var bmPerlin : Bitmap = new Bitmap(bmdPerlin);
			bmdPerlin.perlinNoise(200, 200, 5, Math.random() * uint.MAX_VALUE, false, true, BitmapDataChannel.RED | BitmapDataChannel.GREEN, false);
			bmPerlin.x = sizeW;
			addChild(bmPerlin);
			
			
			buildParticles();
			this.addEventListener(Event.ENTER_FRAME, loop, false, 0, true);
			stage.addEventListener(MouseEvent.CLICK, refreshNoise);
		}
		
		private function refreshNoise(event : MouseEvent) : void
		{
			bmdPerlin.perlinNoise(200, 200, 5, Math.random() * uint.MAX_VALUE, false, true, BitmapDataChannel.RED | BitmapDataChannel.GREEN, false);
		}
		
		private function loop(event : Event) : void
		{
			
			
			bmd.lock();
			bmd.colorTransform(bmd.rect, colorTransform)
			
			for each (var part : Particle in particles)
			{
				
				var kleur : uint = bmdPerlin.getPixel(part.x, part.y);
				var rood : int = kleur >> 16 & 0xFF;
				var groen : int = kleur >> 8 & 0xFF;
				part.speedx += (rood - 128) * 0.002;
				part.speedy += (groen - 128) * 0.002;
				
				
				
				
				part.x += part.speedx;
				part.y += part.speedy ;
				
				part.speedx *= 0.985;
				part.speedy *= 0.985;
				
				
				if (part.x > sizeW)
				{
					part.x -= sizeW;
				}else if(part.x < 0)
				{
					part.x += sizeW;
				}
				if (part.y > sizeH)
				{
					part.y -= sizeH;
				}else if(part.y < 0)
				{
					part.y += sizeH;
				}
				
				
				bmd.setPixel(part.x, part.y, 0xFFFFFF);
			}
			bmd.applyFilter(bmd, bmd.rect, bmd.rect.topLeft, filter);
			bmd.unlock();
			
		}
		
		private function buildParticles() : void
		{
			for (var i : int = 0;i < 20000;++i)
			{
				var part : Particle = new Particle();
				part.x = Math.random() * sizeW;
				part.y = Math.random() * sizeH;
				
				particles.push(part);
			}
			
			particles.fixed = true;
		}
	}
}

package
{
	
	
	public class Particle
	{
		public var x:Number;
		public var y:Number;
		
		public var speedx:Number =0;
		public var speedy:Number =0;
	}
}

for each (var part : Particle in particles)
{
	bmd.setPixel(part.x, part.y, 0xFFFFFF);
}

bmdPerlin.perlinNoise(200, 200, 5, Math.random() * uint.MAX_VALUE, false, true, BitmapDataChannel.RED | BitmapDataChannel.GREEN, false);
var kleur : uint = bmdPerlin.getPixel(part.x, part.y);
var rood : int = kleur >> 16 & 0xFF;
var groen : int = kleur >> 8 & 0xFF;

part.x += (rood - 128)/10;
part.y += (groen - 128)/10 ;

part.speedx += (rood - 128) * 0.002;
part.speedy += (groen - 128) * 0.002;

part.x += part.speedx;
part.y += part.speedy ;

part.speedx *= 0.985;
part.speedy *= 0.985;

private var colorTransform : ColorTransform = new ColorTransform(0.999, 0.95, 0.6, 1, 0, 0, 0, 0);
private var filter : BlurFilter = new BlurFilter(2,2, 1);


bmd.colorTransform(bmd.rect, colorTransform)
bmd.applyFilter(bmd, bmd.rect, bmd.rect.topLeft, filter);

//we maken een array met wat datums erin volgens het UTC format
var arr:Array = ["Tue Feb 23 00:11:49 +0000 2010", "Sat Jan 24 22:14:29 +0000 2009", "Wed Oct 28 19:41:35 +0000 2009", "Sun Feb 21 19:39:10 +0000 2010", "Sun Feb 21 19:39:11 +0000 2010"];
trace(arr);

//we maken een lege array.  Hierin maken we dalijk objecten met de datum in UTC string en in miliseconden.
var arr1:Array = new Array();
//we lopen door de array met datum
for (var a in arr) {
	//hier maken we de objecten met UTC string en de tijd in miliseconden vanaf  January 1, 1970, UTC.
	//uit de livedocs:
	/*
	* parse(date:String):Number
	* [static] Converts a string representing a date into a number equaling the number of milliseconds elapsed since January 1, 1970, UTC.
	*/
	arr1.push( { date:arr[a], time:Date.parse(arr[a]) } );
}
//vervolgens sorteren we de nieuwe array op miliseconden. Het item met de hoogste waarde komt vooraan in de array te staan.
arr1.sortOn("time", Array.NUMERIC);
//we draaien de array om, we willen immers niet het oudste maar het recentste item vooraan hebben.
arr1.reverse();
//en we loopen nog een keer door de array om te kijken of het gelukt is.
for (var a in arr1) {
	//we tracen het veld met de UTC string en concluderen dat het nog werkt ook :D
	trace(arr1[a].date);
}

mijnMovieClip_mc._x = 100;
mijnMovieClip_mc._y = 100;

mijnMovieClip_mc.x = 100;
mijnMovieClip_mc.y = 100;

mijnMovieClip_mc._x = Stage.width/2;
mijnMovieClip_mc._y = Stage.height/2;

// coördinaten 
mijnMovieClip_mc.x = stage.stageWidth/2;
mijnMovieClip_mc.y = stage.stageHeight/2;

// afmetingen
mijnMovieClip_mc.width = stage.stageWidth;
mijnMovieClip_mc.height = stage.stageHeight;

// de functie op de main timeline
function dumber():Void {
	trace("dumber");
}

// aanroepen vanuit ergens in je content
_root.dumber();

// de functie op de main timeline
function dumber():Void {
	trace("dumber");
}

// aanroepen vanuit ergens in je content
MovieClip(root).dumber();

function onButtonRelease():Void {
	trace("er is op de button geklikt");
}

function onButtonRollOver():Void {
	trace("de muis ging over de button heen");
}

mijnButton_btn.onRelease = onButtonRelease;
mijnButton_btn.onRollOver= onButtonRollOver;

function onButtonClick(event:MouseEvent):void {
	trace("er is op de button geklikt");
}

function onMouseOver(event:MouseEvent):void {
	trace("de muis ging over de button heen");
}

mijnButton_btn.addEventListener(MouseEvent.CLICK, onButtonClick);
mijnButton_btn.addEventListener(MouseEvent.MOUSE_OVER, onMouseOver);

getURL("http://www.google.nl","_blank");

var url:URLRequest = new URLRequest("http://www.google.nl");
navigateToURL(url, "_blank");

function onKeyDown():Void {
	var code:Number = Key.getCode();
	var char:String = String.fromCharCode(code);
	trace("Ingedrukte key : code : " + code + "char : " + char);
}

Key.addListener(this);

function onKeyDownHandler(event:KeyboardEvent):void{
	var code:uint = event.keyCode;
	var char:String = String.fromCharCode(code);
	trace("Ingedrukte key : code : " + code + "char : " + char);
}

stage.addEventListener(KeyboardEvent.KEY_UP, onKeyDownHandler);

attachMovie("mijnMovie", "clip", 10);

clip._x = 100;
clip._y = 100;
clip._alpha = 50;

var clip:MovieClip = new mijnMovie();


clip.x = 100;
clip.y = 100;
clip.alpha = .5;

addChild(clip);

Bijgevoegde bestanden

BA843910d01.pdf (599,3 KB, 696x geopend)

Ik heb een handige util class geschreven die ik graag met jullie wil delen. Het is om functies met verschillende intervallen (in ms) in een sequence aan te roepen. De 'Chain' kan gemakkelijk meerdere keren afgespeeld worden, zelfs in omgekeerde volgorde. :D

Bij deze een klein voorbeeldje, hoe je Chain kan gebruiken:
Wat gebeurt hier? Op de eerste regel maken we de classe Chain aan.Op de volgende regel gebeuren meerdere dingen: We roepen een add-function aan. Dit is een belangrijk onderdeel in de class. Hier geef je aan na hoeveel delay er is voor de volgende functie, en welke functie er nu uitgevoerd moet worden. add(one,2000); betekent dus dat functie 1 wordt uitgevoerd en dat er daarna 2 seconden gewacht moet worden voor de volgende functie. Zo gaat hij door met de volgende functies.
Aan het einde zie je de play-functie. Wat aangeeft dat er vanaf dat punt de functies uitgevoerd gaan worden, hoeveel keer het herhaald wordt. Daarna wordt het event COMPLETE dispatched.
Je kunt met deze classe dus je eigen patronen,sequenties en/of ritmes maken.

Ik ben een beetje geïnspireerd door jQuery (wat hier niets mee te maken heeft), om de mogelijkheid te geven om add-functies achter elkaar te plakken.

Dat is wat de classe doet. Een koel ding vind ik dat je het ook in omgekeerde volgorde kunt afspelen:

Natuurlijk kunt je ook tussentijds stoppen/doorgaan met de stop() / doContinue() functies, en je kunt nagaan of hij momenteel afspeelt met de isPlaying-getter

Dit zijn alle functies:
Download: Chain (googlecode)

Ik hoop dat iemand er wat mee kan. Laat maar weten als je nog extra functies verwacht

updates 15-nov-'09
- private functions zijn protected
- add function is nu add(func,delay), dus andersom, en func is verplicht.
- Classe extend EventDispatcher en play/playReversed dispatchen Event.COMPLETE na afspelen van sequence
- code geoptimaliseerd/opgeschoont.