/**

public int format;

public int[] pixels;

public int width, height;

/**

public PApplet parent;

protected Bitmap bitmap;

// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/** for renderers that need to store info about the image */

protected HashMap<PGraphics, Object> cacheMap;

/** for renderers that need to store parameters about the image */

protected HashMap<PGraphics, Object> paramMap;

/** modified portion of the image */

protected boolean modified;

protected int mx1, my1, mx2, my2;

// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

// private fields

private int fracU, ifU, fracV, ifV, u1, u2, v1, v2, sX, sY, iw, iw1, ih1;

private int ul, ll, ur, lr, cUL, cLL, cUR, cLR;

private int srcXOffset, srcYOffset;

private int r, g, b, a;

private int[] srcBuffer;

// fixed point precision is limited to 15 bits!!

static final int PRECISIONB = 15;

static final int PRECISIONF = 1 << PRECISIONB;

static final int PREC_MAXVAL = PRECISIONF-1;

static final int PREC_ALPHA_SHIFT = 24-PRECISIONB;

static final int PREC_RED_SHIFT = 16-PRECISIONB;

// internal kernel stuff for the gaussian blur filter

private int blurRadius;

private int blurKernelSize;

private int[] blurKernel;

private int[][] blurMult;

// colour component bitmasks (moved from PConstants in 2.0b7)

public static final int ALPHA_MASK = 0xff000000;

public static final int RED_MASK = 0x00ff0000;

public static final int GREEN_MASK = 0x0000ff00;

public static final int BLUE_MASK = 0x000000ff;

//////////////////////////////////////////////////////////////

