In case Flash no longer exists; a copy of this site is included in the Flashpoint archive's "ultimate" collection.

Dead Code Preservation :: Archived AS3 works from wonderfl.net

forked from: CarbonFiber (2)

with gaussian normal distribution
Get Adobe Flash player
by aobyrne 13 Apr 2012
/**
 * Copyright aobyrne ( http://wonderfl.net/user/aobyrne )
 * MIT License ( http://www.opensource.org/licenses/mit-license.php )
 * Downloaded from: http://wonderfl.net/c/xtEt
 */

// forked from bradsedito's CarbonFiber (2)
// forked from aobyrne's WonderflTejido
package 
{
    import com.bit101.components.CheckBox;
    import com.bit101.components.HUISlider;
    import com.bit101.components.VBox;
    import flash.display.Bitmap;
    import flash.display.Sprite;
    import flash.display.StageAlign;
    import flash.display.StageScaleMode;
    import flash.events.Event;
    import flash.events.KeyboardEvent;
    import flash.system.fscommand;
    
    public class WonderflTejido extends Sprite 
    {
        static private const GOLDEN_RATIO:Number = 0.618;
        private var tejidoGrid:TejidoGrid;
        private var elementWidth:Number;
        private var gridWidth:int;
        private var gridHeight:int;
        private var isRandom:Boolean;
        private var isTransforming:Boolean;
        private var hUISliderRatio:HUISlider;
        private var checkBoxTransforming:CheckBox;
        
        public function WonderflTejido():void 
        {
            if (stage) init();
            else addEventListener(Event.ADDED_TO_STAGE, init);
        }
        
        private function init(e:Event = null):void 
        {
            removeEventListener(Event.ADDED_TO_STAGE, init);
            // entry point
            stage.scaleMode = StageScaleMode.NO_SCALE;
            stage.align = StageAlign.TOP_LEFT;
            stage.addEventListener(KeyboardEvent.KEY_DOWN, function (e:KeyboardEvent):void { if ("Q" == String.fromCharCode(e.keyCode)) fscommand("quit"); }, false, 0, true);
            
            graphics.lineStyle(0);
            
            elementWidth = 20;
            isRandom = false;
            isTransforming = true;
            
            
            resetTejidoGrid();
            
            tejidoGrid.draw(graphics,isTransforming);
            
            graphics.lineStyle(10);
            graphics.drawRect(0, 0, gridWidth, gridHeight);
            var vBox:VBox = new VBox(this, 10, 10);
            hUISliderRatio = new HUISlider(null, 0, 0, 'ratio', onRatio);
            hUISliderRatio.maximum = 1;
            hUISliderRatio.value = 1;
            var hUISliderSize:HUISlider = new HUISlider(null, 0, 0, 'size', onSize);
            hUISliderSize.minimum = 10;
            hUISliderSize.maximum = 100;
            hUISliderSize.value =  elementWidth;
            
            var checkBoxRandom:CheckBox = new CheckBox(null, 0, 0, 'isRandom', onRandom);
            checkBoxRandom.selected = isRandom;
            checkBoxTransforming = new CheckBox(null, 0, 0, 'isTransforming', onTransform);
            checkBoxTransforming.selected = isTransforming;
            
            vBox.addChildAt(hUISliderSize, vBox.numChildren);
            vBox.addChildAt(checkBoxRandom, vBox.numChildren);
            vBox.addChildAt(checkBoxTransforming, vBox.numChildren);
            vBox.addChildAt(hUISliderRatio, vBox.numChildren);
            
            hUISliderRatioAbility();
        }
        
        private function onTransform(e:Event):void 
        {
            isTransforming = CheckBox(e.target).selected;
            clearGraphics();
            tejidoGrid.draw(graphics, isTransforming);
            hUISliderRatioAbility();
            hUISliderRatio.enabled = !isTransforming;
        }
        
        private function hUISliderRatioAbility():void 
        {
            
            hUISliderRatio.enabled = !tejidoGrid.isRandomRatio;
            checkBoxTransforming.enabled = !tejidoGrid.isRandomRatio;
            hUISliderRatio.enabled = !isTransforming && !tejidoGrid.isRandomRatio;
        }
        
        private function onRandom(e:Event):void 
        {
            clearGraphics();
            tejidoGrid.isRandomRatio = CheckBox(e.target).selected;
            tejidoGrid.draw(graphics, isTransforming);
            hUISliderRatioAbility();
        }
        
        private function onSize(e:Event):void 
        {
            clearGraphics();
            elementWidth = uint(HUISlider(e.target).value);
            resetTejidoGrid();
        }
        
        private function onRatio(e:Event):void 
        {
            clearGraphics();
            tejidoGrid.ratio = HUISlider(e.target).value;
            tejidoGrid.draw(graphics, isTransforming);
        }
        
        private function resetTejidoGrid():void 
        {
            var elementHeight:Number = GOLDEN_RATIO * elementWidth; 
            var separation:Number = elementHeight * 0.5 + elementWidth * 0.5;
            gridWidth = stage.stageWidth;
            var columns:int = Math.ceil(gridWidth / separation);
            columns = columns % 2 ? columns + 1:columns;
            gridHeight = stage.stageHeight;
            var rows:int = Math.ceil(gridHeight / separation);
            rows++;
            var totalElements:int = columns * rows;
            if (!tejidoGrid) 
            {
                tejidoGrid = new TejidoGrid(columns, totalElements, elementWidth, elementHeight, 0.2,[0x00,0x333333],isRandom);
            }
            else
            {
                tejidoGrid.colsAmount = columns;
                tejidoGrid.totalAmount = totalElements;
                tejidoGrid.eWidth = elementWidth;
                tejidoGrid.eHeight = elementHeight;
                tejidoGrid.draw(graphics,isTransforming)
            }
        }
        
        private function clearGraphics():void 
        {
            graphics.clear();
            graphics.lineStyle(0);
        }
        
    }
    
}
import flash.display.BitmapData;
import flash.display.Graphics;
class TejidoGrid 
{
    private var _colsAmount:uint;
    private var _totalAmount:uint;
    private var _eWidth:Number;
    private var _eHeight:Number;
    private var separation:Number;
    private var _ratio:Number;
    private var colors:Array;
    public var bitmapData:BitmapData;
    private var _isRandomRatio:Boolean;
    
