/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */

/*

Part of the Processing project - http://processing.org

Copyright (c) 2004-11 Ben Fry and Casey Reas

Copyright (c) 2001-04 Massachusetts Institute of Technology

This library is free software; you can redistribute it and/or

modify it under the terms of the GNU Lesser General Public

License as published by the Free Software Foundation; either

version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General

Public License along with this library; if not, write to the

Free Software Foundation, Inc., 59 Temple Place, Suite 330,

Boston, MA 02111-1307 USA

*/

package processing.core;

import java.awt.*;

import java.awt.image.*;

import java.io.*;

import java.util.Iterator;

import javax.imageio.*;

import javax.imageio.metadata.*;

/**

* ( begin auto-generated from PImage.xml )

*

* Datatype for storing images. Processing can display <b>.gif</b>,

* <b>.jpg</b>, <b>.tga</b>, and <b>.png</b> images. Images may be

* displayed in 2D and 3D space. Before an image is used, it must be loaded

* with the <b>loadImage()</b> function. The <b>PImage</b> class contains

* fields for the <b>width</b> and <b>height</b> of the image, as well as

* an array called <b>pixels[]</b> that contains the values for every pixel

* in the image. The methods described below allow easy access to the

* image's pixels and alpha channel and simplify the process of compositing.<br/>

* <br/> using the <b>pixels[]</b> array, be sure to use the

* <b>loadPixels()</b> method on the image to make sure that the pixel data

* is properly loaded.<br/>

* <br/> create a new image, use the <b>createImage()</b> function. Do not

* use the syntax <b>new PImage()</b>.

*

* ( end auto-generated )

*

* @webref image

* @usage Web &amp; Application

* @instanceName pimg any object of type PImage

* @see PApplet#loadImage(String)

* @see PApplet#imageMode(int)

* @see PApplet#createImage(int, int, int)

*/

public class PImage implements PConstants, Cloneable {

/**

* Format for this image, one of RGB, ARGB or ALPHA.

* note that RGB images still require 0xff in the high byte

* because of how they'll be manipulated by other functions

*/

public int format;

/**

* ( begin auto-generated from pixels.xml )

*

* Array containing the values for all the pixels in the display window.

* These values are of the color datatype. This array is the size of the

* display window. For example, if the image is 100x100 pixels, there will

* be 10000 values and if the window is 200x300 pixels, there will be 60000

* values. The <b>index</b> value defines the position of a value within

* the array. For example, the statement <b>color b = pixels[230]</b> will

* set the variable <b>b</b> to be equal to the value at that location in

* the array.<br />

* <br />

* Before accessing this array, the data must loaded with the

* <b>loadPixels()</b> function. After the array data has been modified,

* the <b>updatePixels()</b> function must be run to update the changes.

* Without <b>loadPixels()</b>, running the code may (or will in future

* releases) result in a NullPointerException.

*

* ( end auto-generated )

*

* @webref image:pixels

* @usage web_application

* @brief Array containing the color of every pixel in the image

*/

public int[] pixels;

/**

* ( begin auto-generated from PImage_width.xml )

*

* The width of the image in units of pixels.

*

* ( end auto-generated )

* @webref pimage:field

* @usage web_application

* @brief Image width

*/

public int width;

/**

* ( begin auto-generated from PImage_height.xml )

*

* The height of the image in units of pixels.

*

* ( end auto-generated )

* @webref pimage:field

* @usage web_application

* @brief Image height

*/

public int height;

/**

* Path to parent object that will be used with save().

* This prevents users from needing savePath() to use PImage.save().

*/

public PApplet parent;

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

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

//protected HashMap<PGraphics, Object> cacheMap;

// protected WeakHashMap<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;

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

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

/**

* ( begin auto-generated from PImage.xml )

*

* Datatype for storing images. Processing can display <b>.gif</b>,

* <b>.jpg</b>, <b>.tga</b>, and <b>.png</b> images. Images may be

* displayed in 2D and 3D space. Before an image is used, it must be loaded

* with the <b>loadImage()</b> function. The <b>PImage</b> object contains

* fields for the <b>width</b> and <b>height</b> of the image, as well as

* an array called <b>pixels[]</b> which contains the values for every

* pixel in the image. A group of methods, described below, allow easy

* access to the image's pixels and alpha channel and simplify the process

* of compositing.

* <br/> <br/>

* Before using the <b>pixels[]</b> array, be sure to use the

* <b>loadPixels()</b> method on the image to make sure that the pixel data

* is properly loaded.

* <br/> <br/>

* To create a new image, use the <b>createImage()</b> function (do not use

* <b>new PImage()</b>).

* ( end auto-generated )

* @nowebref

* @usage web_application

* @see PApplet#loadImage(String, String)

* @see PApplet#imageMode(int)

* @see PApplet#createImage(int, int, int)

*/

public PImage() {

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

// cache = null;

}

/**

* @nowebref

* @param width image width

* @param height image height

*/

public PImage(int width, int height) {

init(width, height, RGB);

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

}

/**

* @nowebref

* @param format Either RGB, ARGB, ALPHA (grayscale alpha channel)

*/

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

init(width, height, format);

}

