package {
    import flash.display.DisplayObject;
    import flash.display.Bitmap;
    import flash.display.BitmapData;

    import flash.utils.getTimer;

    public class EdgeExtractor {
        private var _inputImage:BitmapData;
        private var _transformBuffer:BitmapData;
        private var _countBuffer:BitmapData;
        private var _result:Bitmap;

        private var _frameMS:int;
        private var _totalScans:int;
        private var _tolerance:int;

        private var _currentScan:int;
        private var _imgWidth:int;
        private var _imgHeight:int;

        private var _notify:Function;
        private var _running:Boolean;

        public function EdgeExtractor(){

        }

        public function Init(framerate:int, quality:Number, threshold:Number){
            _frameMS = 1000 / framerate;
            _totalScans = Math.round(quality * 255.0);
            _tolerance = Math.round(threshold * _totalScans);

            _result = null;
        }

        public function RunExtract(dobj:DisplayObject, notify:Function){
            _currentScan = 0;
            _notify = notify;

            _imgWidth = Math.round(dobj.width);
            _imgHeight = Math.round(dobj.height);

            _inputImage = new BitmapData(_imgWidth, _imgHeight, false, 0);
            _transformBuffer = new BitmapData(_imgWidth, _imgHeight, false, 0);
            _countBuffer = new BitmapData(_imgWidth, _imgHeight, false, 0);

            _inputImage.draw(dobj);

            _running = true;
        }

        public function GetResult():DisplayObject{
            return _result;
        }

        public function Update(){
            var endTime:int;

            if(_running){
                endTime = getTimer() + _frameMS;

                while(getTimer() < endTime){
                    Scan();

                    if(_currentScan >= _totalScans){
                        Finish();

                        _running = false;
                        _notify(true, 1.0);

                        break;
                    } else {
                        _notify(false, _currentScan / _totalScans);
                    }
                }
            }
        }

        private function Scan(){
            _transformBuffer.draw(_inputImage);

            var px:int;
            var py:int;

            var w:int = _inputImage.width;
            var h:int = _inputImage.height;

            var scanWidth:int = Math.floor(255.0 * (_currentScan / _totalScans));

            var r:int;
            var g:int;
            var b:int;
            var color:uint;

            var diff:Boolean;

            for(py = 0; py < h; py++){
                for(px = 0; px < w; px++){
                    color = _transformBuffer.getPixel(px, py);
                    r = (color >> 16) & 0xFF;
                    g = (color >> 8) & 0xFF;
                    b = color & 0xFF;

                    r = Math.floor(r / scanWidth) * scanWidth;
                    g = Math.floor(g / scanWidth) * scanWidth;
                    b = Math.floor(b / scanWidth) * scanWidth;

                    color = (r << 16) + (g << 8) + b;
                    _transformBuffer.setPixel(px, py, color);
                }
            }

            for(py = 1; py < h; py++){
                for(px = 1; px < w; px++){
                    color = _transformBuffer.getPixel(px, py);

                    if((color != _transformBuffer.getPixel(px-1, py)) || (color != _transformBuffer.getPixel(px, py-1))){
                        _countBuffer.setPixel(px, py, _countBuffer.getPixel(px, py) + 1);
                    }
                }
            }

            _currentScan++;
        }

        private function Finish(){
            var outBuffer:BitmapData = new BitmapData(_inputImage.width, _inputImage.height, false, 0xFFFFFF);

            var px:int;
            var py:int;

            var w:int = _inputImage.width;
            var h:int = _inputImage.height;

            for(py = 0; py < h; py++){
                for(px = 0; px < w; px++){
                    if(_countBuffer.getPixel(px, py) >= _tolerance){
                        outBuffer.setPixel(px, py, 0);
                    }
                }
            }

            _result = new Bitmap(outBuffer);
        }
    }
}