    public function TejidoGrid(colsAmount:uint, totalAmount:uint, width:Number, height:Number, ratio:Number, colors:Array,isRandomRatio:Boolean=false) 
    {
        this.isRandomRatio = isRandomRatio;
        this.colors = colors;
        this.ratio = ratio;
        this.eHeight = height;
        this.eWidth = width;
        this.totalAmount = totalAmount;
        this.colsAmount = colsAmount;
        setSeparation();
        var rowsAmount:uint = totalAmount / colsAmount;
        bitmapData = new BitmapData(colsAmount*separation, rowsAmount*separation);
        bitmapData.perlinNoise(50,50,1,1,false,true,1,true)
    }
    
    public function draw(g:Graphics, isTransforming:Boolean = true):void 
    {
        var orientation:Number;
        var actualRatio:Number;
        var yy:Number;
        var xx:uint;
        var fundamentalElement:FundamentalElement;
        for (var i:int = 0; i < totalAmount; i++) 
        {
            yy = Math.floor(i / colsAmount);
            xx = uint(i % colsAmount);
            actualRatio = isTransforming?GaussianDistribution.getNormalizedValue(2 * xx / colsAmount - 1, 0, 0.25):ratio;
            actualRatio = isRandomRatio?(bitmapData.getPixel(xx*separation, yy*separation) & 0xff) / 255:actualRatio;
            fundamentalElement = new FundamentalElement(separation * xx, separation * yy, eHeight, eWidth, actualRatio);
            orientation = (yy % 2 + i) % 2;
            g.beginFill(colors[orientation]);
            fundamentalElement.draw(g, orientation);
            
        }
        g.beginFill(0, 0);
    }
    
    private function setSeparation():void 
    {
        separation = _eWidth * 0.5 + _eHeight * 0.5;
    }
    
    public function get ratio():Number 
    {
        return _ratio;
    }
    
    public function set ratio(value:Number):void 
    {
        _ratio = value;
    }
    
    public function get colsAmount():uint 
    {
        return _colsAmount;
    }
    
    public function set colsAmount(value:uint):void 
    {
        _colsAmount = value;
    }
    