/**

* Function to be used by subclasses of PImage to init later than

* at the constructor, or re-init later when things changes.

* Used by Capture and Movie classes (and perhaps others),

* because the width/height will not be known when super() is called.

* (Leave this public so that other libraries can do the same.)

*/

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;

// this.cache = null;

}

/**

* Check the alpha on an image, using a really primitive loop.

*/

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;

}

}

}

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

/**

* Construct a new PImage from a java.awt.Image. This constructor assumes

* that you've done the work of making sure a MediaTracker has been used

* to fully download the data and that the img is valid.

*

* @nowebref

* @param img assumes a MediaTracker has been used to fully download

* the data and the img is valid

*/

public PImage(Image img) {

format = RGB;

if (img instanceof BufferedImage) {

BufferedImage bi = (BufferedImage) img;

width = bi.getWidth();

height = bi.getHeight();

pixels = new int[width * height];

pixels = ((DataBufferInt) bi.getRaster().getDataBuffer()).getData();

int type = bi.getType();

if (type == BufferedImage.TYPE_INT_ARGB) {

format = ARGB;

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

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

pixels[i] = 0xFF000000 | pixels[i];

}

}

} else { // 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) { }

}

}

/**

* Use the getNative() method instead, which allows library interfaces to be

* written in a cross-platform fashion for desktop, Android, and others.

*/

@Deprecated

public Image getImage() { // ignore

return (Image) getNative();

}

/**

* Returns a native BufferedImage from this PImage.

*/

public Object getNative() { // ignore

loadPixels();

int type = (format == RGB) ?

BufferedImage.TYPE_INT_RGB : BufferedImage.TYPE_INT_ARGB;

BufferedImage image = new BufferedImage(width, height, type);

WritableRaster wr = image.getRaster();

wr.setDataElements(0, 0, width, height, pixels);

return image;

}

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

//

// // METADATA/PARAMETERS REQUIRED BY RENDERERS

//

// /**

// * Store data of some kind for a renderer that requires extra metadata of

// * some kind. Usually this is a renderer-specific representation of the

// * image data, for instance a BufferedImage with tint() settings applied for

// * PGraphicsJava2D, or resized image data and OpenGL texture indices for

// * PGraphicsOpenGL.

// * @param renderer The PGraphics renderer associated to the image

// * @param storage The metadata required by the renderer

// */

// public void setCache(PGraphics renderer, Object storage) {

// if (cacheMap == null) cacheMap = new WeakHashMap<PGraphics, Object>();

// cacheMap.put(renderer, storage);

// }

//

//

// /**

// * Get cache storage data for the specified renderer. Because each renderer

// * will cache data in different formats, it's necessary to store cache data

// * keyed by the renderer object. Otherwise, attempting to draw the same

// * image to both a PGraphicsJava2D and a PGraphicsOpenGL will cause errors.

// * @param renderer The PGraphics renderer associated to the image

// * @return metadata stored for the specified renderer

// */

// public Object getCache(PGraphics renderer) {

// if (cacheMap == null) return null;

// return cacheMap.get(renderer);

// }

//

//

// /**

// * Remove information associated with this renderer from the cache, if any.

// * @param renderer The PGraphics renderer whose cache data should be removed

// */

// public void removeCache(PGraphics renderer) {

// if (cacheMap != null) {

// cacheMap.remove(renderer);

// }

// }

// /**

// * Store parameters for a renderer that requires extra metadata of

// * some kind.

// * @param renderer The PGraphics renderer associated to the image

// * @param storage The parameters required by the renderer

// */

// public void setParams(PGraphics renderer, Object params) {

// if (paramMap == null) paramMap = new HashMap<PGraphics, Object>();

// paramMap.put(renderer, params);

// }

//

//

// /**

// * Get the parameters for the specified renderer.

// * @param renderer The PGraphics renderer associated to the image

// * @return parameters stored for the specified renderer

// */

// public Object getParams(PGraphics renderer) {

// if (paramMap == null) return null;

// return paramMap.get(renderer);

// }

//

//

// /**

// * Remove information associated with this renderer from the cache, if any.

// * @param renderer The PGraphics renderer whose parameters should be removed

// */

// public void removeParams(PGraphics renderer) {

// if (paramMap != null) {

// paramMap.remove(renderer);

// }

// }

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

// 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 = width;

my2 = height;

}

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;

}

