Flash / Flex / ActionScript/Graphics/BitmapData

Adding Noise

   <source lang="java">

package {

   import flash.display.BitmapData;
   import flash.display.Bitmap;
   import flash.display.Sprite;
   import flash.utils.Timer;
   import flash.events.TimerEvent;
   public class Main extends Sprite {
       private var _bitmapData:BitmapData = new BitmapData(400, 400);
       public function Main () {
           var bitmap:Bitmap = new Bitmap(_bitmapData);
           addChild(bitmap);
           var timer:Timer = new Timer(50);
           timer.addEventListener(TimerEvent.TIMER, timerHandler);
           timer.start();
       }
       private function timerHandler(event:TimerEvent):void {
           _bitmapData.noise(Math.random() * 1000000);
       }
   }

}

       </source>
   
  

Adding Perlin Noise

   <source lang="java">

package {

   import flash.display.BitmapData;
   import flash.display.Bitmap;
   import flash.display.Sprite;
   import flash.utils.Timer;
   import flash.events.TimerEvent;
   public class Main extends Sprite {
       private var _bitmapData:BitmapData = new BitmapData(400, 400);
       public function Main () {
           var bitmap:Bitmap = new Bitmap(_bitmapData);
           addChild(bitmap);
           var timer:Timer = new Timer(50);
           timer.addEventListener(TimerEvent.TIMER, timerHandler);
           timer.start();
       }
       private function timerHandler(event:TimerEvent):void {
           _bitmapData.perlinNoise(mouseX, mouseY, 1, 1, false, false);
       }
   }

}

       </source>
   
  

Applying Color Transformations

   <source lang="java">

package {

   import flash.net.URLRequest;
   import flash.display.BitmapData;
   import flash.display.Bitmap;
   import flash.display.Sprite;
   import flash.display.Loader;
   import flash.geom.Rectangle;
   import flash.events.Event;
   import flash.geom.ColorTransform;
   public class Main extends Sprite {
       private var _loader:Loader = new Loader();
       public function Main () {
           _loader.load(new URLRequest("http://www.wbex.ru/samplefiles/image2.jpg"));
           _loader.contentLoaderInfo.addEventListener(Event.ruPLETE,completeHandler);
       }
       private function completeHandler(event:Event):void {
           var w:Number = _loader.width;
           var h:Number = _loader.height;
           var bitmapData:BitmapData = new BitmapData(w, h);
           bitmapData.draw(_loader);
           bitmapData.colorTransform(new Rectangle(0, 0, w/2, h/2), new ColorTransform(1, 0, 0, 1, 0, 0, 0, 0));
           bitmapData.colorTransform(new Rectangle(w/2, 0, w/2, h/2), new ColorTransform(0, 1, 0, 1, 0, 0, 0, 0));
           bitmapData.colorTransform(new Rectangle(0, h/2, w/2, h/2), new ColorTransform(0, 0, 1, 1, 0, 0, 0, 0));
           bitmapData.colorTransform(new Rectangle(w/2, h/2, w/2, h/2), new ColorTransform(1, 1, 0, 1, 0, 0, 0, 0));
           var bitmap:Bitmap = new Bitmap(bitmapData);
           addChild(bitmap);
       }
   }

}

       </source>
   
  

Assign a pixel value using a number that specifies an Alpha channel of CC

   <source lang="java">

package{

 import flash.display.*;
 
 public class Main extends Sprite{
   public function Main(){
       var imgData:BitmapData = new BitmapData(20, 20, true, 0x660000FF);
       imgData.setPixel(0, 0, 0xFFFFFF);
       imgData.setPixel(0, 0, 0xCCFFFFFF);
   }
 }

}

       </source>
   
  

Assigning the Color of a Region of Pixels

   <source lang="java">

  

package{

 import flash.display.*;
 import flash.utils.*;
 import flash.geom.*;
 public class Main extends Sprite{
   public function Main(){
       var imgData:BitmapData = new BitmapData(4, 4, false, 0xFFFF0000);
       
       var byteArray:ByteArray = new ByteArray(  );
       byteArray.writeUnsignedInt(0xFF00FF00);
       
       byteArray.position = 0;
       
       imgData.setPixels(new Rectangle(1,0,3,2), byteArray);
   }
 }

}

       </source>
   
  

Create animation by setting the bitmap pixel

   <source lang="java">

