BigAssCanvas:大于2880像素的bitmap

AS bitmapdata最大支持2880像素。

http://www.bit-101.com/blog/?p=1199

 

I heard through the grapevine that there are some improvements to the BitmapData class coming up in future versions of Flash, that will allow for larger sized bitmaps to be created. Currently, the largest BitmapData instance you can make is 2880 x 2880. This is fine for most uses, but every once in a while you just need something bigger.

I’ve been doing some generative art lately, and taking a page from the books of Josh Davis, Jared Tarbell, and Erik Natzke, I’ve been thinking of considering looking at maybe possibly getting some prints done. To make a decent quality, decent sized print, I believe you need more pixels than what BitmapData offers. The obvious solution is to use more bitmaps, but that can be a major pain stitching them together and so forth. So, I created a class that takes care of most of that for me.

Introducing the BigAssCanvas class.

Basically, BigAssCanvas mimics BitmapData, except that it is a display object (actually a display object container). You create a BigAssCanvas the same way you would a BitmapData, but you have virtually unlimited size:

[as]var myBigAssCanvas:BigAssCanvas = new BigAssCanvas(10000, 10000, true, 0xff000000);
addChild(myBigAssCanvas);[/as]

Note also that unlike a BitmapData, you add it directly to the display list.

Essentially what it’s doing is: If the width you specify is greater than 2880, it makes multiple columns of bitmaps. If the height is more than 2880, it makes multiple rows. That, in itself, is not such a big deal. The cooler part is that is abstracts several of the more common BitmapData methods so that you can use them without worrying about the fact that the method is actually being applied to several Bitmaps. Here’s what I have so far:

• draw – works exactly like BitmapData.draw, including the matrix, colorTransform, blendMode, clipRect and smoothing. You’ll never know you aren’t just drawing to a BitmapData.
• dispose – removes all bitmaps from display list and disposes of all bitmapdatas.
• fillRect – rect, color.
• getPixel, setPixel, getPixel32, setPixel32 – all just like in BitmapData.
• noise – yup.
• perlinNoise – everything except for stitch, which I don’t know if it can ever be made to work, and offsets, which could be made to work with some effort, I believe. (This one can be pretty slow for a large canvas, by the way.)
• lock, and unlock, minus the changeRect stuff in unlock, which I never knew existed til tonite.

There are definitely more methods that could be added to this, but I think I covered the vast majority of use cases. If you want to dive in and contribute a method, go for it. It’s also totally untested apart from running the method a couple of times and seeing that it looked generally right. It’s completely undocumented, but you are smart kids, you’ll figure it out. Anyway, I made it tonite, it’s almost 2 a.m., I think it’s cool, and I’m blogging it.

Get it, use it, tell me what it breaks, fix it for me:

BigAssCanvas.as