/**

* ( begin auto-generated from PImage_loadPixels.xml )

*

* Loads the pixel data for the image into its <b>pixels[]</b> array. This

* function must always be called before reading from or writing to <b>pixels[]</b>.

* <br/><br/> renderers may or may not seem to require <b>loadPixels()</b>

* or <b>updatePixels()</b>. However, the rule is that any time you want to

* manipulate the <b>pixels[]</b> array, you must first call

* <b>loadPixels()</b>, and after changes have been made, call

* <b>updatePixels()</b>. Even if the renderer may not seem to use this

* function in the current Processing release, this will always be subject

* to change.

*

* ( end auto-generated )

*

* <h3>Advanced</h3>

* Call this when you want to mess with the pixels[] array.

* <p/>

* For subclasses where the pixels[] buffer isn't set by default,

* this should copy all data into the pixels[] array

*

* @webref pimage:pixels

* @brief Loads the pixel data for the image into its pixels[] array

* @usage web_application

*/

public void loadPixels() { // ignore

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

pixels = new int[width*height];

}

setLoaded();

}

public void updatePixels() { // ignore

// updatePixelsImpl(0, 0, width, height);

updatePixels(0, 0, width, height);

}

/**

* ( begin auto-generated from PImage_updatePixels.xml )

*

* Updates the image with the data in its <b>pixels[]</b> array. Use in

* conjunction with <b>loadPixels()</b>. If you're only reading pixels from

* the array, there's no need to call <b>updatePixels()</b>.

* <br/><br/> renderers may or may not seem to require <b>loadPixels()</b>

* or <b>updatePixels()</b>. However, the rule is that any time you want to

* manipulate the <b>pixels[]</b> array, you must first call

* <b>loadPixels()</b>, and after changes have been made, call

* <b>updatePixels()</b>. Even if the renderer may not seem to use this

* function in the current Processing release, this will always be subject

* to change.

* <br/> <br/>

* Currently, none of the renderers use the additional parameters to

* <b>updatePixels()</b>, however this may be implemented in the future.

*

* ( end auto-generated )

* <h3>Advanced</h3>

* Mark the pixels in this region as needing an update.

* This is not currently used by any of the renderers, however the api

* is structured this way in the hope of being able to use this to

* speed things up in the future.

* @webref pimage:pixels

* @brief Updates the image with the data in its pixels[] array

* @usage web_application

* @param x x-coordinate of the upper-left corner

* @param y y-coordinate of the upper-left corner

* @param w width

* @param h height

*/

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

// updatePixelsImpl(x, y, w, h);

// }

//

//

// /**

// * Broken out as separate impl to signify that the w/y/w/h numbers have

// * already been tested and their bounds set properly.

// */

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

mx2 = PApplet.min(width, x2);

my1 = PApplet.max(0, y);

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

my2 = PApplet.min(height, y2);

modified = true;

} else {

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

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

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

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

//if (y > my2) my2 = y;

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

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

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

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

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

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

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

}

}

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

// COPYING IMAGE DATA

/**

* Duplicate an image, returns new PImage object.

* The pixels[] array for the new object will be unique

* and recopied from the source image. This is implemented as an

* override of Object.clone(). We recommend using get() instead,

* because it prevents you from needing to catch the

* CloneNotSupportedException, and from doing a cast from the result.

*/

@Override

public Object clone() throws CloneNotSupportedException { // ignore

return get();

}

/**

* ( begin auto-generated from PImage_resize.xml )

*

* Resize the image to a new width and height. To make the image scale

* proportionally, use 0 as the value for the <b>wide</b> or <b>high</b>

* parameter. For instance, to make the width of an image 150 pixels, and

* change the height using the same proportion, use resize(150, 0).<br />

* <br />

* Even though a PGraphics is technically a PImage, it is not possible to

* rescale the image data found in a PGraphics. (It's simply not possible

* to do this consistently across renderers: technically infeasible with

* P3D, or what would it even do with PDF?) If you want to resize PGraphics

* content, first get a copy of its image data using the <b>get()</b>

* method, and call <b>resize()</b> on the PImage that is returned.

*

* ( end auto-generated )

* @webref pimage:method

* @brief Changes the size of an image to a new width and height

* @usage web_application

* @param w the resized image width

* @param h the resized image height

* @see PImage#get(int, int, int, int)

*/

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, h);

// BufferedImage img = null;

// if (w < width && h < height) {

// img = shrinkImage((BufferedImage) getNative(), w, h);

// } else {

// img = resampleImage((BufferedImage) getNative(), w, h);

// }

PImage temp = new PImage(img);

this.width = temp.width;

this.height = temp.height;

// Get the resized pixel array

this.pixels = temp.pixels;

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