package {

   import flash.display.Sprite;
   import flash.display.Bitmap;
   import flash.display.BitmapData;
   import flash.filters.BlurFilter;
   import flash.events.Event;
   public class Main extends Sprite {
       private var _bitmap:BitmapData = new BitmapData(stage.stageWidth, stage.stageHeight,
                                 false, 0xff000000);
       private var _image:Bitmap = new Bitmap(_bitmap);
       
       public function Main(  ) {
           addChild(_image);
           _image.filters = [new BlurFilter(  )];
           addEventListener(Event.ENTER_FRAME, onEnterFrame);
       }
       public function onEnterFrame(event:Event):void {
           for(var i:int = 0; i < 100; i++) {
               _bitmap.setPixel(mouseX + Math.random(  ) * 20 - 10,
                             mouseY + Math.random(  ) * 20 - 10,
                             0xffffffff);
           }
       }
   }

}

       </source>
   
  

Creating a BitmapData Object

   <source lang="java">

package{

 import flash.display.*;
 
 public class Main extends Sprite{
   public function Main(){
       var bmpRectangle:BitmapData = new BitmapData(500, 200);
   }
 }

}

       </source>
   
  

Creating a Flood Fill

   <source lang="java">

package {

   import flash.display.Sprite;
   import flash.display.Bitmap;
   import flash.display.BitmapData;
   import flash.events.MouseEvent;
   import flash.geom.Rectangle;
   public class Main extends Sprite {
       private var _bitmap:BitmapData= new BitmapData(stage.stageWidth,stage.stageHeight,false, 0xffffffff);
   
       public function Main (  ) {
           var sprite:Sprite = new Sprite(  );
           addChild(sprite);
           for(var i:int = 0; i < 200; i++) {
               _bitmap.fillRect(new Rectangle(
                            Math.random(  ) * stage.stageWidth,
                            Math.random(  ) * stage.stageHeight,
                            20, 20), Math.random(  ) * 0xffffffff);
           }
           var image:Bitmap = new Bitmap(_bitmap);
           sprite.addChild(image);
           sprite.addEventListener(MouseEvent.MOUSE_DOWN, onMouseDown);
       }
       public function onMouseDown(event:MouseEvent):void {
           _bitmap.floodFill(mouseX, mouseY, 0xffff0000);
       }
   }

}

       </source>
   
  

Creating a New Bitmap Image from ImageData

   <source lang="java">

package{

 import flash.display.Sprite;
 import flash.display.*;
 import flash.geom.*;
 public class Main extends Sprite{
   public function Main(){
       
       var imgData:BitmapData = new BitmapData(20, 20, false, 0xFF00FF00);
       imgData.fillRect(new Rectangle(5, 5, 10, 10), 0xFF0000FF);
       
       var bmp:Bitmap = new Bitmap(imgData);
       
       bmp.bitmapData = imgData;
       
       addChild(bmp);
   }
 }

}

       </source>
   
  

Detecting Areas by Color

   <source lang="java">

package {

   import flash.display.Bitmap;
   import flash.display.BitmapData;
   import flash.display.Shape;
   import flash.display.Sprite;
   import flash.display.Loader;
   import flash.net.URLRequest;
   import flash.events.MouseEvent;
   import flash.events.Event;
   import flash.geom.Point;
   import flash.geom.Rectangle;
   public class Main extends Sprite {
       private var _bitmapData:BitmapData;
       private var _loader:Loader = new Loader();
       private var _outline:Shape;
       public function Main () {
           _loader.load(new URLRequest("http://www.wbex.ru/samplefiles/image2.jpg"));
           _loader.contentLoaderInfo.addEventListener(Event.ruPLETE, completeHandler);
           addEventListener(MouseEvent.CLICK, clickHandler);
       }
       private function completeHandler(event:Event):void {
           var w:Number = _loader.width;
           var h:Number = _loader.height;
           _bitmapData = new BitmapData(w, h);
           _bitmapData.draw(_loader);
           var bitmap:Bitmap = new Bitmap(_bitmapData);
           var container:Sprite = new Sprite();
           addChild(container);
           container.addChild(bitmap);
           _outline = new Shape();
           addChild(_outline);
       }
       private function clickHandler(event:MouseEvent):void {
           var color:uint = _bitmapData.getPixel32(mouseX, mouseY);
           var rectangle:Rectangle =  _bitmapData.getColorBoundsRect(0xFFFFFFFF, color);
           _outline.graphics.clear();
           _outline.graphics.lineStyle(0, 0x000000, 1);
           _outline.graphics.drawRect(rectangle.x, rectangle.y, rectangle.width, rectangle.height);
       }
   }

}

       </source>
   
  

Displaying BitmapData Images

   <source lang="java">

package{

 import flash.display.*;
 
 public class Main extends Sprite{
   public function Main(){
       var squareData:BitmapData = new BitmapData(200, 200, false, 0xFFCC00CC);
       var square:Bitmap = new Bitmap(squareData);
       addChild(square);
   }
 }

}

       </source>
   
  

Dissolve

   <source lang="java">

