root/as3/PotrAs/samples/potras/algorithm/BestPoligonTest.as

package
{
        import com.nitoyon.potras.*;
        import flash.display.*;
        import flash.geom.*;
        import flash.events.*;

        [SWF(width="320",height="320")]
        public class BestPoligonTest extends Sprite
        {
                [Embed(source='data1.gif')]
                private var Data1:Class;

                private static const SCALE:int = 8;

                public function BestPoligonTest():void
                {
                        var bmp:Bitmap = new Data1();
                        bmp.scaleX = bmp.scaleY = SCALE;
                        var bmd:BitmapData = bmp.bitmapData;
                        addChild(bmp);

                        var i:int = 0;
                        var j:int = 0;

                        var bmdOver:BitmapData = new BitmapData(bmd.width, bmd.height);
                        var bmpOver:Bitmap = new Bitmap(bmdOver);
                        bmdOver.fillRect(new Rectangle(0, 0, bmd.width, bmd.height), 0);
                        bmpOver.scaleX = bmpOver.scaleY = SCALE;
                        addChild(bmpOver);

                        var pathList:Array = PathList.create(bmp.bitmapData);
                        drawPath(bmd, pathList);

                        var lons:Array = [];
                        for(i = 0; i < pathList.length; i++)
                        {
                                var sums:Array = ProcessPath.calcSums(pathList[i].priv as Array) as Array;
                                lons[i] = ProcessPath.calcLon(pathList[i].priv as Array);
                                var po:Array = ProcessPath.bestPolygon(pathList[i].priv as Array, lons[i], sums);

                                for each(var num:int in po)
                                {
                                        bmdOver.setPixel32(pathList[i].priv[num].x, pathList[i].priv[num].y, 0xffff0000);
                                }
                        }

                }

                public static function drawPath(bmd:BitmapData, pathList:Array):void
                {
                        bmd.fillRect(new Rectangle(0, 0, bmd.width, bmd.height), 0xffffffff);
                        for(var i:int = 0; i < pathList.length; i++)
                        {
                                for(var j:int = 0; j < pathList[i].priv.length; j++)
                                {
                                        var pt:Point = pathList[i].priv[j] as Point;
                                        if(pt)
                                        {
                                                bmd.setPixel(pt.x, pt.y, 0x999999);
                                        }
                                }
                        }
                }

                public function drawLon(bmd:BitmapData, pathList:Array, lons:Array, i:int, j:int):void
                {
                        var pt:Point = pathList[i].priv[j] as Point;
                        if(pt)
                        {
                                bmd.lock();
                                bmd.fillRect(new Rectangle(0, 0, bmd.width, bmd.height), 0x00ffffff);
                                bmd.setPixel32(pt.x, pt.y, 0xff000000);

                                var k:int = j;
                                while(true)
                                {
                                        k = (k + 1) % lons[i].length;
                                        if(k == lons[i][j])
                                        {
                                                break;
                                        }

                                        pt = pathList[i].priv[k] as Point;
                                        bmd.setPixel32(pt.x, pt.y, 0xffff0000);

                                }
                                bmd.unlock();
                        }
                }

                private function getIJfromPoint(pathList:Array, point:Point):Array
                {
                        for(var i:int = 0; i < pathList.length; i++)
                        {
                                for(var j:int = 0; j < pathList[i].priv.length; j++)
                                {
                                        if(point.equals(pathList[i].priv[j] as Point))
                                        {
                                                return [i, j]
                                        }
                                }
                        }
                        return null;
                }
        }
}