package com.bit101.display { import flash.display.Bitmap; import flash.display.BitmapData; import flash.display.IBitmapDrawable; import flash.display.Sprite; import flash.geom.ColorTransform; import flash.geom.Matrix; import flash.geom.Point; import flash.geom.Rectangle; public class BigAssCanvas extends Sprite { private var _bitmaps:Array; private var _width:Number; private var _height:Number; private var _transparent:Boolean; private var _color:uint; public function BigAssCanvas(w:Number, h:Number, transparent:Boolean = false, color:uint = 0xffffff) { _width = w; _height = h; _transparent = transparent; _color = color; makeBitmaps(); } private function makeBitmaps():void { _bitmaps = new Array(); var h:Number = _height; var ypos:Number = 0; while(h > 0) { var xpos:Number = 0; var w:Number = _width; while(w > 0) { var bmp:Bitmap = new Bitmap(new BitmapData(Math.min(2880, w), Math.min(2880, h), _transparent, _color)); bmp.x = xpos; bmp.y = ypos; addChild(bmp); _bitmaps.push(bmp); w -= bmp.width; xpos += bmp.width; } ypos += Math.min(2880, h); h -= Math.min(2880, h); } } public function draw(source:IBitmapDrawable, matrix:Matrix = null, colorTransform:ColorTransform = null, blendMode:String = null, clipRect:Rectangle = null, smoothing:Boolean = false):void { if(matrix == null) matrix = new Matrix(); for(var i:int = 0; i < _bitmaps.length; i++) { var bmp:Bitmap = _bitmaps[i] as Bitmap; var temp:Matrix = matrix.clone(); temp.tx -= bmp.x; temp.ty -= bmp.y; var tempRect:Rectangle; if(clipRect != null) { tempRect = clipRect.clone(); tempRect.x -= bmp.x; tempRect.y -= bmp.y; } else { tempRect = null; } bmp.bitmapData.draw(source, temp, colorTransform, blendMode, tempRect, smoothing); } } public function dispose():void { while(_bitmaps.length > 0) { var bmp:Bitmap = _bitmaps.shift() as Bitmap; removeChild(bmp); bmp.bitmapData.dispose(); } } public function fillRect(rect:Rectangle, color:uint):void { for(var i:int = 0; i < _bitmaps.length; i++) { var bmp:Bitmap = _bitmaps[i] as Bitmap; var temp:Rectangle = rect.clone(); temp.x -= bmp.x; temp.y -= bmp.y; bmp.bitmapData.fillRect(temp, color); } } public function getPixel(x:Number, y:Number):uint { for(var i:int = 0; i < _bitmaps.length; i++) { var bmp:Bitmap = _bitmaps[i] as Bitmap; if(x >= bmp.x && x < bmp.x + bmp.width && y >= bmp.y && y < bmp.y + bmp.height) { return bmp.bitmapData.getPixel(x - bmp.x, y - bmp.y); } } return 0; } public function setPixel(x:Number, y:Number, color:uint):void { for(var i:int = 0; i < _bitmaps.length; i++) { var bmp:Bitmap = _bitmaps[i] as Bitmap; if(x >= bmp.x && x < bmp.x + bmp.width && y >= bmp.y && y < bmp.y + bmp.height) { bmp.bitmapData.setPixel(Math.round(x - bmp.x), Math.round(y - bmp.y), color); } } } public function getPixel32(x:Number, y:Number):uint { for(var i:int = 0; i < _bitmaps.length; i++) { var bmp:Bitmap = _bitmaps[i] as Bitmap; if(x >= bmp.x && x < bmp.x + bmp.width && y >= bmp.y && y < bmp.y + bmp.height) { return bmp.bitmapData.getPixel32(x - bmp.x, y - bmp.y); } } return 0; } public function setPixel32(x:Number, y:Number, color:uint):void { for(var i:int = 0; i < _bitmaps.length; i++) { var bmp:Bitmap = _bitmaps[i] as Bitmap; if(x >= bmp.x && x < bmp.x + bmp.width && y >= bmp.y && y < bmp.y + bmp.height) { bmp.bitmapData.setPixel32(x - bmp.x, y - bmp.y, color); } } } public function noise(randomSeed:int, low:uint = 0, high:uint = 255, channelOptions:uint = 7, grayScale:Boolean = false):void { for(var i:int = 0; i < _bitmaps.length; i++) { var bmp:Bitmap = _bitmaps[i] as Bitmap; bmp.bitmapData.noise(randomSeed, low, high, channelOptions, grayScale); } } public function perlinNoise(baseX:Number, baseY:Number, numOctaves:uint, randomSeed:int, fractalNoise:Boolean, channelOptions:uint = 7, grayScale:Boolean = false):void { var offsets:Array = new Array(); for(var i:int = 0; i < numOctaves; i++) { offsets.push(new Point()); } for(i = 0; i < _bitmaps.length; i++) { var bmp:Bitmap = _bitmaps[i] as Bitmap; var temp:Array = new Array(); for(var j:int = 0; j < offsets.length; j++) { temp[j] = new Point(offsets[j].x + bmp.x, offsets[j].y + bmp.y); } bmp.bitmapData.perlinNoise(baseX, baseY, numOctaves, randomSeed, false, fractalNoise, channelOptions, grayScale, temp); } } public function lock():void { for(var i:int = 0; i < _bitmaps.length; i++) { var bmp:Bitmap = _bitmaps[i] as Bitmap; bmp.bitmapData.lock(); } } public function unlock():void { for(var i:int = 0; i < _bitmaps.length; i++) { var bmp:Bitmap = _bitmaps[i] as Bitmap; bmp.bitmapData.unlock(); } } } }