package {

   import flash.display.Sprite;
   import flash.display.Bitmap;
   import flash.display.BitmapData;
   import flash.events.Event;
   import flash.geom.Point;
   public class Main extends Sprite {
       private var _bitmap:BitmapData= new BitmapData(stage.stageWidth,stage.stageHeight,false,0xffffffff);
       private var _image:Bitmap = new Bitmap(_bitmap);
       private var _seed:Number = 10000;
       private var _pixelCount:int = 0;
   
       public function Main(  ) {
           addChild(_image);
           addEventListener(Event.ENTER_FRAME, onEnterFrame);
       }
   
       public function onEnterFrame(event:Event):void {
           _seed = _bitmap.pixelDissolve(_bitmap,
                                      _bitmap.rect,
                                      new Point(  ),
                                      _seed, 
                                      1000,
                                      0xff000000);
           _pixelCount += 1000;
           if(_pixelCount > _bitmap.width * _bitmap.height)
           {
               removeEventListener(Event.ENTER_FRAME, onEnterFrame);
           }
       }
   }

}

       </source>
   
  

File BitmapData with Rectangle

   <source lang="java">

package{

 import flash.display.Sprite;
 import flash.display.*;
   import flash.geom.*;
 public class Main extends Sprite{
   public function Main(){
       var imgData:BitmapData = new BitmapData(20, 20, false, 0xFF00FF00);
       imgData.fillRect(new Rectangle(5, 5, 10, 10), 0xFF0000FF);
       var bmp:Bitmap = new Bitmap(imgData);
       addChild(bmp);
   }
 }

}

       </source>
   
  

getPixel32() Versus getPixel( )

   <source lang="java">

package{

 import flash.display.*;
 
 public class Main extends Sprite{
   public function Main(){
       var imgData:BitmapData = new BitmapData(20, 20, false, 0xFF0000FF);
       trace(imgData.getPixel(0, 0));  // Displays: 255
   }
 }

}

       </source>
   
  

Get pixel data from BitmapData

   <source lang="java">

package{

 import flash.display.*;
 public class Main extends Sprite{
   public function Main(){
       var imgData:BitmapData = new BitmapData(20, 20, false, 0x330000FF);
       trace(imgData.getPixel32(0, 0));  // Displays: 4278190335
                                 // (Alpha is 0xFF, not 0x33)

   }
 }

}

       </source>
   
  

How draw( ) handles Alpha channel values

   <source lang="java">

package{

 import flash.display.*;
   import flash.utils.*;
 import flash.events.*;
 import flash.geom.*;
 import flash.text.*;
 public class Main extends Sprite{
   public function Main(){

       var redSquare:BitmapData = new BitmapData(20, 20, true, 0xFFFF0000);
       var blueSquare:BitmapData = new BitmapData(20, 20, true, 0xFF0000FF);
       
       var sourceRect:Rectangle = new Rectangle(5, 5, 10, 5);
       
       var destPoint:Point = new Point(0,0);
       
       redSquare.copyPixels(blueSquare, sourceRect, destPoint);
       
       var b:Bitmap = new Bitmap(redSquare);
       addChild(b);
   }
 }

}

       </source>
   
  

Modifying a BitmapData

   <source lang="java">

package{

 import flash.display.*;
 
 public class Main extends Sprite{
   public function Main(){
       var imgData:BitmapData = new BitmapData(20, 20, false, 0xFF0000FF);
       imgData.setPixel32(0, 0, 0xFFFFFFFF);
   }
 }

}

       </source>
   
  

PerlinNoise animation

   <source lang="java">

package {

   import flash.display.BitmapData;
   import flash.display.Bitmap;
   import flash.display.Shape;
   import flash.display.Sprite;
   import flash.utils.Timer;
   import flash.events.TimerEvent;
   import flash.geom.Point;
   public class Main extends Sprite {
       private var _bitmapData:BitmapData = new BitmapData(200, 200);
       private var _offset:Number = 0;
       public function RuntimeBitmap() {
           var bitmap:Bitmap = new Bitmap(_bitmapData);
           addChild(bitmap);
           var timer:Timer = new Timer(1000);
           timer.addEventListener(TimerEvent.TIMER, timerHandler);
           timer.start();
       }
       private function timerHandler(event:TimerEvent):void {
           _bitmapData.perlinNoise(100, 100, 1, 1, false, false, 1, false, [new Point(_offset++, 0)]);
       }
   }

}

       </source>
   
  

Retrieve a pixel with Alpha set to 255, from a transparent image

   <source lang="java">

package{

 import flash.display.*;
 
 public class Main extends Sprite{
   public function Main(){
       var imgData:BitmapData = new BitmapData(20, 20, true, 0xFFFFFFFF);
       trace(imgData.getPixel32(0, 0));  // Displays: 4294967295
                                 // (original data was preserved)
   }
 }

}

       </source>
   
  

Retrieving the Color of a Region of Pixels

   <source lang="java">