/**

public PImage() {

format = ARGB; // default to ARGB images for release 0116

}

/**

public PImage(int width, int height) {

init(width, height, RGB);

}

public PImage(int width, int height, int format) {

init(width, height, format);

}

/**

public void init(int width, int height, int format) { // ignore

this.width = width;

this.height = height;

this.pixels = new int[width*height];

this.format = format;

}

/**

protected void checkAlpha() {

if (pixels == null) return;

for (int i = 0; i < pixels.length; i++) {

// since transparency is often at corners, hopefully this

// will find a non-transparent pixel quickly and exit

if ((pixels[i] & 0xff000000) != 0xff000000) {

format = ARGB;

break;

}

}

}

//////////////////////////////////////////////////////////////

/**

public PImage(Object nativeObject) {

Bitmap bitmap = (Bitmap) nativeObject;

this.bitmap = bitmap;

this.width = bitmap.getWidth();

this.height = bitmap.getHeight();

this.pixels = null;

this.format = bitmap.hasAlpha() ? ARGB : RGB;

}

/**

public Object getNative() {

return bitmap;

}

//////////////////////////////////////////////////////////////

// MARKING IMAGE AS MODIFIED / FOR USE w/ GET/SET

public boolean isModified() { // ignore

return modified;

}

public void setModified() { // ignore

modified = true;

}

public void setModified(boolean m) { // ignore

modified = m;

}

public int getModifiedX1() { // ignore

return mx1;

}

public int getModifiedX2() { // ignore

return mx2;

}

public int getModifiedY1() { // ignore

return my1;

}

public int getModifiedY2() { // ignore

return my2;

}

/**

public void loadPixels() { // ignore

if (pixels == null || pixels.length != width*height) {

pixels = new int[width*height];

}

if (bitmap != null) {

bitmap.getPixels(pixels, 0, width, 0, 0, width, height);

}

if (parent == null) return;

Object cache = parent.g.initCache(this);

if (cache != null) {

Method loadPixelsMethod = null;

try {

loadPixelsMethod = cache.getClass().getMethod("loadPixels", new Class[] { int[].class });

} catch (Exception e) {

}

if (loadPixelsMethod != null) {

try {

loadPixelsMethod.invoke(cache, new Object[] { pixels });

} catch (Exception e) {

e.printStackTrace();

}

}

}

}

/**

public void updatePixels() { // ignore

updatePixelsImpl(0, 0, width, height);

}

/**

public void updatePixels(int x, int y, int w, int h) { // ignore

updatePixelsImpl(x, y, w, h);

}

protected void updatePixelsImpl(int x, int y, int w, int h) {

int x2 = x + w;

int y2 = y + h;

if (!modified) {

mx1 = PApplet.max(0, x);

mx2 = PApplet.min(width - 1, x2);

my1 = PApplet.max(0, y);

my2 = PApplet.min(height - 1, y2);

modified = true;

} else {

if (x < mx1) mx1 = PApplet.max(0, x);

if (x > mx2) mx2 = PApplet.min(width - 1, x);

if (y < my1) my1 = PApplet.max(0, y);

if (y > my2) my2 = y;

if (x2 < mx1) mx1 = PApplet.max(0, x2);

if (x2 > mx2) mx2 = PApplet.min(width - 1, x2);

if (y2 < my1) my1 = PApplet.max(0, y2);

if (y2 > my2) my2 = PApplet.min(height - 1, y2);

}

}

//////////////////////////////////////////////////////////////

// COPYING IMAGE DATA

/**

@Override

public Object clone() throws CloneNotSupportedException { // ignore

return get();

}

/**

public void resize(int w, int h) { // ignore

if (w <= 0 && h <= 0) {

throw new IllegalArgumentException("width or height must be > 0 for resize");

}

if (w == 0) { // Use height to determine relative size

float diff = (float) h / (float) height;

w = (int) (width * diff);

} else if (h == 0) { // Use the width to determine relative size

float diff = (float) w / (float) width;

h = (int) (height * diff);

}

bitmap = Bitmap.createScaledBitmap(bitmap, w, h, true);

this.width = w;

this.height = h;

// Mark the pixels array as altered

updatePixels();

}

//////////////////////////////////////////////////////////////

// GET/SET PIXELS

/**

public int get(int x, int y) {

if ((x < 0) || (y < 0) || (x >= width) || (y >= height)) return 0;

if (pixels == null) {

return bitmap.getPixel(x, y);

} else {

// If the pixels array exists, it's fairly safe to assume that it's

// the most up to date, and that it's faster for access.

switch (format) {

case RGB:

return pixels[y*width + x] | 0xff000000;

case ARGB:

return pixels[y*width + x];

case ALPHA:

return (pixels[y*width + x] << 24) | 0xffffff;

}

}

return 0;

}

/**

/**

public PImage get(int x, int y, int w, int h) {

int targetX = 0;

int targetY = 0;

int targetWidth = w;

int targetHeight = h;

boolean cropped = false;

if (x < 0) {

w += x; // x is negative, removes the left edge from the width

targetX = -x;

cropped = true;

x = 0;

}

if (y < 0) {

h += y; // y is negative, clip the number of rows

targetY = -y;

cropped = true;

y = 0;

}

if (x + w > width) {

w = width - x;

cropped = true;

}

if (y + h > height) {

h = height - y;

cropped = true;

}

if (w < 0) {

w = 0;

}

if (h < 0) {

h = 0;

}

int targetFormat = format;

if (cropped && format == RGB) {

targetFormat = ARGB;

}

PImage target = new PImage(targetWidth, targetHeight, targetFormat);

target.parent = parent; // parent may be null so can't use createImage()

if (w > 0 && h > 0) {

getImpl(x, y, w, h, target, targetX, targetY);

}

return target;

}

/**

protected void getImpl(int sourceX, int sourceY,

int sourceWidth, int sourceHeight,

PImage target, int targetX, int targetY) {

if (pixels == null) {

bitmap.getPixels(target.pixels,

targetY*target.width + targetX, target.width,

sourceX, sourceY, sourceWidth, sourceHeight);

} else {

int sourceIndex = sourceY*width + sourceX;

int targetIndex = targetY*target.width + targetX;

for (int row = 0; row < sourceHeight; row++) {

System.arraycopy(pixels, sourceIndex, target.pixels, targetIndex, sourceWidth);

sourceIndex += width;

targetIndex += target.width;

}

}

}

/**

public PImage get() {

// Formerly this used clone(), which caused memory problems.

// http://code.google.com/p/processing/issues/detail?id=42

return get(0, 0, width, height);

}

/**

public void set(int x, int y, int c) {

if (pixels == null) {

bitmap.setPixel(x, y, c);

} else {

if ((x < 0) || (y < 0) || (x >= width) || (y >= height)) return;

pixels[y*width + x] = c;

updatePixelsImpl(x, y, 1, 1); // slow?

}

}

/**

public void set(int x, int y, PImage img) {

if (img.format == ALPHA) {

// set() doesn't really make sense for an ALPHA image, since it

// directly replaces pixels and does no blending.

throw new IllegalArgumentException("set() not available for ALPHA images");

}

int sx = 0;

int sy = 0;

int sw = img.width;

int sh = img.height;

if (x < 0) { // off left edge

sx -= x;

sw += x;

x = 0;

}

if (y < 0) { // off top edge

sy -= y;

sh += y;

y = 0;

}

if (x + sw > width) { // off right edge

sw = width - x;

}

if (y + sh > height) { // off bottom edge

sh = height - y;

}

// this could be nonexistent

if ((sw <= 0) || (sh <= 0)) return;

setImpl(img, sx, sy, sw, sh, x, y);

}

/**

protected void setImpl(PImage sourceImage,

int sourceX, int sourceY,

int sourceWidth, int sourceHeight,

int targetX, int targetY) {

if (sourceImage.pixels == null) {

sourceImage.loadPixels();

}

// if this.pixels[] is null, copying directly into this.bitmap

if (pixels == null) {

// if this.pixels[] is null, this.bitmap cannot be null

// make sure the bitmap is writable

if (!bitmap.isMutable()) {

// create a mutable version of this bitmap

bitmap = bitmap.copy(Config.ARGB_8888, true);

}

// copy from src.pixels to this.bitmap

int offset = sourceY * sourceImage.width + sourceX;

bitmap.setPixels(sourceImage.pixels,

offset, sourceImage.width,

targetX, targetY, sourceWidth, sourceHeight);

} else { // pixels != null

// copy into this.pixels[] and mark as modified

int srcOffset = sourceY * sourceImage.width + sourceX;

int dstOffset = targetY * width + targetX;

for (int y = sourceY; y < sourceY + sourceHeight; y++) {

System.arraycopy(sourceImage.pixels, srcOffset, pixels, dstOffset, sourceWidth);

srcOffset += sourceImage.width;

dstOffset += width;

}

updatePixelsImpl(targetX, targetY, sourceWidth, sourceHeight);

}

}

//////////////////////////////////////////////////////////////

// ALPHA CHANNEL

/**

public void mask(int alpha[]) {

loadPixels();

// don't execute if mask image is different size

if (alpha.length != pixels.length) {

throw new RuntimeException("The PImage used with mask() must be " +

"the same size as the applet.");

}

for (int i = 0; i < pixels.length; i++) {

pixels[i] = ((alpha[i] & 0xff) << 24) | (pixels[i] & 0xffffff);

}

format = ARGB;

updatePixels();

}

/**

public void mask(PImage alpha) {

if (alpha.pixels == null) {

// if pixels haven't been loaded by the user, then only load them

// temporarily to save memory when finished.

alpha.loadPixels();

mask(alpha.pixels);

alpha.pixels = null;

} else {

mask(alpha.pixels);

}

}

//////////////////////////////////////////////////////////////

// IMAGE FILTERS

/**

public void filter(int kind) {

loadPixels();

switch (kind) {

case BLUR:

// TODO write basic low-pass filter blur here

// what does photoshop do on the edges with this guy?

// better yet.. why bother? just use gaussian with radius 1

filter(BLUR, 1);

break;

case GRAY:

if (format == ALPHA) {

// for an alpha image, convert it to an opaque grayscale

for (int i = 0; i < pixels.length; i++) {

int col = 255 - pixels[i];

pixels[i] = 0xff000000 | (col << 16) | (col << 8) | col;

}

format = RGB;

} else {

// Converts RGB image data into grayscale using

// weighted RGB components, and keeps alpha channel intact.

// [toxi 040115]

for (int i = 0; i < pixels.length; i++) {

int col = pixels[i];

// luminance = 0.3*red + 0.59*green + 0.11*blue

// 0.30 * 256 = 77

// 0.59 * 256 = 151

// 0.11 * 256 = 28

int lum = (77*(col>>16&0xff) + 151*(col>>8&0xff) + 28*(col&0xff))>>8;

pixels[i] = (col & ALPHA_MASK) | lum<<16 | lum<<8 | lum;

}

}

break;

case INVERT:

for (int i = 0; i < pixels.length; i++) {

//pixels[i] = 0xff000000 |

pixels[i] ^= 0xffffff;

}

break;

case POSTERIZE:

throw new RuntimeException("Use filter(POSTERIZE, int levels) " +

"instead of filter(POSTERIZE)");

case RGB:

for (int i = 0; i < pixels.length; i++) {

pixels[i] |= 0xff000000;

}

format = RGB;

break;

case THRESHOLD:

filter(THRESHOLD, 0.5f);

break;

// [toxi20050728] added new filters

case ERODE:

dilate(true);

break;

case DILATE:

dilate(false);

break;

}

updatePixels(); // mark as modified

}

/**

public void filter(int kind, float param) {

loadPixels();

switch (kind) {

case BLUR:

if (format == ALPHA)

blurAlpha(param);

else if (format == ARGB)

blurARGB(param);

else

blurRGB(param);

break;

case GRAY:

throw new RuntimeException("Use filter(GRAY) instead of " +

"filter(GRAY, param)");

case INVERT:

throw new RuntimeException("Use filter(INVERT) instead of " +

"filter(INVERT, param)");

case OPAQUE:

throw new RuntimeException("Use filter(OPAQUE) instead of " +

"filter(OPAQUE, param)");

case POSTERIZE:

int levels = (int)param;

if ((levels < 2) || (levels > 255)) {

throw new RuntimeException("Levels must be between 2 and 255 for " +

"filter(POSTERIZE, levels)");

}

int levels1 = levels - 1;

for (int i = 0; i < pixels.length; i++) {

int rlevel = (pixels[i] >> 16) & 0xff;

int glevel = (pixels[i] >> 8) & 0xff;

int blevel = pixels[i] & 0xff;

rlevel = (((rlevel * levels) >> 8) * 255) / levels1;

glevel = (((glevel * levels) >> 8) * 255) / levels1;

blevel = (((blevel * levels) >> 8) * 255) / levels1;

pixels[i] = ((0xff000000 & pixels[i]) |

(rlevel << 16) |

(glevel << 8) |

blevel);

}

break;

case THRESHOLD: // greater than or equal to the threshold

int thresh = (int) (param * 255);

for (int i = 0; i < pixels.length; i++) {

int max = Math.max((pixels[i] & RED_MASK) >> 16,

Math.max((pixels[i] & GREEN_MASK) >> 8,

(pixels[i] & BLUE_MASK)));

pixels[i] = (pixels[i] & ALPHA_MASK) |

((max < thresh) ? 0x000000 : 0xffffff);

}

break;

// [toxi20050728] added new filters

case ERODE:

throw new RuntimeException("Use filter(ERODE) instead of " +

"filter(ERODE, param)");

case DILATE:

throw new RuntimeException("Use filter(DILATE) instead of " +

"filter(DILATE, param)");

}

updatePixels(); // mark as modified

}

/**

protected void buildBlurKernel(float r) {

int radius = (int) (r * 3.5f);

radius = (radius < 1) ? 1 : ((radius < 248) ? radius : 248);

if (blurRadius != radius) {

blurRadius = radius;

blurKernelSize = 1 + blurRadius<<1;

blurKernel = new int[blurKernelSize];

blurMult = new int[blurKernelSize][256];

int bk,bki;

int[] bm,bmi;

for (int i = 1, radiusi = radius - 1; i < radius; i++) {

blurKernel[radius+i] = blurKernel[radiusi] = bki = radiusi * radiusi;

bm=blurMult[radius+i];

bmi=blurMult[radiusi--];

for (int j = 0; j < 256; j++)

bm[j] = bmi[j] = bki*j;

}

bk = blurKernel[radius] = radius * radius;

bm = blurMult[radius];

for (int j = 0; j < 256; j++)

bm[j] = bk*j;

}

}

protected void blurAlpha(float r) {

int sum, cb;

int read, ri, ym, ymi, bk0;

int b2[] = new int[pixels.length];

int yi = 0;

buildBlurKernel(r);

for (int y = 0; y < height; y++) {

for (int x = 0; x < width; x++) {

//cb = cg = cr = sum = 0;

cb = sum = 0;

read = x - blurRadius;

if (read<0) {

bk0=-read;

read=0;

} else {

if (read >= width)

break;

bk0=0;

}

for (int i = bk0; i < blurKernelSize; i++) {

if (read >= width)

break;

int c = pixels[read + yi];

int[] bm=blurMult[i];

cb += bm[c & BLUE_MASK];

sum += blurKernel[i];

read++;

}

ri = yi + x;

b2[ri] = cb / sum;

}

yi += width;

}

yi = 0;

ym=-blurRadius;

ymi=ym*width;

for (int y = 0; y < height; y++) {

for (int x = 0; x < width; x++) {

//cb = cg = cr = sum = 0;

cb = sum = 0;

if (ym<0) {

bk0 = ri = -ym;

read = x;

} else {

if (ym >= height)

break;

bk0 = 0;

ri = ym;

read = x + ymi;

}

for (int i = bk0; i < blurKernelSize; i++) {

if (ri >= height)

break;

int[] bm=blurMult[i];

cb += bm[b2[read]];

sum += blurKernel[i];

ri++;

read += width;

}

pixels[x+yi] = (cb/sum);

}

yi += width;

ymi += width;

ym++;

}

}

protected void blurRGB(float r) {

int sum, cr, cg, cb; //, k;

int /*pixel,*/ read, ri, /*roff,*/ ym, ymi, /*riw,*/ bk0;

