в 09:19, 26 мая 2010

2010-05-26T09:19:13Z

Admin: 1 версия

2010-05-26T08:15:06Z

1 версия

Новая страница

==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>

← Предыдущая	Версия 09:19, 26 мая 2010
(нет различий)

Flash / Flex / ActionScript/Graphics/BitmapData - История изменений

в 09:19, 26 мая 2010

Admin: 1 версия