picrate 2.1.2-java → 2.4.2-java

data/src/main/java/processing/core/PImage.java

@@ -31,27 +31,30 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 
+import processing.awt.ShimAWT;
+
 
 /**
-   * ( 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.
-   *  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.
-   *  create a new image, use the <b>createImage()</b> function. Do not
-   * use the syntax <b>new PImage()</b>.
-   *
-   * ( end auto-generated )
-   *
+ *
+ * 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 />
+ * 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 the
+ * syntax <b>new PImage()</b>.
+ *
+ *
  * @webref image
+ * @webBrief Datatype for storing images.
  * @usage Web &amp; Application
  * @instanceName pimg any object of type PImage
  * @see PApplet#loadImage(String)
@@ -60,7 +63,7 @@ import java.io.OutputStream;
  */
 public class PImage implements PConstants, Cloneable {
 
-  private static final byte TIFF_HEADER[] = {
+  private static final byte[] TIFF_HEADER = {
     77, 77, 0, 42, 0, 0, 0, 8, 0, 9, 0, -2, 0, 4, 0, 0, 0, 1, 0, 0,
     0, 0, 1, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 3, 0, 0, 0, 1,
     0, 0, 0, 0, 1, 2, 0, 3, 0, 0, 0, 3, 0, 0, 0, 122, 1, 6, 0, 3, 0,
@@ -79,28 +82,22 @@ public class PImage implements PConstants, Cloneable {
   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.
    *
+   * The pixels[] array contains the values for all the pixels in the image. These
+   * values are of the color datatype. This array is the size of the image,
+   * meaning if the image is 100 x 100 pixels, there will be 10,000 values and if
+   * the window is 200 x 300 pixels, there will be 60,000 values. <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.
+   * <b>loadPixels()</b> method. Failure to do so may result in a
+   * NullPointerException. After the array data has been modified, the
+   * <b>updatePixels()</b> method must be run to update the content of the display
+   * window.
    *
-   * ( end auto-generated )
    *
    * @webref image:pixels
+   * @webBrief Array containing the color of every pixel in the image.
    * @usage web_application
-   * @brief     Array containing the color of every pixel in the image
    */
   public int[] pixels;
 
@@ -112,26 +109,22 @@ public class PImage implements PConstants, Cloneable {
   public int pixelHeight;
 
   /**
-   * ( begin auto-generated from PImage_width.xml )
    *
    * The width of the image in units of pixels.
    *
-   * ( end auto-generated )
    * @webref pimage:field
+   * @webBrief The width of the image in units of pixels.
    * @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
+   * @webBrief The height of the image in units of pixels.
    * @usage web_application
-   * @brief     Image height
    */
   public int height;
 
@@ -155,14 +148,11 @@ public class PImage implements PConstants, Cloneable {
   // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
 
 
-  // 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 ifV, sX, v1, v2, iw, iw1, ih1;
   private int srcXOffset, srcYOffset;
-  private int r, g, b, a;
   private int[] srcBuffer;
 
-  // fixed point precision is limited to 15 bits!!
+  // 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;
@@ -197,14 +187,13 @@ public class PImage implements PConstants, Cloneable {
    * 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)
@@ -213,7 +202,6 @@ public class PImage implements PConstants, Cloneable {
    */
   public PImage() {
     format = ARGB;  // default to ARGB images for release 0116
-    pixelDensity = 1;
   }
 
 
@@ -228,7 +216,7 @@ public class PImage implements PConstants, Cloneable {
     // 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.
+    // photoshop works, and our audience will likely 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.
@@ -296,15 +284,10 @@ public class PImage implements PConstants, Cloneable {
 
   //////////////////////////////////////////////////////////////
 
-  public PImage(int width, int height, int[] pixels, boolean requiresCheckAlpha, PApplet parent) {
-    initFromPixels(
-        width,
-        height,
-        pixels,
-        RGB,
-        1
-    );
 
+  public PImage(int width, int height, int[] pixels,
+                boolean requiresCheckAlpha, PApplet parent) {
+    initFromPixels(width, height, pixels, RGB,1);
     this.parent = parent;
 
     if (requiresCheckAlpha) {
@@ -312,7 +295,8 @@ public class PImage implements PConstants, Cloneable {
     }
   }
 
-  public PImage(int width, int height, int[] pixels, boolean requiresCheckAlpha, PApplet parent,
+  public PImage(int width, int height, int[] pixels,
+                boolean requiresCheckAlpha, PApplet parent,
                 int format, int factor) {
 
     initFromPixels(width, height, pixels, format, factor);
@@ -382,28 +366,20 @@ public class PImage implements PConstants, Cloneable {
 
 
   /**
-   * ( 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>.
-   *  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 )
+   * Loads the pixel data of the current display window into the <b>pixels[]</b>
+   * array. This function must always be called before reading from or writing to
+   * <b>pixels[]</b>. Subsequent changes to the display window will not be
+   * reflected in <b>pixels</b> until <b>loadPixels()</b> is called again.
    *
-   * <h3>Advanced</h3>
-   * Call this when you want to mess with the pixels[] array.
    *
-   * For subclasses where the pixels[] buffer isn't set by default,
-   * this should copy all data into the pixels[] array
+   * <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
+   * @webBrief Loads the pixel data for the image into its <b>pixels[]</b> array.
    * @usage web_application
    */
   public void loadPixels() {  // ignore
@@ -420,30 +396,19 @@ public class PImage implements PConstants, Cloneable {
 
 
   /**
-   * ( 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>.
-   *  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.
-   *
-   * 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.
+   *
+   * Updates the display window with the data in the <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> &mdash; updating is only
+   * necessary to apply changes.
+   *
+   * <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
+   * @webBrief Updates the image with the data in its <b>pixels[]</b> array.
    * @usage web_application
    * @param x x-coordinate of the upper-left corner
    * @param y y-coordinate of the upper-left corner
@@ -495,13 +460,12 @@ public class PImage implements PConstants, Cloneable {
 
 
   /**
-   * ( 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).
-   *
+   * 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
@@ -509,9 +473,8 @@ public class PImage implements PConstants, Cloneable {
    * 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
+   * @webBrief Resize the image to a new width and height.
    * @usage web_application
    * @param w the resized image width
    * @param h the resized image height
@@ -548,7 +511,6 @@ public class PImage implements PConstants, Cloneable {
 
 
   /**
-   * ( 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>
@@ -556,20 +518,19 @@ public class PImage implements PConstants, Cloneable {
    * 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>.
-   *
+   * 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.
-   *
+   * 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.
@@ -590,7 +551,7 @@ public class PImage implements PConstants, Cloneable {
    * pixels[] array directly.
    *
    * @webref image:pixels
-   * @brief Reads the color of any pixel or grabs a rectangle of pixels
+   * @webBrief 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
@@ -707,28 +668,26 @@ public class PImage implements PConstants, Cloneable {
 
 
   /**
-   * ( begin auto-generated from PImage_set.xml )
    *
    * Changes the color of any pixel or writes an image directly into the
-   * display window.
-   *
+   * 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
+   * @webBrief 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
@@ -829,20 +788,18 @@ public class PImage implements PConstants, Cloneable {
 
 
   /**
-   * ( begin auto-generated from PImage_mask.xml )
    *
    * Masks part of an image from displaying by loading another image and
    * using it as an alpha channel. This mask image should only contain
    * grayscale data, but only the blue color channel is used. The mask image
-   * needs to be the same size as the image to which it is applied.
-   *
+   * needs to be the same size as the image to which it is applied.<br />
+   * <br />
    * In addition to using a mask image, an integer array containing the alpha
    * channel data can be specified directly. This method is useful for
    * creating dynamically generated alpha masks. This array must be of the
    * same length as the target image's pixels array and should contain only
    * grayscale data of values between 0-255.
    *
-   * ( end auto-generated )
    *
    * <h3>Advanced</h3>
    *
@@ -859,9 +816,9 @@ public class PImage implements PConstants, Cloneable {
    * performing a proper luminance-based conversion.
    *
    * @webref pimage:method
+   * @webBrief Masks part of an image with another image as an alpha channel
    * @usage web_application
    * @param img image to use as the mask
-   * @brief Masks part of an image with another image as an alpha channel
    */
   public void mask(PImage img) {
     img.loadPixels();
@@ -947,36 +904,43 @@ public class PImage implements PConstants, Cloneable {
 
 
   /**
-   * ( begin auto-generated from PImage_filter.xml )
-   *
-   * Filters an image as defined by one of the following modes:
-   * THRESHOLD - converts the image to black and white pixels depending if
-   * they are above or below the threshold defined by the level parameter.
-   * The level must be between 0.0 (black) and 1.0(white). If no level is
-   * specified, 0.5 is used.
-   *
-   * GRAY - converts any colors in the image to grayscale equivalents
-   *
-   * INVERT - sets each pixel to its inverse value
-   *
-   * POSTERIZE - limits each channel of the image to the number of colors
-   * specified as the level parameter
    *
-   * BLUR - executes a Guassian blur with the level parameter specifying the
-   * extent of the blurring. If no level parameter is used, the blur is
-   * equivalent to Guassian blur of radius 1
-   *
-   * OPAQUE - sets the alpha channel to entirely opaque
-   *
-   * ERODE - reduces the light areas with the amount defined by the level
-   * parameter
-   *
-   * DILATE - increases the light areas with the amount defined by the level parameter
-   *
-   * ( end auto-generated )
-   *
-   * <h3>Advanced</h3>
-   * Method to apply a variety of basic filters to this image.
+   * Filters the image as defined by one of the following modes:<br />
+   * <br />
+   * THRESHOLD<br />
+   * Converts the image to black and white pixels depending if they are above or
+   * below the threshold defined by the level parameter. The parameter must be
+   * between 0.0 (black) and 1.0 (white). If no level is specified, 0.5 is
+   * used.<br />
+   * <br />
+   * GRAY<br />
+   * Converts any colors in the image to grayscale equivalents. No parameter is
+   * used.<br />
+   * <br />
+   * OPAQUE<br />
+   * Sets the alpha channel to entirely opaque. No parameter is used.<br />
+   * <br />
+   * INVERT<br />
+   * Sets each pixel to its inverse value. No parameter is used.<br />
+   * <br />
+   * POSTERIZE<br />
+   * Limits each channel of the image to the number of colors specified as the
+   * parameter. The parameter can be set to values between 2 and 255, but results
+   * are most noticeable in the lower ranges.<br />
+   * <br />
+   * BLUR<br />
+   * Executes a Gaussian blur with the level parameter specifying the extent of
+   * the blurring. If no parameter is used, the blur is equivalent to Gaussian
+   * blur of radius 1. Larger values increase the blur.<br />
+   * <br />
+   * ERODE<br />
+   * Reduces the light areas. No parameter is used.<br />
+   * <br />
+   * DILATE<br />
+   * Increases the light areas. No parameter is used.
+   *
+   *
+   * <h3>Advanced</h3> Method to apply a variety of basic filters to this image.
    * <P>
    * <UL>
    * <LI>filter(BLUR) provides a basic blur.
@@ -989,14 +953,15 @@ public class PImage implements PConstants, Cloneable {
    * </UL>
    * Luminance conversion code contributed by
    * <A HREF="http://www.toxi.co.uk">toxi</A>
-   *
+   * <P/>
    * Gaussian blur code contributed by
    * <A HREF="http://incubator.quasimondo.com">Mario Klingemann</A>
    *
    * @webref image:pixels
-   * @brief Converts the image to grayscale or black and white
+   * @webBrief Converts the image to grayscale or black and white
    * @usage web_application
-   * @param kind Either THRESHOLD, GRAY, OPAQUE, INVERT, POSTERIZE, BLUR, ERODE, or DILATE
+   * @param kind  Either THRESHOLD, GRAY, OPAQUE, INVERT, POSTERIZE, BLUR, ERODE,
+   *              or DILATE
    * @param param unique for each, see above
    */
   public void filter(int kind, float param) {
@@ -1004,20 +969,14 @@ public class PImage implements PConstants, Cloneable {
 
     switch (kind) {
       case BLUR:
-      switch (format) {
-        case ALPHA:
+        if (format == ALPHA)
           blurAlpha(param);
-          break;
-        case ARGB:
+        else if (format == ARGB)
           blurARGB(param);
-          break;
-        default:
+        else
           blurRGB(param);
-          break;
-      }
         break;
 
-
       case GRAY:
         throw new RuntimeException("Use filter(GRAY) instead of " +
                                    "filter(GRAY, param)");
@@ -1091,7 +1050,8 @@ public class PImage implements PConstants, Cloneable {
    */
   protected void buildBlurKernel(float r) {
     int radius = (int) (r * 3.5f);
-    radius = (radius < 1) ? 1 : ((radius < 248) ? radius : 248);
+    if (radius < 1) radius = 1;
+    if (radius > 248) radius = 248;
     if (blurRadius != radius) {
       blurRadius = radius;
       blurKernelSize = 1 + blurRadius<<1;
@@ -1188,8 +1148,8 @@ public class PImage implements PConstants, Cloneable {
 
 
   protected void blurRGB(float r) {
-    int sum, cr, cg, cb; //, k;
-    int /*pixel,*/ read, ri, /*roff,*/ ym, ymi, /*riw,*/ bk0;
+    int sum, cr, cg, cb;
+    int read, ri, ym, ymi, bk0;
     int[] r2 = new int[pixels.length];
     int[] g2 = new int[pixels.length];
     int[] b2 = new int[pixels.length];
@@ -1420,7 +1380,7 @@ public class PImage implements PConstants, Cloneable {
         }
         if (lumDown > currLum) {
           result = colDown;
-          currLum = lumDown;
+//          currLum = lumDown;  // removed, unused assignment
         }
         outgoing[index++] = result;
       }
@@ -1489,7 +1449,7 @@ public class PImage implements PConstants, Cloneable {
         }
         if (lumDown < currLum) {
           result = colDown;
-          currLum = lumDown;
+//          currLum = lumDown;  // removed, unused assignment
         }
         outgoing[index++] = result;
       }
@@ -1505,20 +1465,18 @@ public class PImage implements PConstants, Cloneable {
 
 
   /**
-   * ( begin auto-generated from PImage_copy.xml )
    *
    * Copies a region of pixels from one image into another. If the source and
    * destination regions aren't the same size, it will automatically resize
    * source pixels to fit the specified target region. No alpha information
    * is used in the process, however if the source image has an alpha channel
    * set, it will be copied as well.
-   *
+   * <br /><br />
    * As of release 0149, this function ignores <b>imageMode()</b>.
    *
-   * ( end auto-generated )
    *
    * @webref image:pixels
-   * @brief Copies the entire image
+   * @webBrief Copies the entire image
    * @usage web_application
    * @param sx X coordinate of the source's upper left corner
    * @param sy Y coordinate of the source's upper left corner
@@ -1554,13 +1512,11 @@ public class PImage implements PConstants, Cloneable {
 
 
   /**
-   * ( begin auto-generated from blendColor.xml )
    *
    * Blends two color values together based on the blending mode given as the
    * <b>MODE</b> parameter. The possible modes are described in the reference
    * for the <b>blend()</b> function.
    *
-   * ( end auto-generated )
    * <h3>Advanced</h3>
    * <UL>
    * <LI>REPLACE - destination colour equals colour of source pixel: C = A.
@@ -1574,7 +1530,7 @@ public class PImage implements PConstants, Cloneable {
    *     Clipped to 0..255, Photoshop calls this "Linear Burn",
    *     and Director calls it "Add Pin".
    *
-   * <LI>SUBTRACT - substractive blend with black clip:
+   * <LI>SUBTRACT - subtractive blend with black clip:
    *     <TT>C = max(B - A*factor, 0)</TT>.
    *     Clipped to 0..255, Photoshop calls this "Linear Dodge",
    *     and Director calls it "Subtract Pin".
@@ -1616,15 +1572,17 @@ public class PImage implements PConstants, Cloneable {
    * necessarily "correct" code. No biggie, most software does. A nitpicker
    * can find numerous "off by 1 division" problems in the blend code where
    * <TT>&gt;&gt;8</TT> or <TT>&gt;&gt;7</TT> is used when strictly speaking
-   * <TT>/255.0</TT> or <TT>/127.0</TT> should have been used.</P>
+   * <TT>/255.0</T> or <TT>/127.0</TT> should have been used.</P>
    * <P>For instance, exclusion (not intended for real-time use) reads
    * <TT>r1 + r2 - ((2 * r1 * r2) / 255)</TT> because <TT>255 == 1.0</TT>
    * not <TT>256 == 1.0</TT>. In other words, <TT>(255*255)>>8</TT> is not
    * the same as <TT>(255*255)/255</TT>. But for real-time use the shifts
-   * are preferrable, and the difference is insignificant for applications
+   * are preferable, and the difference is insignificant for applications
    * built with Processing.</P>
    *
    * @webref color:creating_reading
+   * @webBrief Blends two color values together based on the blending mode given as the
+   * <b>MODE</b> parameter.
    * @usage web_application
    * @param c1 the first color to blend
    * @param c2 the second color to blend
@@ -1667,65 +1625,63 @@ public class PImage implements PConstants, Cloneable {
 
 
   /**
-   * ( begin auto-generated from PImage_blend.xml )
    *
    * Blends a region of pixels into the image specified by the <b>img</b>
    * parameter. These copies utilize full alpha channel support and a choice
    * of the following modes to blend the colors of source pixels (A) with the
-   * ones of pixels in the destination image (B):
-   *
-   * BLEND - linear interpolation of colours: C = A*factor + B
-   *
-   * ADD - additive blending with white clip: C = min(A*factor + B, 255)
-   *
+   * ones of pixels in the destination image (B):<br />
+   * <br />
+   * BLEND - linear interpolation of colours: C = A*factor + B<br />
+   * <br />
+   * ADD - additive blending with white clip: C = min(A*factor + B, 255)<br />
+   * <br />
    * SUBTRACT - subtractive blending with black clip: C = max(B - A*factor,
-   * 0)
-   *
-   * DARKEST - only the darkest colour succeeds: C = min(A*factor, B)
-   *
-   * LIGHTEST - only the lightest colour succeeds: C = max(A*factor, B)
-   *
-   * DIFFERENCE - subtract colors from underlying image.
-   *
-   * EXCLUSION - similar to DIFFERENCE, but less extreme.
-   *
-   * MULTIPLY - Multiply the colors, result will always be darker.
-   *
-   * SCREEN - Opposite multiply, uses inverse values of the colors.
-   *
+   * 0)<br />
+   * <br />
+   * DARKEST - only the darkest colour succeeds: C = min(A*factor, B)<br />
+   * <br />
+   * LIGHTEST - only the lightest colour succeeds: C = max(A*factor, B)<br />
+   * <br />
+   * DIFFERENCE - subtract colors from underlying image.<br />
+   * <br />
+   * EXCLUSION - similar to DIFFERENCE, but less extreme.<br />
+   * <br />
+   * MULTIPLY - Multiply the colors, result will always be darker.<br />
+   * <br />
+   * SCREEN - Opposite multiply, uses inverse values of the colors.<br />
+   * <br />
    * OVERLAY - A mix of MULTIPLY and SCREEN. Multiplies dark values,
-   * and screens light values.
-   *
-   * HARD_LIGHT - SCREEN when greater than 50% gray, MULTIPLY when lower.
-   *
+   * and screens light values.<br />
+   * <br />
+   * HARD_LIGHT - SCREEN when greater than 50% gray, MULTIPLY when lower.<br />
+   * <br />
    * SOFT_LIGHT - Mix of DARKEST and LIGHTEST.
-   * Works like OVERLAY, but not as harsh.
-   *
+   * Works like OVERLAY, but not as harsh.<br />
+   * <br />
    * DODGE - Lightens light tones and increases contrast, ignores darks.
-   * Called "Color Dodge" in Illustrator and Photoshop.
-   *
+   * Called "Color Dodge" in Illustrator and Photoshop.<br />
+   * <br />
    * BURN - Darker areas are applied, increasing contrast, ignores lights.
-   * Called "Color Burn" in Illustrator and Photoshop.
-   *
+   * Called "Color Burn" in Illustrator and Photoshop.<br />
+   * <br />
    * All modes use the alpha information (highest byte) of source image
    * pixels as the blending factor. If the source and destination regions are
    * different sizes, the image will be automatically resized to match the
    * destination size. If the <b>srcImg</b> parameter is not used, the
-   * display window is used as the source image.
-   *
+   * display window is used as the source image.<br />
+   * <br />
    * As of release 0149, this function ignores <b>imageMode()</b>.
    *
-   * ( end auto-generated )
    *
    * @webref image:pixels
-   * @brief  Copies a pixel or rectangle of pixels using different blending modes
+   * @webBrief Copies a pixel or rectangle of pixels using different blending modes.
    * @param src an image variable referring to the source image
    * @param sx X coordinate of the source's upper left corner
    * @param sy Y coordinate of the source's upper left corner
    * @param sw source image width
    * @param sh source image height
-   * @param dx X coordinate of the destinations's upper left corner
-   * @param dy Y coordinate of the destinations's upper left corner
+   * @param dx X coordinate of the destination's upper left corner
+   * @param dy Y coordinate of the destination's upper left corner
    * @param dw destination image width
    * @param dh destination image height
    * @param mode Either BLEND, ADD, SUBTRACT, LIGHTEST, DARKEST, DIFFERENCE, EXCLUSION, MULTIPLY, SCREEN, OVERLAY, HARD_LIGHT, SOFT_LIGHT, DODGE, BURN
@@ -1745,18 +1701,18 @@ public class PImage implements PConstants, Cloneable {
     loadPixels();
     if (src == this) {
       if (intersect(sx, sy, sx2, sy2, dx, dy, dx2, dy2)) {
-        blit_resize(get(sx, sy, sw, sh),
+        blitResize(get(sx, sy, sw, sh),
                     0, 0, sw, sh,
-                    pixels, pixelWidth, pixelHeight, dx, dy, dx2, dy2, mode);
+                    pixels, pixelWidth, pixelHeight, dx, dy, dx2, dy2, mode, true);
       } else {
         // same as below, except skip the loadPixels() because it'd be redundant
-        blit_resize(src, sx, sy, sx2, sy2,
-                    pixels, pixelWidth, pixelHeight, dx, dy, dx2, dy2, mode);
+        blitResize(src, sx, sy, sx2, sy2,
+                    pixels, pixelWidth, pixelHeight, dx, dy, dx2, dy2, mode, true);
       }
     } else {
       src.loadPixels();
-      blit_resize(src, sx, sy, sx2, sy2,
-                  pixels, pixelWidth, pixelHeight, dx, dy, dx2, dy2, mode);
+      blitResize(src, sx, sy, sx2, sy2,
+                  pixels, pixelWidth, pixelHeight, dx, dy, dx2, dy2, mode, true);
       //src.updatePixels();
     }
     updatePixels();
@@ -1807,11 +1763,11 @@ public class PImage implements PConstants, Cloneable {
    * Uses bilinear filtering if smooth() has been enabled
    * 'mode' determines the blending mode used in the process.
    */
-  private void blit_resize(PImage img,
-                           int srcX1, int srcY1, int srcX2, int srcY2,
-                           int[] destPixels, int screenW, int screenH,
-                           int destX1, int destY1, int destX2, int destY2,
-                           int mode) {
+  private void blitResize(PImage img,
+                          int srcX1, int srcY1, int srcX2, int srcY2,
+                          int[] destPixels, int screenW, int screenH,
+                          int destX1, int destY1, int destX2, int destY2,
+                          int mode, boolean smooth) {
     if (srcX1 < 0) srcX1 = 0;
     if (srcY1 < 0) srcY1 = 0;
     if (srcX2 > img.pixelWidth) srcX2 = img.pixelWidth;
@@ -1822,10 +1778,9 @@ public class PImage implements PConstants, Cloneable {
     int destW = destX2 - destX1;
     int destH = destY2 - destY1;
 
-    boolean smooth = true;  // may as well go with the smoothing these days
-
     if (!smooth) {
-      srcW++; srcH++;
+      srcW++;
+      srcH++;
     }
 
     if (destW <= 0 || destH <= 0 ||
@@ -1857,12 +1812,23 @@ public class PImage implements PConstants, Cloneable {
     srcBuffer = img.pixels;
 
     if (smooth) {
-      // use bilinear filtering
-      iw = img.pixelWidth;
-      iw1 = img.pixelWidth - 1;
-      ih1 = img.pixelHeight - 1;
+      blitResizeBilinear(img, destPixels, destOffset, screenW, destW, destH, dx, dy, mode);
+    } else {
+      blitResizeNearest(img, destPixels, destOffset, screenW, destW, destH, dx, dy, mode);
+    }
+  }
 
-      switch (mode) {
+  private void blitResizeBilinear(PImage img,
+                                  int[] destPixels, int destOffset, int screenW,
+                                  int destW, int destH,
+                                  int dx, int dy,
+                                  int mode) {
+    // use bilinear filtering
+    iw = img.pixelWidth;
+    iw1 = img.pixelWidth - 1;
+    ih1 = img.pixelHeight - 1;
+
+    switch (mode) {
 
       case BLEND:
         for (int y = 0; y < destH; y++) {
@@ -1870,7 +1836,7 @@ public class PImage implements PConstants, Cloneable {
           for (int x = 0; x < destW; x++) {
             // davbol  - renamed old blend_multiply to blend_blend
             destPixels[destOffset + x] =
-              blend_blend(destPixels[destOffset + x], filter_bilinear());
+                    blend_blend(destPixels[destOffset + x], filter_bilinear());
             sX += dx;
           }
           destOffset += screenW;
@@ -1883,7 +1849,7 @@ public class PImage implements PConstants, Cloneable {
           filter_new_scanline();
           for (int x = 0; x < destW; x++) {
             destPixels[destOffset + x] =
-              blend_add_pin(destPixels[destOffset + x], filter_bilinear());
+                    blend_add_pin(destPixels[destOffset + x], filter_bilinear());
             sX += dx;
           }
           destOffset += screenW;
@@ -1896,7 +1862,7 @@ public class PImage implements PConstants, Cloneable {
           filter_new_scanline();
           for (int x = 0; x < destW; x++) {
             destPixels[destOffset + x] =
-              blend_sub_pin(destPixels[destOffset + x], filter_bilinear());
+                    blend_sub_pin(destPixels[destOffset + x], filter_bilinear());
             sX += dx;
           }
           destOffset += screenW;
@@ -1909,7 +1875,7 @@ public class PImage implements PConstants, Cloneable {
           filter_new_scanline();
           for (int x = 0; x < destW; x++) {
             destPixels[destOffset + x] =
-              blend_lightest(destPixels[destOffset + x], filter_bilinear());
+                    blend_lightest(destPixels[destOffset + x], filter_bilinear());
             sX += dx;
           }
           destOffset += screenW;
@@ -1922,7 +1888,7 @@ public class PImage implements PConstants, Cloneable {
           filter_new_scanline();
           for (int x = 0; x < destW; x++) {
             destPixels[destOffset + x] =
-              blend_darkest(destPixels[destOffset + x], filter_bilinear());
+                    blend_darkest(destPixels[destOffset + x], filter_bilinear());
             sX += dx;
           }
           destOffset += screenW;
@@ -1947,7 +1913,7 @@ public class PImage implements PConstants, Cloneable {
           filter_new_scanline();
           for (int x = 0; x < destW; x++) {
             destPixels[destOffset + x] =
-              blend_difference(destPixels[destOffset + x], filter_bilinear());
+                    blend_difference(destPixels[destOffset + x], filter_bilinear());
             sX += dx;
           }
           destOffset += screenW;
@@ -1960,7 +1926,7 @@ public class PImage implements PConstants, Cloneable {
           filter_new_scanline();
           for (int x = 0; x < destW; x++) {
             destPixels[destOffset + x] =
-              blend_exclusion(destPixels[destOffset + x], filter_bilinear());
+                    blend_exclusion(destPixels[destOffset + x], filter_bilinear());
             sX += dx;
           }
           destOffset += screenW;
@@ -1973,7 +1939,7 @@ public class PImage implements PConstants, Cloneable {
           filter_new_scanline();
           for (int x = 0; x < destW; x++) {
             destPixels[destOffset + x] =
-              blend_multiply(destPixels[destOffset + x], filter_bilinear());
+                    blend_multiply(destPixels[destOffset + x], filter_bilinear());
             sX += dx;
           }
           destOffset += screenW;
@@ -1986,7 +1952,7 @@ public class PImage implements PConstants, Cloneable {
           filter_new_scanline();
           for (int x = 0; x < destW; x++) {
             destPixels[destOffset + x] =
-              blend_screen(destPixels[destOffset + x], filter_bilinear());
+                    blend_screen(destPixels[destOffset + x], filter_bilinear());
             sX += dx;
           }
           destOffset += screenW;
@@ -1999,7 +1965,7 @@ public class PImage implements PConstants, Cloneable {
           filter_new_scanline();
           for (int x = 0; x < destW; x++) {
             destPixels[destOffset + x] =
-              blend_overlay(destPixels[destOffset + x], filter_bilinear());
+                    blend_overlay(destPixels[destOffset + x], filter_bilinear());
             sX += dx;
           }
           destOffset += screenW;
@@ -2012,7 +1978,7 @@ public class PImage implements PConstants, Cloneable {
           filter_new_scanline();
           for (int x = 0; x < destW; x++) {
             destPixels[destOffset + x] =
-              blend_hard_light(destPixels[destOffset + x], filter_bilinear());
+                    blend_hard_light(destPixels[destOffset + x], filter_bilinear());
             sX += dx;
           }
           destOffset += screenW;
@@ -2025,7 +1991,7 @@ public class PImage implements PConstants, Cloneable {
           filter_new_scanline();
           for (int x = 0; x < destW; x++) {
             destPixels[destOffset + x] =
-              blend_soft_light(destPixels[destOffset + x], filter_bilinear());
+                    blend_soft_light(destPixels[destOffset + x], filter_bilinear());
             sX += dx;
           }
           destOffset += screenW;
@@ -2039,7 +2005,7 @@ public class PImage implements PConstants, Cloneable {
           filter_new_scanline();
           for (int x = 0; x < destW; x++) {
             destPixels[destOffset + x] =
-              blend_dodge(destPixels[destOffset + x], filter_bilinear());
+                    blend_dodge(destPixels[destOffset + x], filter_bilinear());
             sX += dx;
           }
           destOffset += screenW;
@@ -2052,7 +2018,7 @@ public class PImage implements PConstants, Cloneable {
           filter_new_scanline();
           for (int x = 0; x < destW; x++) {
             destPixels[destOffset + x] =
-              blend_burn(destPixels[destOffset + x], filter_bilinear());
+                    blend_burn(destPixels[destOffset + x], filter_bilinear());
             sX += dx;
           }
           destOffset += screenW;
@@ -2060,245 +2026,249 @@ public class PImage implements PConstants, Cloneable {
         }
         break;
 
-      }
+    }
+  }
 
-    } else {
-      // nearest neighbour scaling (++fast!)
-      switch (mode) {
+  private void blitResizeNearest(PImage img,
+                                 int[] destPixels, int destOffset, int screenW,
+                                 int destW, int destH,
+                                 int dx, int dy,
+                                 int mode) {
+    // nearest neighbour scaling (++fast!)
+    int sY;
+    switch (mode) {
 
-      case BLEND:
-        for (int y = 0; y < destH; y++) {
-          sX = srcXOffset;
-          sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
-          for (int x = 0; x < destW; x++) {
-            // davbol - renamed old blend_multiply to blend_blend
-            destPixels[destOffset + x] =
-              blend_blend(destPixels[destOffset + x],
+    case BLEND:
+      for (int y = 0; y < destH; y++) {
+        sX = srcXOffset;
+        sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
+        for (int x = 0; x < destW; x++) {
+          // davbol - renamed old blend_multiply to blend_blend
+          destPixels[destOffset + x] =
+            blend_blend(destPixels[destOffset + x],
+                        srcBuffer[sY + (sX >> PRECISIONB)]);
+          sX += dx;
+        }
+        destOffset += screenW;
+        srcYOffset += dy;
+      }
+      break;
+
+    case ADD:
+      for (int y = 0; y < destH; y++) {
+        sX = srcXOffset;
+        sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
+        for (int x = 0; x < destW; x++) {
+          destPixels[destOffset + x] =
+            blend_add_pin(destPixels[destOffset + x],
                           srcBuffer[sY + (sX >> PRECISIONB)]);
-            sX += dx;
-          }
-          destOffset += screenW;
-          srcYOffset += dy;
+          sX += dx;
         }
-        break;
-
-      case ADD:
-        for (int y = 0; y < destH; y++) {
-          sX = srcXOffset;
-          sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
-          for (int x = 0; x < destW; x++) {
-            destPixels[destOffset + x] =
-              blend_add_pin(destPixels[destOffset + x],
-                            srcBuffer[sY + (sX >> PRECISIONB)]);
-            sX += dx;
-          }
-          destOffset += screenW;
-          srcYOffset += dy;
+        destOffset += screenW;
+        srcYOffset += dy;
+      }
+      break;
+
+    case SUBTRACT:
+      for (int y = 0; y < destH; y++) {
+        sX = srcXOffset;
+        sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
+        for (int x = 0; x < destW; x++) {
+          destPixels[destOffset + x] =
+            blend_sub_pin(destPixels[destOffset + x],
+                          srcBuffer[sY + (sX >> PRECISIONB)]);
+          sX += dx;
         }
-        break;
-
-      case SUBTRACT:
-        for (int y = 0; y < destH; y++) {
-          sX = srcXOffset;
-          sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
-          for (int x = 0; x < destW; x++) {
-            destPixels[destOffset + x] =
-              blend_sub_pin(destPixels[destOffset + x],
-                            srcBuffer[sY + (sX >> PRECISIONB)]);
-            sX += dx;
-          }
-          destOffset += screenW;
-          srcYOffset += dy;
+        destOffset += screenW;
+        srcYOffset += dy;
+      }
+      break;
+
+    case LIGHTEST:
+      for (int y = 0; y < destH; y++) {
+        sX = srcXOffset;
+        sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
+        for (int x = 0; x < destW; x++) {
+          destPixels[destOffset + x] =
+            blend_lightest(destPixels[destOffset + x],
+                           srcBuffer[sY + (sX >> PRECISIONB)]);
+          sX += dx;
+        }
+        destOffset += screenW;
+        srcYOffset += dy;
+      }
+      break;
+
+    case DARKEST:
+      for (int y = 0; y < destH; y++) {
+        sX = srcXOffset;
+        sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
+        for (int x = 0; x < destW; x++) {
+          destPixels[destOffset + x] =
+            blend_darkest(destPixels[destOffset + x],
+                          srcBuffer[sY + (sX >> PRECISIONB)]);
+          sX += dx;
         }
-        break;
-
-      case LIGHTEST:
-        for (int y = 0; y < destH; y++) {
-          sX = srcXOffset;
-          sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
-          for (int x = 0; x < destW; x++) {
-            destPixels[destOffset + x] =
-              blend_lightest(destPixels[destOffset + x],
+        destOffset += screenW;
+        srcYOffset += dy;
+      }
+      break;
+
+    case REPLACE:
+      for (int y = 0; y < destH; y++) {
+        sX = srcXOffset;
+        sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
+        for (int x = 0; x < destW; x++) {
+          destPixels[destOffset + x] = srcBuffer[sY + (sX >> PRECISIONB)];
+          sX += dx;
+        }
+        destOffset += screenW;
+        srcYOffset += dy;
+      }
+      break;
+
+    case DIFFERENCE:
+      for (int y = 0; y < destH; y++) {
+        sX = srcXOffset;
+        sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
+        for (int x = 0; x < destW; x++) {
+          destPixels[destOffset + x] =
+            blend_difference(destPixels[destOffset + x],
                              srcBuffer[sY + (sX >> PRECISIONB)]);
-            sX += dx;
-          }
-          destOffset += screenW;
-          srcYOffset += dy;
+          sX += dx;
         }
-        break;
-
-      case DARKEST:
-        for (int y = 0; y < destH; y++) {
-          sX = srcXOffset;
-          sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
-          for (int x = 0; x < destW; x++) {
-            destPixels[destOffset + x] =
-              blend_darkest(destPixels[destOffset + x],
+        destOffset += screenW;
+        srcYOffset += dy;
+      }
+      break;
+
+    case EXCLUSION:
+      for (int y = 0; y < destH; y++) {
+        sX = srcXOffset;
+        sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
+        for (int x = 0; x < destW; x++) {
+          destPixels[destOffset + x] =
+            blend_exclusion(destPixels[destOffset + x],
                             srcBuffer[sY + (sX >> PRECISIONB)]);
-            sX += dx;
-          }
-          destOffset += screenW;
-          srcYOffset += dy;
-        }
-        break;
-
-      case REPLACE:
-        for (int y = 0; y < destH; y++) {
-          sX = srcXOffset;
-          sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
-          for (int x = 0; x < destW; x++) {
-            destPixels[destOffset + x] = srcBuffer[sY + (sX >> PRECISIONB)];
-            sX += dx;
-          }
-          destOffset += screenW;
-          srcYOffset += dy;
-        }
-        break;
-
-      case DIFFERENCE:
-        for (int y = 0; y < destH; y++) {
-          sX = srcXOffset;
-          sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
-          for (int x = 0; x < destW; x++) {
-            destPixels[destOffset + x] =
-              blend_difference(destPixels[destOffset + x],
-                               srcBuffer[sY + (sX >> PRECISIONB)]);
-            sX += dx;
-          }
-          destOffset += screenW;
-          srcYOffset += dy;
+          sX += dx;
         }
-        break;
-
-      case EXCLUSION:
-        for (int y = 0; y < destH; y++) {
-          sX = srcXOffset;
-          sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
-          for (int x = 0; x < destW; x++) {
-            destPixels[destOffset + x] =
-              blend_exclusion(destPixels[destOffset + x],
-                              srcBuffer[sY + (sX >> PRECISIONB)]);
-            sX += dx;
-          }
-          destOffset += screenW;
-          srcYOffset += dy;
-        }
-        break;
-
-      case MULTIPLY:
-        for (int y = 0; y < destH; y++) {
-          sX = srcXOffset;
-          sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
-          for (int x = 0; x < destW; x++) {
-            destPixels[destOffset + x] =
-              blend_multiply(destPixels[destOffset + x],
-                            srcBuffer[sY + (sX >> PRECISIONB)]);
-            sX += dx;
-          }
-          destOffset += screenW;
-          srcYOffset += dy;
+        destOffset += screenW;
+        srcYOffset += dy;
+      }
+      break;
+
+    case MULTIPLY:
+      for (int y = 0; y < destH; y++) {
+        sX = srcXOffset;
+        sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
+        for (int x = 0; x < destW; x++) {
+          destPixels[destOffset + x] =
+            blend_multiply(destPixels[destOffset + x],
+                          srcBuffer[sY + (sX >> PRECISIONB)]);
+          sX += dx;
         }
-        break;
-
-      case SCREEN:
-        for (int y = 0; y < destH; y++) {
-          sX = srcXOffset;
-          sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
-          for (int x = 0; x < destW; x++) {
-            destPixels[destOffset + x] =
-              blend_screen(destPixels[destOffset + x],
-                            srcBuffer[sY + (sX >> PRECISIONB)]);
-            sX += dx;
-          }
-          destOffset += screenW;
-          srcYOffset += dy;
+        destOffset += screenW;
+        srcYOffset += dy;
+      }
+      break;
+
+    case SCREEN:
+      for (int y = 0; y < destH; y++) {
+        sX = srcXOffset;
+        sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
+        for (int x = 0; x < destW; x++) {
+          destPixels[destOffset + x] =
+            blend_screen(destPixels[destOffset + x],
+                          srcBuffer[sY + (sX >> PRECISIONB)]);
+          sX += dx;
         }
-        break;
-
-      case OVERLAY:
-        for (int y = 0; y < destH; y++) {
-          sX = srcXOffset;
-          sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
-          for (int x = 0; x < destW; x++) {
-            destPixels[destOffset + x] =
-              blend_overlay(destPixels[destOffset + x],
-                            srcBuffer[sY + (sX >> PRECISIONB)]);
-            sX += dx;
-          }
-          destOffset += screenW;
-          srcYOffset += dy;
+        destOffset += screenW;
+        srcYOffset += dy;
+      }
+      break;
+
+    case OVERLAY:
+      for (int y = 0; y < destH; y++) {
+        sX = srcXOffset;
+        sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
+        for (int x = 0; x < destW; x++) {
+          destPixels[destOffset + x] =
+            blend_overlay(destPixels[destOffset + x],
+                          srcBuffer[sY + (sX >> PRECISIONB)]);
+          sX += dx;
         }
-        break;
-
-      case HARD_LIGHT:
-        for (int y = 0; y < destH; y++) {
-          sX = srcXOffset;
-          sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
-          for (int x = 0; x < destW; x++) {
-            destPixels[destOffset + x] =
-              blend_hard_light(destPixels[destOffset + x],
-                            srcBuffer[sY + (sX >> PRECISIONB)]);
-            sX += dx;
-          }
-          destOffset += screenW;
-          srcYOffset += dy;
+        destOffset += screenW;
+        srcYOffset += dy;
+      }
+      break;
+
+    case HARD_LIGHT:
+      for (int y = 0; y < destH; y++) {
+        sX = srcXOffset;
+        sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
+        for (int x = 0; x < destW; x++) {
+          destPixels[destOffset + x] =
+            blend_hard_light(destPixels[destOffset + x],
+                          srcBuffer[sY + (sX >> PRECISIONB)]);
+          sX += dx;
         }
-        break;
-
-      case SOFT_LIGHT:
-        for (int y = 0; y < destH; y++) {
-          sX = srcXOffset;
-          sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
-          for (int x = 0; x < destW; x++) {
-            destPixels[destOffset + x] =
-              blend_soft_light(destPixels[destOffset + x],
-                            srcBuffer[sY + (sX >> PRECISIONB)]);
-            sX += dx;
-          }
-          destOffset += screenW;
-          srcYOffset += dy;
+        destOffset += screenW;
+        srcYOffset += dy;
+      }
+      break;
+
+    case SOFT_LIGHT:
+      for (int y = 0; y < destH; y++) {
+        sX = srcXOffset;
+        sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
+        for (int x = 0; x < destW; x++) {
+          destPixels[destOffset + x] =
+            blend_soft_light(destPixels[destOffset + x],
+                          srcBuffer[sY + (sX >> PRECISIONB)]);
+          sX += dx;
         }
-        break;
-
-      // davbol - proposed 2007-01-09
-      case DODGE:
-        for (int y = 0; y < destH; y++) {
-          sX = srcXOffset;
-          sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
-          for (int x = 0; x < destW; x++) {
-            destPixels[destOffset + x] =
-              blend_dodge(destPixels[destOffset + x],
-                            srcBuffer[sY + (sX >> PRECISIONB)]);
-            sX += dx;
-          }
-          destOffset += screenW;
-          srcYOffset += dy;
+        destOffset += screenW;
+        srcYOffset += dy;
+      }
+      break;
+
+    // davbol - proposed 2007-01-09
+    case DODGE:
+      for (int y = 0; y < destH; y++) {
+        sX = srcXOffset;
+        sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
+        for (int x = 0; x < destW; x++) {
+          destPixels[destOffset + x] =
+            blend_dodge(destPixels[destOffset + x],
+                          srcBuffer[sY + (sX >> PRECISIONB)]);
+          sX += dx;
         }
-        break;
-
-      case BURN:
-        for (int y = 0; y < destH; y++) {
-          sX = srcXOffset;
-          sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
-          for (int x = 0; x < destW; x++) {
-            destPixels[destOffset + x] =
-              blend_burn(destPixels[destOffset + x],
-                            srcBuffer[sY + (sX >> PRECISIONB)]);
-            sX += dx;
-          }
-          destOffset += screenW;
-          srcYOffset += dy;
+        destOffset += screenW;
+        srcYOffset += dy;
+      }
+      break;
+
+    case BURN:
+      for (int y = 0; y < destH; y++) {
+        sX = srcXOffset;
+        sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
+        for (int x = 0; x < destW; x++) {
+          destPixels[destOffset + x] =
+            blend_burn(destPixels[destOffset + x],
+                          srcBuffer[sY + (sX >> PRECISIONB)]);
+          sX += dx;
         }
-        break;
-
+        destOffset += screenW;
+        srcYOffset += dy;
       }
+      break;
     }
   }
 
 
   private void filter_new_scanline() {
     sX = srcXOffset;
-    fracV = srcYOffset & PREC_MAXVAL;
+    int fracV = srcYOffset & PREC_MAXVAL;
     ifV = PREC_MAXVAL - fracV + 1;
     v1 = (srcYOffset >> PRECISIONB) * iw;
     v2 = min((srcYOffset >> PRECISIONB) + 1, ih1) * iw;
@@ -2306,14 +2276,18 @@ public class PImage implements PConstants, Cloneable {
 
 
   private int filter_bilinear() {
-    fracU = sX & PREC_MAXVAL;
-    ifU = PREC_MAXVAL - fracU + 1;
-    ul = (ifU * ifV) >> PRECISIONB;
-    ll = ifU - ul;
-    ur = ifV - ul;
-    lr = PREC_MAXVAL + 1 - ul - ll - ur;
-    u1 = (sX >> PRECISIONB);
-    u2 = min(u1 + 1, iw1);
+    int cUL, cLL, cUR, cLR;
+    int r, g, b, a;
+
+    // private fields
+    int fracU = sX & PREC_MAXVAL;
+    int ifU = PREC_MAXVAL - fracU + 1;
+    int ul = (ifU * ifV) >> PRECISIONB;
+    int ll = ifU - ul;
+    int ur = ifV - ul;
+    int lr = PREC_MAXVAL + 1 - ul - ll - ur;
+    int u1 = (sX >> PRECISIONB);
+    int u2 = min(u1 + 1, iw1);
 
     // get color values of the 4 neighbouring texels
     cUL = srcBuffer[v1 + u1];
@@ -2735,7 +2709,7 @@ int testFunction(int dst, int src) {
 
 
   /**
-   * Soft Light (Pegtop)
+   * Soft Light (peg top)
    * O = (1 - D) * MULTIPLY(D, S) + D * SCREEN(D, S)
    * O = (1 - D) * DS + D * (1 - (1 - D)(1 - S))
    * O = 2DS + DD - 2DDS
@@ -2823,18 +2797,17 @@ int testFunction(int dst, int src) {
   }
 
 
+
   //////////////////////////////////////////////////////////////
 
   // FILE I/O
 
 
-  protected boolean saveImpl(String filename) {
-    return false;
-  }
-
-
   static public PImage loadTIFF(InputStream input) {  // ignore
-    byte tiff[] = PApplet.loadBytes(input);
+    byte[] tiff = PApplet.loadBytes(input);
+    if (tiff == null) {
+      return null;
+    }
 
     if ((tiff[42] != tiff[102]) ||  // width/height in both places
         (tiff[43] != tiff[103])) {
@@ -2883,8 +2856,8 @@ int testFunction(int dst, int src) {
   }
 
   protected boolean saveTIFF(OutputStream output) {
-    // shutting off the warning, people can figure this out themselves
     /*
+    // shutting off this warning, people can figure this out themselves
     if (format != RGB) {
       System.err.println("Warning: only RGB information is saved with " +
                          ".tif files. Use .tga or .png for ARGB images and others.");
@@ -2917,6 +2890,7 @@ int testFunction(int dst, int src) {
       return true;
 
     } catch (IOException e) {
+      e.printStackTrace();
     }
     return false;
   }
@@ -3124,7 +3098,7 @@ int testFunction(int dst, int src) {
   /**
    * Creates a Targa32 formatted byte sequence of specified
    * pixel buffer using RLE compression.
-   * <p>
+   * </p>
    * Also figured out how to avoid parsing the image upside-down
    * (there's a header flag to set the image origin to top-left)
    * </p>
@@ -3135,33 +3109,31 @@ int testFunction(int dst, int src) {
    * <LI><TT>ARGB</TT> &rarr; 32 bits
    * </UL>
    * All versions are RLE compressed.
-   *
+   * </p>
    * Contributed by toxi 8-10 May 2005, based on this RLE
    * <A HREF="http://www.wotsit.org/download.asp?f=tga">specification</A>
    */
   protected boolean saveTGA(OutputStream output) {
     byte[] header = new byte[18];
 
-    switch (format) {
-      case ALPHA:
-        // save ALPHA images as 8bit grayscale
-        header[2] = 0x0B;
-        header[16] = 0x08;
-        header[17] = 0x28;
-        break;
-      case RGB:
-        header[2] = 0x0A;
-        header[16] = 24;
-        header[17] = 0x20;
-        break;
-      case ARGB:
-        header[2] = 0x0A;
-        header[16] = 32;
-        header[17] = 0x28;
-        break;
-      default:
-        throw new RuntimeException("Image format not recognized inside save()");
-    }
+     if (format == ALPHA) {  // save ALPHA images as 8bit grayscale
+       header[2] = 0x0B;
+       header[16] = 0x08;
+       header[17] = 0x28;
+
+     } else if (format == RGB) {
+       header[2] = 0x0A;
+       header[16] = 24;
+       header[17] = 0x20;
+
+     } else if (format == ARGB) {
+       header[2] = 0x0A;
+       header[16] = 32;
+       header[17] = 0x28;
+
+     } else {
+       throw new RuntimeException("Image format not recognized inside save()");
+     }
      // set image dimensions lo-hi byte order
      header[12] = (byte) (pixelWidth & 0xff);
      header[13] = (byte) (pixelWidth >> 8);
@@ -3271,13 +3243,13 @@ int testFunction(int dst, int src) {
        return true;
 
      } catch (IOException e) {
+       e.printStackTrace();
        return false;
      }
   }
 
 
   /**
-   * ( begin auto-generated from PImage_save.xml )
    *
    * Saves the image into a file. Append a file extension to the name of
    * the file, to indicate the file format to be used: either TIFF (.tif),
@@ -3285,13 +3257,12 @@ int testFunction(int dst, int src) {
    * in the filename, the image will save in TIFF format and .tif will be
    * added to the name.  These files are saved to the sketch's folder, which
    * may be opened by selecting "Show sketch folder" from the "Sketch" menu.
-   * To save an image created within the code, rather
+   * <br /><br />To save an image created within the code, rather
    * than through loading, it's necessary to make the image with the
    * <b>createImage()</b> function so it is aware of the location of the
    * program and can therefore save the file to the right place. See the
    * <b>createImage()</b> reference for more information.
    *
-   * ( end auto-generated )
    * <h3>Advanced</h3>
    * Save this image to disk.
    * <p>
@@ -3318,60 +3289,79 @@ int testFunction(int dst, int src) {
    * file with no error.
    *
    * @webref pimage:method
-   * @brief Saves the image to a TIFF, TARGA, PNG, or JPEG file
+   * @webBrief Saves the image to a TIFF, TARGA, PNG, or JPEG file.
    * @usage application
    * @param filename a sequence of letters and numbers
    */
-   public boolean save(String filename) {  // ignore
-     boolean success = false;
+  public boolean save(String filename) {  // ignore
+    boolean success;
 
-     if (parent != null) {
-       // use savePath(), so that the intermediate directories are created
-       filename = parent.savePath(filename);
+    if (parent != null) {
+      // use savePath(), so that the intermediate directories are created
+      filename = parent.savePath(filename);
 
-     } else {
-       File file = new File(filename);
-       if (file.isAbsolute()) {
-         // make sure that the intermediate folders have been created
-         PApplet.createPath(file);
-       } else {
-         String msg =
-           "PImage.save() requires an absolute path. " +
-           "Use createImage(), or pass savePath() to save().";
-         PGraphics.showException(msg);
-       }
-     }
+    } else {
+      File file = new File(filename);
+      if (file.isAbsolute()) {
+        // make sure that the intermediate folders have been created
+        PApplet.createPath(file);
+      } else {
+        String msg =
+            "PImage.save() requires an absolute path. " +
+                "Use createImage(), or pass savePath() to save().";
+        PGraphics.showException(msg);
+      }
+    }
 
-     // Make sure the pixel data is ready to go
-     loadPixels();
+    // Make sure the pixel data is ready to go
+    loadPixels();
 
-     try {
-       OutputStream os = null;
+    try {
+      final String lower = filename.toLowerCase();
 
-       if (saveImpl(filename)) {
-         return true;
-       }
+      if (saveImpl(filename)) {
+        return true;
+      }
 
-       if (filename.toLowerCase().endsWith(".tga")) {
-         os = new BufferedOutputStream(new FileOutputStream(filename), 32768);
-         success = saveTGA(os); //, pixels, width, height, format);
+      if (lower.endsWith(".tga")) {
+        OutputStream os = new BufferedOutputStream(new FileOutputStream(filename), 32768);
+        success = saveTGA(os); //, pixels, width, height, format);
+        os.close();
+
+      } else {  // fall-through case is TIFF
+        // add a default extension and save uncompressed
+        // TODO this is the only place in the api that we mess w/ file names,
+        // and while arguably useful, seems like a weird precedent [fry 200816]
+        if (!lower.endsWith(".tif") && !lower.endsWith(".tiff")) {
+          filename += ".tif";
+        }
+        OutputStream os = new BufferedOutputStream(new FileOutputStream(filename), 32768);
+        success = saveTIFF(os); //, pixels, width, height);
+        os.close();
+      }
 
-       } else {
-         if (!filename.toLowerCase().endsWith(".tif") &&
-             !filename.toLowerCase().endsWith(".tiff")) {
-           // if no .tif extension, add it..
-           filename += ".tif";
-         }
-         os = new BufferedOutputStream(new FileOutputStream(filename), 32768);
-         success = saveTIFF(os); //, pixels, width, height);
-       }
-       os.flush();
-       os.close();
+    } catch (IOException e) {
+      System.err.println("Error while saving image.");
+      e.printStackTrace();
+      success = false;
+    }
+    return success;
+  }
 
-     } catch (IOException e) {
-       System.err.println("Error while saving image.");
-       success = false;
-     }
-     return success;
-   }
+
+  /**
+   * Override this in subclasses to intercept save calls for other formats
+   * or higher-performance implementations. When reaching this code, pixels
+   * must be loaded and that path should be absolute.
+   *
+   * @param path must be a full path (not relative or simply a filename)
+   */
+  protected boolean saveImpl(String path) {
+    // TODO Imperfect/temporary solution for alpha 2.
+    // https://github.com/processing/processing4/wiki/Exorcising-AWT
+    if (!PApplet.disableAWT) {
+      return ShimAWT.saveImage(this, path);
+    }
+    return false;
+  }
 }