/**

public int format;

/**

public int[] pixels;

/** 1 for most images, 2 for hi-dpi/retina */

public int pixelDensity = 1;

/** Actual dimensions of pixels array, taking into account the 2x setting. */

public int pixelWidth;

public int pixelHeight;

/**

public int width;

/**

public int height;

/**

public PApplet parent;

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

/** modified portion of the image */

protected boolean modified;

protected int mx1, my1, mx2, my2;

/** Loaded pixels flag */

public boolean loaded = false;

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

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

pixelDensity = 1;

}

/**

public PImage(int width, int height) {

init(width, height, RGB, 1);

// toxi: is it maybe better to init the image with max alpha enabled?

//for(int i=0; i<pixels.length; i++) pixels[i]=0xffffffff;

// fry: i'm opting for the full transparent image, which is how

// photoshop works, and our audience oughta be familiar with.

// also, i want to avoid having to set all those pixels since

// in java it's super slow, and most using this fxn will be

// setting all the pixels anyway.

// toxi: agreed and same reasons why i left it out ;)

}

/**

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

init(width, height, format, 1);

}

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

init(width, height, format, factor);

}

/**

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

init(width, height, format, 1);

}

/**

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

this.width = width;

this.height = height;

this.format = format;

this.pixelDensity = factor;

pixelWidth = width * pixelDensity;

pixelHeight = height * pixelDensity;

this.pixels = new int[pixelWidth * pixelHeight];

}

/**

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(Image img) {

format = RGB;

if (img instanceof BufferedImage) {

BufferedImage bi = (BufferedImage) img;

width = bi.getWidth();

height = bi.getHeight();

int type = bi.getType();

if (type == BufferedImage.TYPE_3BYTE_BGR ||

type == BufferedImage.TYPE_4BYTE_ABGR) {

pixels = new int[width * height];

bi.getRGB(0, 0, width, height, pixels, 0, width);

if (type == BufferedImage.TYPE_4BYTE_ABGR) {

format = ARGB;

} else {

opaque();

}

} else {

DataBuffer db = bi.getRaster().getDataBuffer();

if (db instanceof DataBufferInt) {

pixels = ((DataBufferInt) db).getData();

if (type == BufferedImage.TYPE_INT_ARGB) {

format = ARGB;

} else if (type == BufferedImage.TYPE_INT_RGB) {

opaque();

}

}

}

}

// Implements fall-through if not DataBufferInt above, or not a

// known type, or not DataBufferInt for the data itself.

if (pixels == null) { // go the old school Java 1.0 route

width = img.getWidth(null);

height = img.getHeight(null);

pixels = new int[width * height];

PixelGrabber pg =

new PixelGrabber(img, 0, 0, width, height, pixels, 0, width);

try {

pg.grabPixels();

} catch (InterruptedException e) { }

}

pixelDensity = 1;

pixelWidth = width;

pixelHeight = height;

}

/**

@Deprecated

public Image getImage() { // ignore

return (Image) getNative();

}

/**

public Object getNative() { // ignore

loadPixels();

int type = (format == RGB) ?

BufferedImage.TYPE_INT_RGB : BufferedImage.TYPE_INT_ARGB;

BufferedImage image = new BufferedImage(pixelWidth, pixelHeight, type);

WritableRaster wr = image.getRaster();

wr.setDataElements(0, 0, pixelWidth, pixelHeight, pixels);

return image;

}

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

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

public boolean isModified() { // ignore

return modified;

}

public void setModified() { // ignore

modified = true;

mx1 = 0;

my1 = 0;

mx2 = pixelWidth;

my2 = pixelHeight;

}

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 != pixelWidth*pixelHeight) {

pixels = new int[pixelWidth*pixelHeight];

}

setLoaded();

}

public void updatePixels() { // ignore

updatePixels(0, 0, pixelWidth, pixelHeight);

}

/**

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

int x2 = x + w;

int y2 = y + h;

if (!modified) {

mx1 = PApplet.max(0, x);

mx2 = PApplet.min(pixelWidth, x2);

my1 = PApplet.max(0, y);

my2 = PApplet.min(pixelHeight, y2);

modified = true;

} else {

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

if (x > mx2) mx2 = PApplet.min(pixelWidth, x);

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

if (y > my2) my2 = PApplet.min(pixelHeight, y);

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

if (x2 > mx2) mx2 = PApplet.min(pixelWidth, x2);

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

if (y2 > my2) my2 = PApplet.min(pixelHeight, 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);

}

BufferedImage img =

shrinkImage((BufferedImage) getNative(), w*pixelDensity, h*pixelDensity);

PImage temp = new PImage(img);

this.pixelWidth = temp.width;

this.pixelHeight = temp.height;

// Get the resized pixel array

this.pixels = temp.pixels;

this.width = pixelWidth / pixelDensity;

this.height = pixelHeight / pixelDensity;

// Mark the pixels array as altered

updatePixels();

}

// Adapted from getFasterScaledInstance() method from page 111 of

// "Filthy Rich Clients" by Chet Haase and Romain Guy

// Additional modifications and simplifications have been added,

// plus a fix to deal with an infinite loop if images are expanded.

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

static private BufferedImage shrinkImage(BufferedImage img,

int targetWidth, int targetHeight) {

int type = (img.getTransparency() == Transparency.OPAQUE) ?

BufferedImage.TYPE_INT_RGB : BufferedImage.TYPE_INT_ARGB;

BufferedImage outgoing = img;

BufferedImage scratchImage = null;

Graphics2D g2 = null;

int prevW = outgoing.getWidth();

int prevH = outgoing.getHeight();

boolean isTranslucent = img.getTransparency() != Transparency.OPAQUE;

// Use multi-step technique: start with original size, then scale down in

// multiple passes with drawImage() until the target size is reached

int w = img.getWidth();

int h = img.getHeight();

do {

if (w > targetWidth) {

w /= 2;

// if this is the last step, do the exact size

if (w < targetWidth) {

w = targetWidth;

}

} else if (targetWidth >= w) {

w = targetWidth;

}

if (h > targetHeight) {

h /= 2;

if (h < targetHeight) {

h = targetHeight;

}

} else if (targetHeight >= h) {

h = targetHeight;

}

if (scratchImage == null || isTranslucent) {

// Use a single scratch buffer for all iterations and then copy

// to the final, correctly-sized image before returning

scratchImage = new BufferedImage(w, h, type);

g2 = scratchImage.createGraphics();

}

g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION,

RenderingHints.VALUE_INTERPOLATION_BILINEAR);

g2.drawImage(outgoing, 0, 0, w, h, 0, 0, prevW, prevH, null);

prevW = w;

prevH = h;

outgoing = scratchImage;

} while (w != targetWidth || h != targetHeight);

if (g2 != null) {

g2.dispose();

}

// If we used a scratch buffer that is larger than our target size,

// create an image of the right size and copy the results into it

if (targetWidth != outgoing.getWidth() ||

targetHeight != outgoing.getHeight()) {

scratchImage = new BufferedImage(targetWidth, targetHeight, type);

g2 = scratchImage.createGraphics();

g2.drawImage(outgoing, 0, 0, null);

g2.dispose();

outgoing = scratchImage;

}

return outgoing;

}

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

// MARKING IMAGE AS LOADED / FOR USE IN RENDERERS

public boolean isLoaded() { // ignore

return loaded;

}

public void setLoaded() { // ignore

loaded = true;

}

public void setLoaded(boolean l) { // ignore

loaded = l;

}

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

// GET/SET PIXELS

/**

public int get(int x, int y) {

if ((x < 0) || (y < 0) || (x >= pixelWidth) || (y >= pixelHeight)) return 0;

switch (format) {

case RGB:

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

case ARGB:

return pixels[y*pixelWidth + x];

case ALPHA:

return (pixels[y*pixelWidth + 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 > pixelWidth) {

w = pixelWidth - x;

cropped = true;

}

if (y + h > pixelHeight) {

h = pixelHeight - 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 / pixelDensity,

targetHeight / pixelDensity,

targetFormat, pixelDensity);

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;

}

/**

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, pixelWidth, pixelHeight);

}

public PImage copy() {

return get(0, 0, pixelWidth, pixelHeight);

}

/**

protected void getImpl(int sourceX, int sourceY,

int sourceWidth, int sourceHeight,

PImage target, int targetX, int targetY) {

int sourceIndex = sourceY*pixelWidth + sourceX;

int targetIndex = targetY*target.pixelWidth + targetX;

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

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

sourceIndex += pixelWidth;

targetIndex += target.pixelWidth;

}

}

/**

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

if ((x < 0) || (y < 0) || (x >= pixelWidth) || (y >= pixelHeight)) return;

pixels[y*pixelWidth + x] = c;

updatePixels(x, y, 1, 1); // slow...

}

/**

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

int sx = 0;

int sy = 0;

int sw = img.pixelWidth;

int sh = img.pixelHeight;

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 > pixelWidth) { // off right edge

sw = pixelWidth - x;

}

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

sh = pixelHeight - 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) {

int sourceOffset = sourceY * sourceImage.pixelWidth + sourceX;

int targetOffset = targetY * pixelWidth + targetX;

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

System.arraycopy(sourceImage.pixels, sourceOffset, pixels, targetOffset, sourceWidth);

sourceOffset += sourceImage.pixelWidth;

targetOffset += pixelWidth;

}

//updatePixelsImpl(targetX, targetY, sourceWidth, sourceHeight);

updatePixels(targetX, targetY, sourceWidth, sourceHeight);

}

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

// ALPHA CHANNEL

@Deprecated

public void mask(int maskArray[]) { // ignore

loadPixels();

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

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

throw new IllegalArgumentException("mask() can only be used with an image that's the same size.");

}

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

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

}

format = ARGB;

updatePixels();

}

/**

public void mask(PImage img) {

img.loadPixels();

mask(img.pixels);

}

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

// IMAGE FILTERS