/**

* ( begin auto-generated from PImage_get.xml )

*

* Reads the color of any pixel or grabs a section of an image. If no

* parameters are specified, the entire image is returned. Use the <b>x</b>

* and <b>y</b> parameters to get the value of one pixel. Get a section of

* the display window by specifying an additional <b>width</b> and

* <b>height</b> parameter. When getting an image, the <b>x</b> and

* <b>y</b> parameters define the coordinates for the upper-left corner of

* the image, regardless of the current <b>imageMode()</b>.<br />

* <br />

* If the pixel requested is outside of the image window, black is

* returned. The numbers returned are scaled according to the current color

* ranges, but only RGB values are returned by this function. For example,

* even though you may have drawn a shape with <b>colorMode(HSB)</b>, the

* numbers returned will be in RGB format.<br />

* <br />

* Getting the color of a single pixel with <b>get(x, y)</b> is easy, but

* not as fast as grabbing the data directly from <b>pixels[]</b>. The

* equivalent statement to <b>get(x, y)</b> using <b>pixels[]</b> is

* <b>pixels[y*width+x]</b>. See the reference for <b>pixels[]</b> for more information.

*

* ( end auto-generated )

*

* <h3>Advanced</h3>

* Returns an ARGB "color" type (a packed 32 bit int with the color.

* If the coordinate is outside the image, zero is returned

* (black, but completely transparent).

* <P>

* If the image is in RGB format (i.e. on a PVideo object),

* the value will get its high bits set, just to avoid cases where

* they haven't been set already.

* <P>

* If the image is in ALPHA format, this returns a white with its

* alpha value set.

* <P>

* This function is included primarily for beginners. It is quite

* slow because it has to check to see if the x, y that was provided

* is inside the bounds, and then has to check to see what image

* type it is. If you want things to be more efficient, access the

* pixels[] array directly.

*

* @webref image:pixels

* @brief Reads the color of any pixel or grabs a rectangle of pixels

* @usage web_application

* @param x x-coordinate of the pixel

* @param y y-coordinate of the pixel

* @see PApplet#set(int, int, int)

* @see PApplet#pixels

* @see PApplet#copy(PImage, int, int, int, int, int, int, int, int)

*/

public int get(int x, int y) {

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

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;

}

/**

* @param w width of pixel rectangle to get

* @param h height of pixel rectangle to get

*/

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;

}

/**

* Returns a copy of this PImage. Equivalent to get(0, 0, width, height).

*/

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);

}

/**

* Internal function to actually handle getting a block of pixels that

* has already been properly cropped to a valid region. That is, x/y/w/h

* are guaranteed to be inside the image space, so the implementation can

* use the fastest possible pixel copying method.

*/

protected void getImpl(int sourceX, int sourceY,

int sourceWidth, int sourceHeight,

PImage target, int targetX, int targetY) {

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;

}

}

/**

* ( begin auto-generated from PImage_set.xml )

*

* Changes the color of any pixel or writes an image directly into the

* display window.<br />

* <br />

* The <b>x</b> and <b>y</b> parameters specify the pixel to change and the

* <b>color</b> parameter specifies the color value. The color parameter is

* affected by the current color mode (the default is RGB values from 0 to

* 255). When setting an image, the <b>x</b> and <b>y</b> parameters define

* the coordinates for the upper-left corner of the image, regardless of

* the current <b>imageMode()</b>.

* <br /><br />

* Setting the color of a single pixel with <b>set(x, y)</b> is easy, but

* not as fast as putting the data directly into <b>pixels[]</b>. The

* equivalent statement to <b>set(x, y, #000000)</b> using <b>pixels[]</b>

* is <b>pixels[y*width+x] = #000000</b>. See the reference for

* <b>pixels[]</b> for more information.

*

* ( end auto-generated )

*

* @webref image:pixels

* @brief writes a color to any pixel or writes an image into another

* @usage web_application

* @param x x-coordinate of the pixel

* @param y y-coordinate of the pixel

* @param c any value of the color datatype

* @see PImage#get(int, int, int, int)

* @see PImage#pixels

* @see PImage#copy(PImage, int, int, int, int, int, int, int, int)

*/

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

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

pixels[y*width + x] = c;

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

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

}

/**

* <h3>Advanced</h3>

* Efficient method of drawing an image's pixels directly to this surface.

* No variations are employed, meaning that any scale, tint, or imageMode

* settings will be ignored.

*

* @param img image to copy into the original image

*/

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

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);

}

/**

* Internal function to actually handle setting a block of pixels that

* has already been properly cropped from the image to a valid region.

*/

protected void setImpl(PImage sourceImage,

int sourceX, int sourceY,

int sourceWidth, int sourceHeight,

int targetX, int targetY) {

int sourceOffset = sourceY * sourceImage.width + sourceX;

int targetOffset = targetY * width + targetX;

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

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

sourceOffset += sourceImage.width;

targetOffset += width;

}

//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 RuntimeException("mask() can only be used with an image that's the same size.");

}