package{

 import flash.display.*;
 import flash.geom.*;
 import flash.utils.ByteArray;
 public class Main extends Sprite{
   public function Main(){
       var blueSquare:BitmapData = new BitmapData(20, 20, false, 0xFF0000FF);
       var greenSquare:BitmapData = new BitmapData(30, 30, false, 0xFF00FF00);
       
       var rectRegion:Rectangle = new Rectangle(5, 5, 10, 10);
       
       var greenPixels:ByteArray = greenSquare.getPixels(rectRegion);
       
       greenPixels.position = 0;
       
       blueSquare.setPixels(rectRegion, greenPixels);
       
       var blueBmp:Bitmap = new Bitmap(blueSquare);
       var greenBmp:Bitmap = new Bitmap(greenSquare);
       addChild(blueBmp);
       addChild(greenBmp);
       greenBmp.x = 40;
   }
 }

}

       </source>
   
  

The alpha value of pixels can be set in transparent bitmaps only (i.e., bitmaps created with the value true passed to the transparent parameter of the BitmapData constructor)

   <source lang="java">

package{

 import flash.display.*;
 
 public class Main extends Sprite{
   public function Main(){
       var imgData:BitmapData = new BitmapData(20, 20, true, 0x330000FF);
       trace(imgData.getPixel32(0, 0));  // Displays: 855638271
                                 // (Alpha is 0x33)
   }
 }

}

       </source>
   
  

The following code makes a BitmapData object with Perlin noise, and then uses that object as a bitmap fill. Because the stitch parameter is false, the edges are visible as it tiles.

   <source lang="java">

package {

   import flash.display.BitmapData;
   import flash.display.Shape;
   import flash.display.Sprite;
   import flash.utils.Timer;
   import flash.events.TimerEvent;
   public class Main extends Sprite {
       private var _bitmapData:BitmapData = new BitmapData(200, 200);
       public function Main() {
           var shape:Shape = new Shape();
           shape.graphics.lineStyle(0, 0, 0);
           shape.graphics.beginBitmapFill(_bitmapData);
           shape.graphics.drawRect(0, 0, 600, 400);
           shape.graphics.endFill();
           addChild(shape);
           var timer:Timer = new Timer(1000);
           timer.addEventListener(TimerEvent.TIMER, timerHandler);
           timer.start();
       }
       private function timerHandler(event:TimerEvent):void {
           _bitmapData.perlinNoise(100, 100, 1, Math.random() * 100000, false, false);
       }
   }

}

       </source>
   
  

The randomSeed parameter is responsible for the randomness of the noise

   <source lang="java">

package {

   import flash.display.BitmapData;
   import flash.display.Bitmap;
   import flash.display.Sprite;
   import flash.utils.Timer;
   import flash.events.TimerEvent;
   public class Main extends Sprite {
       private var _bitmapData:BitmapData = new BitmapData(400, 400);
       public function Main () {
           var bitmap:Bitmap = new Bitmap(_bitmapData);
           addChild(bitmap);
           var timer:Timer = new Timer(50);
           timer.addEventListener(TimerEvent.TIMER, timerHandler);
           timer.start();
       }
       private function timerHandler(event:TimerEvent):void {
           _bitmapData.perlinNoise(100, 100, 1, Math.random() * 1000, false, false);
       }
   }

}

       </source>
   
  

Updates the octaves parameter

   <source lang="java">

package {

   import flash.display.BitmapData;
   import flash.display.Bitmap;
   import flash.display.Sprite;
   import flash.utils.Timer;
   import flash.events.TimerEvent;
   public class Main extends Sprite {
       private var _bitmapData:BitmapData = new BitmapData(400, 400);
       public function Main () {
           var bitmap:Bitmap = new Bitmap(_bitmapData);
           addChild(bitmap);
           var timer:Timer = new Timer(50);
           timer.addEventListener(TimerEvent.TIMER, timerHandler);
           timer.start();
       }
       private function timerHandler(event:TimerEvent):void {
           _bitmapData.perlinNoise(100, 100, mouseX * 10 / 400, 1, false, false);
       }
   }

}

       </source>
   
  

Using BitmapData.lock( ) to improve performance

   <source lang="java">

package{

 import flash.display.*;
 
 public class Main extends Sprite{
   public function Main(){
       var imgData:BitmapData = new BitmapData(500, 500, true, 0x00000000);
       var bmp:Bitmap = new Bitmap(imgData);
       
       imgData.lock(  );
       
       var color:uint;
       for (var i:int = 0; i < imgData.height ; i++) {
         for (var j:int = 0; j < imgData.width; j++) {
           color =  Math.floor(Math.random(  )*0xFFFFFFFF);
           imgData.setPixel32(j, i, color);
         }
       }
       
       imgData.unlock(  );
   }
 }

}

       </source>