int r2[] = new int[pixels.length];

int g2[] = new int[pixels.length];

int b2[] = new int[pixels.length];

int yi = 0;

buildBlurKernel(r);

for (int y = 0; y < height; y++) {

for (int x = 0; x < width; x++) {

cb = cg = cr = sum = 0;

read = x - blurRadius;

if (read<0) {

bk0=-read;

read=0;

} else {

if (read >= width)

break;

bk0=0;

}

for (int i = bk0; i < blurKernelSize; i++) {

if (read >= width)

break;

int c = pixels[read + yi];

int[] bm=blurMult[i];

cr += bm[(c & RED_MASK) >> 16];

cg += bm[(c & GREEN_MASK) >> 8];

cb += bm[c & BLUE_MASK];

sum += blurKernel[i];

read++;

}

ri = yi + x;

r2[ri] = cr / sum;

g2[ri] = cg / sum;

b2[ri] = cb / sum;

}

yi += width;

}

yi = 0;

ym=-blurRadius;

ymi=ym*width;

for (int y = 0; y < height; y++) {

for (int x = 0; x < width; x++) {

cb = cg = cr = sum = 0;

if (ym<0) {

bk0 = ri = -ym;

read = x;

} else {

if (ym >= height)

break;

bk0 = 0;

ri = ym;

read = x + ymi;

}