    public function get totalAmount():uint 
    {
        return _totalAmount;
    }
    
    public function set totalAmount(value:uint):void 
    {
        _totalAmount = value;
    }
    
    public function get eWidth():Number 
    {
        return _eWidth;
    }
    
    public function set eWidth(value:Number):void 
    {
        _eWidth = value;
        setSeparation();
    }
    
    public function get eHeight():Number 
    {
        return _eHeight;
    }
    
    public function set eHeight(value:Number):void 
    {
        _eHeight = value;
        setSeparation();
    }
    
    public function get isRandomRatio():Boolean 
    {
        return _isRandomRatio;
    }
    
    public function set isRandomRatio(value:Boolean):void 
    {
        _isRandomRatio = value;
    }
    
    
}

import flash.display.Graphics;
import flash.geom.Matrix;
import flash.geom.Point;
class FundamentalElement 
{
    private var cx:Number;
    private var cy:Number;
    private var height:Number;
    private var width:Number;
    private var ratio:Number;
    private var AA:Point;
    private var BB:Point;
    private var matrix:Matrix;
    private var array:Array;
    
    public function FundamentalElement(cx:Number, cy:Number, height:Number, width:Number, ratio:Number) 
    {
        this.ratio = ratio;
        this.width = width;
        this.height = height;
        this.cy = cy;
        this.cx = cx;
        AA = new Point;
        BB = new Point;
        matrix = new Matrix;
        matrix.rotate(Math.PI * 0.5);
        
        doSet();
    }
    
    private function doSet():void 
    {
        AA.x = ratio * width * 0.5;
        AA.y = 0.5 * height;
        
        
        BB.x = 0.5 * width;
        array = [AA,BB,new Point(AA.x,-AA.y),new Point(-AA.x,-AA.y),new Point(-BB.x,BB.y),new Point(-AA.x,AA.y)];
    }
    
    public function draw(g:Graphics,isRotated:uint=0):void 
    {
        if (isRotated) 
        {
            for (var i:int = 0; i < array.length; i++) 
            {
                array[i] = matrix.transformPoint(array[i]);
            }
        }
        g.moveTo(cx + array[array.length-1].x, cy + array[array.length-1].y);
        for (var j:int = 0; j < array.length; j++) 
        {
            g.lineTo(cx+array[j].x, cy+array[j].y);
        }
    }
    
    
}
class GaussianDistribution 
{
    private var mu:Number;
    private var _sigma:Number;
    private var factor:Number;
    
    public function GaussianDistribution(mu:Number, sigma:Number) 
    {
        this.sigma = sigma;
        this.mu = mu;
        
        
    }
    
    public function getData():Array 
    {
        var gaussian:Number;
        var pow:Number;
        var xx:Number;
        var normal:Number;
        var steps:int = 100;
        var delta:Number = 1 / steps;
        var data:Array = [];
        var initxx:Number = -5;
        var finalxx:Number = 5;
        var size:Number = 10;
        size = finalxx > initxx?finalxx - initxx:initxx - finalxx;
        for (var i:int = 0; i < steps; i++) 
        {
            normal = i * delta;
            xx = size * (normal - 0.5);
            pow = -(xx - mu) * (xx - mu)/(2*sigma*sigma);
            gaussian = factor * Math.pow(Math.E, pow);
            data[i] = gaussian;
        }
        return data;
    
    }
    
    public static function getNormalizedValue(xx:Number, mu:Number, sigma:Number):Number
    {
        return getValue(xx, mu, sigma) / getValue(mu, mu, sigma);
    }
    public static function getValue(xx:Number, mu:Number, sigma:Number):Number
    {
        var gaussian:Number;
        var pow:Number;
        var s:Number = 1 / sigma;
        var factor:Number  = s / Math.sqrt(2 * Math.PI);
        pow = -(xx - mu) * (xx - mu)*s*s*0.5;            
        gaussian = factor * Math.pow(Math.E, pow);
        return gaussian
    }
    
    public function get sigma():Number 
    {
        return _sigma;
    }
    
    public function set sigma(value:Number):void 
    {
        _sigma = value;
        factor = 1 /( sigma * Math.sqrt(2 * Math.PI));
    }
    
}