import flash.utils.getQualifiedClassName;

getQualifiedClassName() returns the name of a class as a String.

Creating a class dynamically:

// SomeClass could be an Object class, too, so can be pretty generic
import some.class.definition.SomeClass;
import flash.utils.getDefinitionByName;

var className:String = “SomeClassName”;
classRef = getDefinitionByName(className) as Class;
imgMC = (new classRef() as SomeClass);

Thanks for posting!

Did you see this post http://www.sakri.net/blog/2009/05/28/detecting-edge-pixels-with-marching-squares-algorithm/

I’ve also got the four pixel version running there, however, it’s not bullet proof, there are a few conditions in which a “straight forward” 4 pixel version fails.

package com.MorganMoonjob.edgeDetection{
import __AS3__.vec.Vector;
import flash.display.BitmapData;
import flash.geom.Point;

public class EdgeScanner{
protected var _scanPts:Vector.=Vector.([
new Point(0,0),
new Point(1,0),
new Point(0,1),
new Point(1,1)
]);
protected var _variations:Object={
“0000″:new Point(1,0),
“0001″:new Point(0,1),
“0010″:new Point(-1,0),
“0011″:new Point(-1,0),
“0100″:new Point(1,0),
“0101″:new Point(0,1),
“0110″:new Point(-1,0),
“0111″:new Point(-1,0),
“1000″:new Point(0,-1),
“1001″:new Point(0,-1),
“1010″:new Point(0,-1),
“1011″:new Point(0,-1),
“1100″:new Point(1,0),
“1101″:new Point(0,1),
“1110″:new Point(0,-1),
“1111″:new Point(1,0)
}
protected var _target:BitmapData;
protected var _grid:String;

public function getCurrentGrid():String{
return _grid+”";
}
protected var _position:Point;
public function get position():Point{
return _position;
}

public function EdgeScanner(target:BitmapData){
reset(target);
}

public function reset(target:BitmapData):void{
_grid=”";
_target=target;
}

public function moveTo(p:Point):void{
_position=p;
updateScanGrid();
}
protected function updateScanGrid():void{
_grid=”";
var p:Point;
for(var i:uint=0;i0×0 ? “1″ : “0″);
}
}

public function getNextEdgePoint():Point{
var p:Point=_variations[_grid];
if(p==null)throw new Error(”BitmapEdgeScanner Error : _grid:”+_grid+” , not found in _variations”);
return new Point(_position.x+p.x,_position.y+p.y);
}
}
}

I think your shape extractor is a lot faster than trying to use the marching square to march over all the empty space and the interiors.

And don’t forget to not double size extract the shapes! That is where the biggest time saving seems to be. I was also looking at BitmapData.lock/unlock in some places, but I couldn’t find anywhere where it seemed to make a really large difference.

Thanks for taking the time to post I had a quick look at Marching Squares on wikipedia, looks great! In retrospect, I’m wondering why I went for 9 squares

Do you have an AS3 implementation of Marching Squares? I’d love to give it a spin myself…

Thanks again

Sakri

Using the double sized extraction and your 9-grid search it took 137 milliseconds.
Using the double sized extraction and a 4-grid search it took 124 milliseconds

Using the single sized extraction and a 4-grid search it took 44 milliseconds

I couldn’t use the 9-grid search with the single sized extraction because my shape throws an error.

But the combination of not having to double the bitmap and having to only test 4 pixel values is a lot faster than your current implementation.

Here is the scan points:

new Point(0,-1),
new Point(-1,-1),
new Point(-1,0),
new Point(0,0)

With a 4-grid there are only 16 possible combinations compared to the 512 for a nine grid. I’m not sure how you are getting away with 40 combinations, but I’m guessing it has to do with the center always being an on pixel and the doubling must rule out some others. Maybe? With 4 grid there are two combinations that don’t occur, all on and all off so the 14 variations are:

“0001″ :new Point(1,0),
“0010″ :new Point(0,1),
“0011″ :new Point(1,0),
“0100″ :new Point(-1,0),
“0101″ :new Point(1,0),
“0110″ :new Point(0,1),
“0111″ :new Point(1,0),
“1000″ :new Point(0,-1),
“1001″ :new Point(0,-1),
“1010″ :new Point(0,1),
“1011″ :new Point(0,-1),
“1100″ :new Point(-1,0),
“1101″ :new Point(-1,0),
“1110″ :new Point(0,1)

There are two ambiguous variations 0101 and 1010. Those whould be where a shape approaches itself at an angle but doesn’t touch. I haven’t tried it yet to see if that can cause an “infinite” loop.

I also found another algorithm that I don’t yet understand that is described in this paper:

http://www.iis.sinica.edu.tw/~fchang/paper/component_labeling_cviu.pdf