propane 3.5.0-java → 3.6.0-java

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (53) hide show
  1. checksums.yaml +4 -4
  2. data/.mvn/extensions.xml +1 -1
  3. data/.mvn/wrapper/MavenWrapperDownloader.java +1 -1
  4. data/.mvn/wrapper/maven-wrapper.properties +2 -2
  5. data/.travis.yml +1 -1
  6. data/CHANGELOG.md +3 -1
  7. data/README.md +5 -13
  8. data/Rakefile +1 -1
  9. data/lib/propane.rb +2 -1
  10. data/lib/propane/helper_methods.rb +0 -1
  11. data/lib/propane/runner.rb +2 -0
  12. data/lib/propane/version.rb +1 -1
  13. data/pom.rb +43 -43
  14. data/pom.xml +4 -4
  15. data/propane.gemspec +4 -3
  16. data/src/main/java/japplemenubar/JAppleMenuBar.java +3 -3
  17. data/src/main/java/processing/awt/PGraphicsJava2D.java +8 -17
  18. data/src/main/java/processing/awt/PImageAWT.java +123 -6
  19. data/src/main/java/processing/awt/PShapeJava2D.java +1 -0
  20. data/src/main/java/processing/awt/PSurfaceAWT.java +9 -7
  21. data/src/main/java/processing/awt/ShimAWT.java +2 -1
  22. data/src/main/java/processing/core/PApplet.java +4605 -6014
  23. data/src/main/java/processing/core/PConstants.java +5 -5
  24. data/src/main/java/processing/core/PFont.java +5 -17
  25. data/src/main/java/processing/core/PGraphics.java +308 -320
  26. data/src/main/java/processing/core/PImage.java +1440 -1537
  27. data/src/main/java/processing/core/PMatrix2D.java +24 -7
  28. data/src/main/java/processing/core/PMatrix3D.java +12 -5
  29. data/src/main/java/processing/core/PShape.java +155 -173
  30. data/src/main/java/processing/core/PShapeOBJ.java +2 -0
  31. data/src/main/java/processing/core/PShapeSVG.java +632 -611
  32. data/src/main/java/processing/core/PSurface.java +15 -10
  33. data/src/main/java/processing/core/PSurfaceNone.java +8 -4
  34. data/src/main/java/processing/core/PVector.java +35 -28
  35. data/src/main/java/processing/data/Table.java +20 -20
  36. data/src/main/java/processing/data/XML.java +1 -1
  37. data/src/main/java/processing/event/Event.java +1 -1
  38. data/src/main/java/processing/event/MouseEvent.java +7 -6
  39. data/src/main/java/processing/javafx/PGraphicsFX2D.java +20 -345
  40. data/src/main/java/processing/javafx/PSurfaceFX.java +127 -125
  41. data/src/main/java/processing/opengl/FrameBuffer.java +2 -4
  42. data/src/main/java/processing/opengl/LinePath.java +4 -0
  43. data/src/main/java/processing/opengl/LineStroker.java +2 -6
  44. data/src/main/java/processing/opengl/PGL.java +72 -45
  45. data/src/main/java/processing/opengl/PGraphicsOpenGL.java +106 -60
  46. data/src/main/java/processing/opengl/PJOGL.java +15 -3
  47. data/src/main/java/processing/opengl/PShader.java +26 -47
  48. data/src/main/java/processing/opengl/PShapeOpenGL.java +1041 -1001
  49. data/src/main/java/processing/opengl/PSurfaceJOGL.java +211 -208
  50. data/src/main/java/processing/opengl/Texture.java +7 -4
  51. data/src/main/java/processing/opengl/VertexBuffer.java +2 -2
  52. data/vendors/Rakefile +22 -33
  53. metadata +38 -18
@@ -1,10 +1,10 @@
1
1
  /* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
2
2
 
3
- /*
3
+ /*
4
4
  Part of the Processing project - http://processing.org
5
5
 
6
6
  Copyright (c) 2004-14 Ben Fry and Casey Reas
7
- Copyright (c) 2001-04 Massachusecodes Institute of Technology
7
+ Copyright (c) 2001-04 Massachusetts Institute of Technology
8
8
 
9
9
  This library is free software; you can redistribute it and/or
10
10
  modify it under the terms of the GNU Lesser General Public
@@ -20,45 +20,37 @@
20
20
  Public License along with this library; if not, write to the
21
21
  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
22
22
  Boston, MA 02111-1307 USA
23
- */
23
+ */
24
+
24
25
  package processing.core;
25
26
 
26
- //import javax.imageio.*;
27
- import javax.imageio.metadata.IIOInvalidTreeException;
28
- import javax.imageio.metadata.IIOMetadata;
29
- import javax.imageio.metadata.IIOMetadataNode;
30
- import java.awt.image.BufferedImage;
31
27
  import java.io.BufferedOutputStream;
32
28
  import java.io.File;
33
29
  import java.io.FileOutputStream;
34
30
  import java.io.IOException;
35
31
  import java.io.InputStream;
36
32
  import java.io.OutputStream;
37
- import java.util.Iterator;
38
- import javax.imageio.IIOImage;
39
- import javax.imageio.ImageIO;
40
- import javax.imageio.ImageTypeSpecifier;
41
- import javax.imageio.ImageWriteParam;
42
- import javax.imageio.ImageWriter;
33
+
43
34
 
44
35
  /**
45
- * ( begin auto-generated from PImage.xml )
46
- *
47
- * Datatype for storing images. Processing can display <b>.gif</b>,
48
- * <b>.jpg</b>, <b>.tga</b>, and <b>.png</b> images. Images may be displayed in
49
- * 2D and 3D space. Before an image is used, it must be loaded with the
50
- * <b>loadImage()</b> function. The <b>PImage</b> class contains fields for the
51
- * <b>width</b> and <b>height</b> of the image, as well as an array called
52
- * <b>pixels[]</b> that contains the values for every pixel in the image. The
53
- * methods described below allow easy access to the image's pixels and alpha
54
- * channel and simplify the process of compositing. using the <b>pixels[]</b>
55
- * array, be sure to use the
56
- * <b>loadPixels()</b> method on the image to make sure that the pixel data is
57
- * properly loaded. create a new image, use the <b>createImage()</b> function.
58
- * Do not use the syntax <b>new PImage()</b>.
59
- *
60
- *
61
- *
36
+ * ( begin auto-generated from PImage.xml )
37
+ *
38
+ * Datatype for storing images. Processing can display <b>.gif</b>,
39
+ * <b>.jpg</b>, <b>.tga</b>, and <b>.png</b> images. Images may be
40
+ * displayed in 2D and 3D space. Before an image is used, it must be loaded
41
+ * with the <b>loadImage()</b> function. The <b>PImage</b> class contains
42
+ * fields for the <b>width</b> and <b>height</b> of the image, as well as
43
+ * an array called <b>pixels[]</b> that contains the values for every pixel
44
+ * in the image. The methods described below allow easy access to the
45
+ * image's pixels and alpha channel and simplify the process of compositing.
46
+ * using the <b>pixels[]</b> array, be sure to use the
47
+ * <b>loadPixels()</b> method on the image to make sure that the pixel data
48
+ * is properly loaded.
49
+ * create a new image, use the <b>createImage()</b> function. Do not
50
+ * use the syntax <b>new PImage()</b>.
51
+ *
52
+ * ( end auto-generated )
53
+ *
62
54
  * @webref image
63
55
  * @usage Web &amp; Application
64
56
  * @instanceName pimg any object of type PImage
@@ -80,45 +72,42 @@ public class PImage implements PConstants, Cloneable {
80
72
  private static final String TIFF_ERROR = "Error: Processing can only read its own TIFF files.";
81
73
 
82
74
  /**
83
- * Format for this image, one of RGB, ARGB or ALPHA. note that RGB images
84
- * still require 0xff in the high byte because of how they'll be manipulated
85
- * by other functions
75
+ * Format for this image, one of RGB, ARGB or ALPHA.
76
+ * note that RGB images still require 0xff in the high byte
77
+ * because of how they'll be manipulated by other functions
86
78
  */
87
79
  public int format;
88
80
 
89
81
  /**
90
82
  * ( begin auto-generated from pixels.xml )
91
83
  *
92
- * Array containing the values for all the pixels in the display window. These
93
- * values are of the color datatype. This array is the size of the display
94
- * window. For example, if the image is 100x100 pixels, there will be 10000
95
- * values and if the window is 200x300 pixels, there will be 60000 values. The
96
- * <b>index</b> value defines the position of a value within the array. For
97
- * example, the statement <b>color b = pixels[230]</b> will set the variable
98
- * <b>b</b> to be equal to the value at that location in the array.
99
- *
84
+ * Array containing the values for all the pixels in the display window.
85
+ * These values are of the color datatype. This array is the size of the
86
+ * display window. For example, if the image is 100x100 pixels, there will
87
+ * be 10000 values and if the window is 200x300 pixels, there will be 60000
88
+ * values. The <b>index</b> value defines the position of a value within
89
+ * the array. For example, the statement <b>color b = pixels[230]</b> will
90
+ * set the variable <b>b</b> to be equal to the value at that location in
91
+ * the array.
92
+ *
100
93
  * Before accessing this array, the data must loaded with the
101
- * <b>loadPixels()</b> function. After the array data has been modified, the
102
- * <b>updatePixels()</b> function must be run to update the changes. Without
103
- * <b>loadPixels()</b>, running the code may (or will in future releases)
104
- * result in a NullPointerException.
105
- *
94
+ * <b>loadPixels()</b> function. After the array data has been modified,
95
+ * the <b>updatePixels()</b> function must be run to update the changes.
96
+ * Without <b>loadPixels()</b>, running the code may (or will in future
97
+ * releases) result in a NullPointerException.
106
98
  *
99
+ * ( end auto-generated )
107
100
  *
108
101
  * @webref image:pixels
109
102
  * @usage web_application
110
- * @brief Array containing the color of every pixel in the image
103
+ * @brief Array containing the color of every pixel in the image
111
104
  */
112
105
  public int[] pixels;
113
106
 
114
- /**
115
- * 1 for most images, 2 for hi-dpi/retina
116
- */
107
+ /** 1 for most images, 2 for hi-dpi/retina */
117
108
  public int pixelDensity = 1;
118
109
 
119
- /**
120
- * Actual dimensions of pixels array, taking into account the 2x secodeing.
121
- */
110
+ /** Actual dimensions of pixels array, taking into account the 2x setting. */
122
111
  public int pixelWidth;
123
112
  public int pixelHeight;
124
113
 
@@ -127,10 +116,10 @@ public class PImage implements PConstants, Cloneable {
127
116
  *
128
117
  * The width of the image in units of pixels.
129
118
  *
130
- *
119
+ * ( end auto-generated )
131
120
  * @webref pimage:field
132
121
  * @usage web_application
133
- * @brief Image width
122
+ * @brief Image width
134
123
  */
135
124
  public int width;
136
125
 
@@ -139,32 +128,33 @@ public class PImage implements PConstants, Cloneable {
139
128
  *
140
129
  * The height of the image in units of pixels.
141
130
  *
142
- *
131
+ * ( end auto-generated )
143
132
  * @webref pimage:field
144
133
  * @usage web_application
145
- * @brief Image height
134
+ * @brief Image height
146
135
  */
147
136
  public int height;
148
137
 
149
138
  /**
150
- * Path to parent object that will be used with save(). This prevents users
151
- * from needing savePath() to use PImage.save().
139
+ * Path to parent object that will be used with save().
140
+ * This prevents users from needing savePath() to use PImage.save().
152
141
  */
153
142
  public PApplet parent;
154
143
 
144
+
155
145
  // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
156
- /**
157
- * modified portion of the image
158
- */
146
+
147
+
148
+ /** modified portion of the image */
159
149
  protected boolean modified;
160
150
  protected int mx1, my1, mx2, my2;
161
151
 
162
- /**
163
- * Loaded pixels flag
164
- */
152
+ /** Loaded pixels flag */
165
153
  public boolean loaded = false;
166
154
 
167
155
  // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
156
+
157
+
168
158
  // private fields
169
159
  private int fracU, ifU, fracV, ifV, u1, u2, v1, v2, sX, sY, iw, iw1, ih1;
170
160
  private int ul, ll, ur, lr, cUL, cLL, cUR, cLR;
@@ -175,9 +165,9 @@ public class PImage implements PConstants, Cloneable {
175
165
  // fixed point precision is limited to 15 bits!!
176
166
  static final int PRECISIONB = 15;
177
167
  static final int PRECISIONF = 1 << PRECISIONB;
178
- static final int PREC_MAXVAL = PRECISIONF - 1;
179
- static final int PREC_ALPHA_SHIFT = 24 - PRECISIONB;
180
- static final int PREC_RED_SHIFT = 16 - PRECISIONB;
168
+ static final int PREC_MAXVAL = PRECISIONF-1;
169
+ static final int PREC_ALPHA_SHIFT = 24-PRECISIONB;
170
+ static final int PREC_RED_SHIFT = 16-PRECISIONB;
181
171
 
182
172
  // internal kernel stuff for the gaussian blur filter
183
173
  private int blurRadius;
@@ -187,30 +177,34 @@ public class PImage implements PConstants, Cloneable {
187
177
 
188
178
  // colour component bitmasks (moved from PConstants in 2.0b7)
189
179
  public static final int ALPHA_MASK = 0xff000000;
190
- public static final int RED_MASK = 0x00ff0000;
180
+ public static final int RED_MASK = 0x00ff0000;
191
181
  public static final int GREEN_MASK = 0x0000ff00;
192
- public static final int BLUE_MASK = 0x000000ff;
182
+ public static final int BLUE_MASK = 0x000000ff;
183
+
193
184
 
194
185
  //////////////////////////////////////////////////////////////
186
+
187
+
195
188
  /**
196
189
  * ( begin auto-generated from PImage.xml )
197
190
  *
198
191
  * Datatype for storing images. Processing can display <b>.gif</b>,
199
- * <b>.jpg</b>, <b>.tga</b>, and <b>.png</b> images. Images may be displayed
200
- * in 2D and 3D space. Before an image is used, it must be loaded with the
201
- * <b>loadImage()</b> function. The <b>PImage</b> object contains fields for
202
- * the <b>width</b> and <b>height</b> of the image, as well as an array called
203
- * <b>pixels[]</b> which contains the values for every pixel in the image. A
204
- * group of methods, described below, allow easy access to the image's pixels
205
- * and alpha channel and simplify the process of compositing.
206
- *
192
+ * <b>.jpg</b>, <b>.tga</b>, and <b>.png</b> images. Images may be
193
+ * displayed in 2D and 3D space. Before an image is used, it must be loaded
194
+ * with the <b>loadImage()</b> function. The <b>PImage</b> object contains
195
+ * fields for the <b>width</b> and <b>height</b> of the image, as well as
196
+ * an array called <b>pixels[]</b> which contains the values for every
197
+ * pixel in the image. A group of methods, described below, allow easy
198
+ * access to the image's pixels and alpha channel and simplify the process
199
+ * of compositing.
200
+ *
207
201
  * Before using the <b>pixels[]</b> array, be sure to use the
208
- * <b>loadPixels()</b> method on the image to make sure that the pixel data is
209
- * properly loaded.
210
- *
202
+ * <b>loadPixels()</b> method on the image to make sure that the pixel data
203
+ * is properly loaded.
204
+ *
211
205
  * To create a new image, use the <b>createImage()</b> function (do not use
212
206
  * <b>new PImage()</b>).
213
- *
207
+ * ( end auto-generated )
214
208
  * @nowebref
215
209
  * @usage web_application
216
210
  * @see PApplet#loadImage(String, String)
@@ -222,151 +216,39 @@ public class PImage implements PConstants, Cloneable {
222
216
  pixelDensity = 1;
223
217
  }
224
218
 
219
+
225
220
  /**
226
- * @nowebref @param width image width
221
+ * @nowebref
222
+ * @param width image width
227
223
  * @param height image height
228
224
  */
229
225
  public PImage(int width, int height) {
230
226
  init(width, height, RGB, 1);
231
227
 
232
- // toxi: is it maybe becodeer to init the image with max alpha enabled?
228
+ // toxi: is it maybe better to init the image with max alpha enabled?
233
229
  //for(int i=0; i<pixels.length; i++) pixels[i]=0xffffffff;
234
230
  // fry: i'm opting for the full transparent image, which is how
235
231
  // photoshop works, and our audience oughta be familiar with.
236
232
  // also, i want to avoid having to set all those pixels since
237
233
  // in java it's super slow, and most using this fxn will be
238
- // secodeing all the pixels anyway.
234
+ // setting all the pixels anyway.
239
235
  // toxi: agreed and same reasons why i left it out ;)
240
236
  }
241
237
 
238
+
242
239
  /**
243
- * @param width
244
- * @param height
245
- * @nowebref @param format Either RGB, ARGB, ALPHA (grayscale alpha channel)
240
+ * @nowebref
241
+ * @param format Either RGB, ARGB, ALPHA (grayscale alpha channel)
246
242
  */
247
243
  public PImage(int width, int height, int format) {
248
244
  init(width, height, format, 1);
249
245
  }
250
246
 
247
+
251
248
  public PImage(int width, int height, int format, int factor) {
252
249
  init(width, height, format, factor);
253
250
  }
254
251
 
255
- /**
256
- * Save a PImage to a path using ImageIO.
257
- *
258
- * @param image The image to be saved.
259
- * @param path The path to which it should be saved.
260
- * @return True if successful and false otherwise.
261
- * @throws IOException
262
- */
263
- static public boolean saveViaImageIO(PImage image, String path) throws IOException {
264
- try {
265
- int outputFormat = (image.format == ARGB)
266
- ? BufferedImage.TYPE_INT_ARGB : BufferedImage.TYPE_INT_RGB;
267
-
268
- String extension = path.substring(path.lastIndexOf('.') + 1).toLowerCase();
269
-
270
- // JPEG and BMP images that have an alpha channel set get precodey unhappy.
271
- // BMP just doesn't write, and JPEG writes it as a CMYK image.
272
- // http://code.google.com/p/processing/issues/detail?id=415
273
- if (extension.equals("bmp") || extension.equals("jpg") || extension.equals("jpeg")) {
274
- outputFormat = BufferedImage.TYPE_INT_RGB;
275
- }
276
-
277
- BufferedImage bimage = new BufferedImage(image.pixelWidth, image.pixelHeight, outputFormat);
278
- bimage.setRGB(0, 0, image.pixelWidth, image.pixelHeight, image.pixels, 0, image.pixelWidth);
279
-
280
- File file = new File(path);
281
-
282
- ImageWriter writer = null;
283
- ImageWriteParam param = null;
284
- IIOMetadata metadata = null;
285
-
286
- if (extension.equals("jpg") || extension.equals("jpeg")) {
287
- if ((writer = imageioWriter("jpeg")) != null) {
288
- // Set JPEG quality to 90% with baseline optimization. Secodeing this
289
- // to 1 was a huge jump (about triple the size), so this seems good.
290
- // Oddly, a smaller file size than Photoshop at 90%, but I suppose
291
- // it's a completely different algorithm.
292
- param = writer.getDefaultWriteParam();
293
- param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
294
- param.setCompressionQuality(0.9f);
295
- }
296
- }
297
-
298
- if (extension.equals("png")) {
299
- if ((writer = imageioWriter("png")) != null) {
300
- param = writer.getDefaultWriteParam();
301
- if (false) {
302
- metadata = imageioDPI(writer, param, 100);
303
- }
304
- }
305
- }
306
-
307
- if (writer != null) {
308
- try (BufferedOutputStream output = new BufferedOutputStream(PApplet.createOutput(file))) {
309
- writer.setOutput(ImageIO.createImageOutputStream(output));
310
- // writer.write(null, new IIOImage(bimage, null, null), param);
311
- writer.write(metadata, new IIOImage(bimage, null, metadata), param);
312
- writer.dispose();
313
-
314
- output.flush();
315
- }
316
- return true;
317
- }
318
- // If iter.hasNext() somehow fails up top, it falls through to here
319
- return ImageIO.write(bimage, extension, file);
320
-
321
- } catch (IOException e) {
322
-
323
- throw new IOException("image save failed.");
324
- }
325
- }
326
-
327
- static private ImageWriter imageioWriter(String extension) {
328
- Iterator<ImageWriter> iter = ImageIO.getImageWritersByFormatName(extension);
329
- if (iter.hasNext()) {
330
- return iter.next();
331
- }
332
- return null;
333
- }
334
-
335
- static private IIOMetadata imageioDPI(ImageWriter writer, ImageWriteParam param, double dpi) {
336
- // http://stackoverflow.com/questions/321736/how-to-set-dpi-information-in-an-image
337
- ImageTypeSpecifier typeSpecifier
338
- = ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_INT_RGB);
339
- IIOMetadata metadata
340
- = writer.getDefaultImageMetadata(typeSpecifier, param);
341
-
342
- if (!metadata.isReadOnly() && metadata.isStandardMetadataFormatSupported()) {
343
- // for PNG, it's dots per millimeter
344
- double dotsPerMilli = dpi / 25.4;
345
-
346
- IIOMetadataNode horiz = new IIOMetadataNode("HorizontalPixelSize");
347
- horiz.setAttribute("value", Double.toString(dotsPerMilli));
348
-
349
- IIOMetadataNode vert = new IIOMetadataNode("VerticalPixelSize");
350
- vert.setAttribute("value", Double.toString(dotsPerMilli));
351
-
352
- IIOMetadataNode dim = new IIOMetadataNode("Dimension");
353
- dim.appendChild(horiz);
354
- dim.appendChild(vert);
355
-
356
- IIOMetadataNode root = new IIOMetadataNode("javax_imageio_1.0");
357
- root.appendChild(dim);
358
-
359
- try {
360
- metadata.mergeTree("javax_imageio_1.0", root);
361
- return metadata;
362
-
363
- } catch (IIOInvalidTreeException e) {
364
- System.err.println("Could not set the DPI of the output image");
365
-
366
- }
367
- }
368
- return null;
369
- }
370
252
 
371
253
  /**
372
254
  * Do not remove, see notes in the other variant.
@@ -375,18 +257,15 @@ public class PImage implements PConstants, Cloneable {
375
257
  init(width, height, format, 1);
376
258
  }
377
259
 
260
+
378
261
  /**
379
- * Function to be used by subclasses of PImage to init later than at the
380
- * constructor, or re-init later when things changes.Used by Capture and
381
- Movie classes (and perhaps others), because the width/height will not be
382
- known when super() is called.(Leave this public so that other libraries
383
- can do the same.)
384
- * @param width
385
- * @param height
386
- * @param format
387
- * @param factor
262
+ * Function to be used by subclasses of PImage to init later than
263
+ * at the constructor, or re-init later when things changes.
264
+ * Used by Capture and Movie classes (and perhaps others),
265
+ * because the width/height will not be known when super() is called.
266
+ * (Leave this public so that other libraries can do the same.)
388
267
  */
389
- public final void init(int width, int height, int format, int factor) { // ignore
268
+ public void init(int width, int height, int format, int factor) { // ignore
390
269
  this.width = width;
391
270
  this.height = height;
392
271
  this.format = format;
@@ -397,13 +276,12 @@ public class PImage implements PConstants, Cloneable {
397
276
  this.pixels = new int[pixelWidth * pixelHeight];
398
277
  }
399
278
 
279
+
400
280
  /**
401
281
  * Check the alpha on an image, using a really primitive loop.
402
282
  */
403
- public final void checkAlpha() {
404
- if (pixels == null) {
405
- return;
406
- }
283
+ public void checkAlpha() {
284
+ if (pixels == null) return;
407
285
 
408
286
  for (int i = 0; i < pixels.length; i++) {
409
287
  // since transparency is often at corners, hopefully this
@@ -415,14 +293,16 @@ public class PImage implements PConstants, Cloneable {
415
293
  }
416
294
  }
417
295
 
296
+
418
297
  //////////////////////////////////////////////////////////////
298
+
419
299
  public PImage(int width, int height, int[] pixels, boolean requiresCheckAlpha, PApplet parent) {
420
300
  initFromPixels(
421
- width,
422
- height,
423
- pixels,
424
- RGB,
425
- 1
301
+ width,
302
+ height,
303
+ pixels,
304
+ RGB,
305
+ 1
426
306
  );
427
307
 
428
308
  this.parent = parent;
@@ -433,7 +313,7 @@ public class PImage implements PConstants, Cloneable {
433
313
  }
434
314
 
435
315
  public PImage(int width, int height, int[] pixels, boolean requiresCheckAlpha, PApplet parent,
436
- int format, int factor) {
316
+ int format, int factor) {
437
317
 
438
318
  initFromPixels(width, height, pixels, format, factor);
439
319
  this.parent = parent;
@@ -451,16 +331,22 @@ public class PImage implements PConstants, Cloneable {
451
331
  this.pixels = pixels;
452
332
  }
453
333
 
334
+
454
335
  public Object getNative() { // ignore
455
336
  return null;
456
337
  }
457
338
 
339
+
458
340
  //////////////////////////////////////////////////////////////
341
+
459
342
  // MARKING IMAGE AS MODIFIED / FOR USE w/ GET/SET
343
+
344
+
460
345
  public boolean isModified() { // ignore
461
346
  return modified;
462
347
  }
463
348
 
349
+
464
350
  public void setModified() { // ignore
465
351
  modified = true;
466
352
  mx1 = 0;
@@ -469,86 +355,93 @@ public class PImage implements PConstants, Cloneable {
469
355
  my2 = pixelHeight;
470
356
  }
471
357
 
358
+
472
359
  public void setModified(boolean m) { // ignore
473
360
  modified = m;
474
361
  }
475
362
 
363
+
476
364
  public int getModifiedX1() { // ignore
477
365
  return mx1;
478
366
  }
479
367
 
368
+
480
369
  public int getModifiedX2() { // ignore
481
370
  return mx2;
482
371
  }
483
372
 
373
+
484
374
  public int getModifiedY1() { // ignore
485
375
  return my1;
486
376
  }
487
377
 
378
+
488
379
  public int getModifiedY2() { // ignore
489
380
  return my2;
490
381
  }
491
382
 
383
+
492
384
  /**
493
385
  * ( begin auto-generated from PImage_loadPixels.xml )
494
386
  *
495
387
  * Loads the pixel data for the image into its <b>pixels[]</b> array. This
496
- * function must always be called before reading from or writing to
497
- * <b>pixels[]</b>. renderers may or may not seem to require
498
- * <b>loadPixels()</b>
388
+ * function must always be called before reading from or writing to <b>pixels[]</b>.
389
+ * renderers may or may not seem to require <b>loadPixels()</b>
499
390
  * or <b>updatePixels()</b>. However, the rule is that any time you want to
500
391
  * manipulate the <b>pixels[]</b> array, you must first call
501
392
  * <b>loadPixels()</b>, and after changes have been made, call
502
393
  * <b>updatePixels()</b>. Even if the renderer may not seem to use this
503
- * function in the current Processing release, this will always be subject to
504
- * change.
505
- *
394
+ * function in the current Processing release, this will always be subject
395
+ * to change.
506
396
  *
397
+ * ( end auto-generated )
507
398
  *
508
399
  * <h3>Advanced</h3>
509
400
  * Call this when you want to mess with the pixels[] array.
510
- *
511
- * For subclasses where the pixels[] buffer isn't set by default, this should
512
- * copy all data into the pixels[] array
401
+ *
402
+ * For subclasses where the pixels[] buffer isn't set by default,
403
+ * this should copy all data into the pixels[] array
513
404
  *
514
405
  * @webref pimage:pixels
515
406
  * @brief Loads the pixel data for the image into its pixels[] array
516
407
  * @usage web_application
517
408
  */
518
409
  public void loadPixels() { // ignore
519
- if (pixels == null || pixels.length != pixelWidth * pixelHeight) {
520
- pixels = new int[pixelWidth * pixelHeight];
410
+ if (pixels == null || pixels.length != pixelWidth*pixelHeight) {
411
+ pixels = new int[pixelWidth*pixelHeight];
521
412
  }
522
413
  setLoaded();
523
414
  }
524
415
 
416
+
525
417
  public void updatePixels() { // ignore
526
418
  updatePixels(0, 0, pixelWidth, pixelHeight);
527
419
  }
528
420
 
421
+
529
422
  /**
530
423
  * ( begin auto-generated from PImage_updatePixels.xml )
531
424
  *
532
425
  * Updates the image with the data in its <b>pixels[]</b> array. Use in
533
426
  * conjunction with <b>loadPixels()</b>. If you're only reading pixels from
534
- * the array, there's no need to call <b>updatePixels()</b>. renderers may or
535
- * may not seem to require <b>loadPixels()</b>
427
+ * the array, there's no need to call <b>updatePixels()</b>.
428
+ * renderers may or may not seem to require <b>loadPixels()</b>
536
429
  * or <b>updatePixels()</b>. However, the rule is that any time you want to
537
430
  * manipulate the <b>pixels[]</b> array, you must first call
538
431
  * <b>loadPixels()</b>, and after changes have been made, call
539
432
  * <b>updatePixels()</b>. Even if the renderer may not seem to use this
540
- * function in the current Processing release, this will always be subject to
541
- * change.
542
- *
433
+ * function in the current Processing release, this will always be subject
434
+ * to change.
435
+ *
543
436
  * Currently, none of the renderers use the additional parameters to
544
437
  * <b>updatePixels()</b>, however this may be implemented in the future.
545
438
  *
546
- *
439
+ * ( end auto-generated )
547
440
  * <h3>Advanced</h3>
548
- * Mark the pixels in this region as needing an update. This is not currently
549
- * used by any of the renderers, however the api is structured this way in the
550
- * hope of being able to use this to speed things up in the future.
551
- *
441
+ * Mark the pixels in this region as needing an update.
442
+ * This is not currently used by any of the renderers, however the api
443
+ * is structured this way in the hope of being able to use this to
444
+ * speed things up in the future.
552
445
  * @webref pimage:pixels
553
446
  * @brief Updates the image with the data in its pixels[] array
554
447
  * @usage web_application
@@ -569,41 +462,30 @@ public class PImage implements PConstants, Cloneable {
569
462
  modified = true;
570
463
 
571
464
  } else {
572
- if (x < mx1) {
573
- mx1 = PApplet.max(0, x);
574
- }
575
- if (x > mx2) {
576
- mx2 = PApplet.min(pixelWidth, x);
577
- }
578
- if (y < my1) {
579
- my1 = PApplet.max(0, y);
580
- }
581
- if (y > my2) {
582
- my2 = PApplet.min(pixelHeight, y);
583
- }
465
+ if (x < mx1) mx1 = PApplet.max(0, x);
466
+ if (x > mx2) mx2 = PApplet.min(pixelWidth, x);
467
+ if (y < my1) my1 = PApplet.max(0, y);
468
+ if (y > my2) my2 = PApplet.min(pixelHeight, y);
584
469
 
585
- if (x2 < mx1) {
586
- mx1 = PApplet.max(0, x2);
587
- }
588
- if (x2 > mx2) {
589
- mx2 = PApplet.min(pixelWidth, x2);
590
- }
591
- if (y2 < my1) {
592
- my1 = PApplet.max(0, y2);
593
- }
594
- if (y2 > my2) {
595
- my2 = PApplet.min(pixelHeight, y2);
596
- }
470
+ if (x2 < mx1) mx1 = PApplet.max(0, x2);
471
+ if (x2 > mx2) mx2 = PApplet.min(pixelWidth, x2);
472
+ if (y2 < my1) my1 = PApplet.max(0, y2);
473
+ if (y2 > my2) my2 = PApplet.min(pixelHeight, y2);
597
474
  }
598
475
  }
599
476
 
477
+
600
478
  //////////////////////////////////////////////////////////////
479
+
601
480
  // COPYING IMAGE DATA
481
+
482
+
602
483
  /**
603
- * Duplicate an image, returns new PImage object. The pixels[] array for the
604
- * new object will be unique and recopied from the source image. This is
605
- * implemented as an override of Object.clone(). We recommend using get()
606
- * instead, because it prevents you from needing to catch the
484
+ * Duplicate an image, returns new PImage object.
485
+ * The pixels[] array for the new object will be unique
486
+ * and recopied from the source image. This is implemented as an
487
+ * override of Object.clone(). We recommend using get() instead,
488
+ * because it prevents you from needing to catch the
607
489
  * CloneNotSupportedException, and from doing a cast from the result.
608
490
  */
609
491
  @Override
@@ -611,6 +493,7 @@ public class PImage implements PConstants, Cloneable {
611
493
  return get();
612
494
  }
613
495
 
496
+
614
497
  /**
615
498
  * ( begin auto-generated from PImage_resize.xml )
616
499
  *
@@ -618,15 +501,15 @@ public class PImage implements PConstants, Cloneable {
618
501
  * proportionally, use 0 as the value for the <b>wide</b> or <b>high</b>
619
502
  * parameter. For instance, to make the width of an image 150 pixels, and
620
503
  * change the height using the same proportion, use resize(150, 0).
621
- *
504
+ *
622
505
  * Even though a PGraphics is technically a PImage, it is not possible to
623
- * rescale the image data found in a PGraphics. (It's simply not possible to
624
- * do this consistently across renderers: technically infeasible with P3D, or
625
- * what would it even do with PDF?) If you want to resize PGraphics content,
626
- * first get a copy of its image data using the <b>get()</b>
506
+ * rescale the image data found in a PGraphics. (It's simply not possible
507
+ * to do this consistently across renderers: technically infeasible with
508
+ * P3D, or what would it even do with PDF?) If you want to resize PGraphics
509
+ * content, first get a copy of its image data using the <b>get()</b>
627
510
  * method, and call <b>resize()</b> on the PImage that is returned.
628
511
  *
629
- *
512
+ * ( end auto-generated )
630
513
  * @webref pimage:method
631
514
  * @brief Changes the size of an image to a new width and height
632
515
  * @usage web_application
@@ -638,62 +521,73 @@ public class PImage implements PConstants, Cloneable {
638
521
  throw new RuntimeException("resize() not implemented for this PImage type");
639
522
  }
640
523
 
524
+
641
525
  //////////////////////////////////////////////////////////////
526
+
642
527
  // MARKING IMAGE AS LOADED / FOR USE IN RENDERERS
528
+
529
+
643
530
  public boolean isLoaded() { // ignore
644
531
  return loaded;
645
532
  }
646
533
 
534
+
647
535
  public void setLoaded() { // ignore
648
536
  loaded = true;
649
537
  }
650
538
 
539
+
651
540
  public void setLoaded(boolean l) { // ignore
652
541
  loaded = l;
653
542
  }
654
543
 
544
+
655
545
  //////////////////////////////////////////////////////////////
546
+
656
547
  // GET/SET PIXELS
548
+
549
+
657
550
  /**
658
551
  * ( begin auto-generated from PImage_get.xml )
659
552
  *
660
553
  * Reads the color of any pixel or grabs a section of an image. If no
661
554
  * parameters are specified, the entire image is returned. Use the <b>x</b>
662
- * and <b>y</b> parameters to get the value of one pixel. Get a section of the
663
- * display window by specifying an additional <b>width</b> and
555
+ * and <b>y</b> parameters to get the value of one pixel. Get a section of
556
+ * the display window by specifying an additional <b>width</b> and
664
557
  * <b>height</b> parameter. When getting an image, the <b>x</b> and
665
- * <b>y</b> parameters define the coordinates for the upper-left corner of the
666
- * image, regardless of the current <b>imageMode()</b>.
667
- *
668
- * If the pixel requested is outside of the image window, black is returned.
669
- * The numbers returned are scaled according to the current color ranges, but
670
- * only RGB values are returned by this function. For example, even though you
671
- * may have drawn a shape with <b>colorMode(HSB)</b>, the numbers returned
672
- * will be in RGB format.
673
- *
674
- * getting the color of a single pixel with <b>get(x, y)</b> is easy, but not
675
- * as fast as grabbing the data directly from <b>pixels[]</b>. The equivalent
676
- * statement to <b>get(x, y)</b> using <b>pixels[]</b> is
677
- * <b>pixels[y*width+x]</b>. See the reference for <b>pixels[]</b> for more
678
- * information.
679
- *
558
+ * <b>y</b> parameters define the coordinates for the upper-left corner of
559
+ * the image, regardless of the current <b>imageMode()</b>.
560
+ *
561
+ * If the pixel requested is outside of the image window, black is
562
+ * returned. The numbers returned are scaled according to the current color
563
+ * ranges, but only RGB values are returned by this function. For example,
564
+ * even though you may have drawn a shape with <b>colorMode(HSB)</b>, the
565
+ * numbers returned will be in RGB format.
566
+ *
567
+ * Getting the color of a single pixel with <b>get(x, y)</b> is easy, but
568
+ * not as fast as grabbing the data directly from <b>pixels[]</b>. The
569
+ * equivalent statement to <b>get(x, y)</b> using <b>pixels[]</b> is
570
+ * <b>pixels[y*width+x]</b>. See the reference for <b>pixels[]</b> for more information.
680
571
  *
572
+ * ( end auto-generated )
681
573
  *
682
574
  * <h3>Advanced</h3>
683
- * Returns an ARGB "color" type (a packed 32 bit int with the color. If the
684
- * coordinate is outside the image, zero is returned (black, but completely
685
- * transparent).
575
+ * Returns an ARGB "color" type (a packed 32 bit int with the color.
576
+ * If the coordinate is outside the image, zero is returned
577
+ * (black, but completely transparent).
686
578
  * <P>
687
- * If the image is in RGB format (i.e. on a PVideo object), the value will get
688
- * its high bits set, just to avoid cases where they haven't been set already.
579
+ * If the image is in RGB format (i.e. on a PVideo object),
580
+ * the value will get its high bits set, just to avoid cases where
581
+ * they haven't been set already.
689
582
  * <P>
690
- * If the image is in ALPHA format, this returns a white with its alpha value
691
- * set.
583
+ * If the image is in ALPHA format, this returns a white with its
584
+ * alpha value set.
692
585
  * <P>
693
- * This function is included primarily for beginners. It is quite slow because
694
- * it has to check to see if the x, y that was provided is inside the bounds,
695
- * and then has to check to see what image type it is. If you want things to
696
- * be more efficient, access the pixels[] array directly.
586
+ * This function is included primarily for beginners. It is quite
587
+ * slow because it has to check to see if the x, y that was provided
588
+ * is inside the bounds, and then has to check to see what image
589
+ * type it is. If you want things to be more efficient, access the
590
+ * pixels[] array directly.
697
591
  *
698
592
  * @webref image:pixels
699
593
  * @brief Reads the color of any pixel or grabs a rectangle of pixels
@@ -705,29 +599,25 @@ public class PImage implements PConstants, Cloneable {
705
599
  * @see PApplet#copy(PImage, int, int, int, int, int, int, int, int)
706
600
  */
707
601
  public int get(int x, int y) {
708
- if ((x < 0) || (y < 0) || (x >= pixelWidth) || (y >= pixelHeight)) {
709
- return 0;
710
- }
602
+ if ((x < 0) || (y < 0) || (x >= pixelWidth) || (y >= pixelHeight)) return 0;
711
603
 
712
604
  switch (format) {
713
605
  case RGB:
714
- return pixels[y * pixelWidth + x] | 0xff000000;
606
+ return pixels[y*pixelWidth + x] | 0xff000000;
715
607
 
716
608
  case ARGB:
717
- return pixels[y * pixelWidth + x];
609
+ return pixels[y*pixelWidth + x];
718
610
 
719
611
  case ALPHA:
720
- return (pixels[y * pixelWidth + x] << 24) | 0xffffff;
612
+ return (pixels[y*pixelWidth + x] << 24) | 0xffffff;
721
613
  }
722
614
  return 0;
723
615
  }
724
616
 
617
+
725
618
  /**
726
- * @param x
727
- * @param y
728
619
  * @param w width of pixel rectangle to get
729
620
  * @param h height of pixel rectangle to get
730
- * @return
731
621
  */
732
622
  public PImage get(int x, int y, int w, int h) {
733
623
  int targetX = 0;
@@ -771,8 +661,8 @@ public class PImage implements PConstants, Cloneable {
771
661
  }
772
662
 
773
663
  PImage target = new PImage(targetWidth / pixelDensity,
774
- targetHeight / pixelDensity,
775
- targetFormat, pixelDensity);
664
+ targetHeight / pixelDensity,
665
+ targetFormat, pixelDensity);
776
666
  target.parent = parent; // parent may be null so can't use createImage()
777
667
  if (w > 0 && h > 0) {
778
668
  getImpl(x, y, w, h, target, targetX, targetY);
@@ -780,9 +670,10 @@ public class PImage implements PConstants, Cloneable {
780
670
  return target;
781
671
  }
782
672
 
673
+
783
674
  /**
784
- * Returns a copy of this PImage.Equivalent to get(0, 0, width, height). Deprecated, just use copy() instead.
785
- * @return
675
+ * Returns a copy of this PImage. Equivalent to get(0, 0, width, height).
676
+ * Deprecated, just use copy() instead.
786
677
  */
787
678
  public PImage get() {
788
679
  // Formerly this used clone(), which caused memory problems.
@@ -790,28 +681,23 @@ public class PImage implements PConstants, Cloneable {
790
681
  return get(0, 0, pixelWidth, pixelHeight);
791
682
  }
792
683
 
684
+
793
685
  public PImage copy() {
794
686
  return get(0, 0, pixelWidth, pixelHeight);
795
687
  }
796
688
 
689
+
797
690
  /**
798
- * Internal function to actually handle getting a block of pixels that has
799
- * already been properly cropped to a valid region.That is, x/y/w/h are
800
- guaranteed to be inside the image space, so the implementation can use the
801
- fastest possible pixel copying method.
802
- * @param sourceX
803
- * @param sourceY
804
- * @param sourceWidth
805
- * @param sourceHeight
806
- * @param target
807
- * @param targetX
808
- * @param targetY
691
+ * Internal function to actually handle getting a block of pixels that
692
+ * has already been properly cropped to a valid region. That is, x/y/w/h
693
+ * are guaranteed to be inside the image space, so the implementation can
694
+ * use the fastest possible pixel copying method.
809
695
  */
810
696
  protected void getImpl(int sourceX, int sourceY,
811
- int sourceWidth, int sourceHeight,
812
- PImage target, int targetX, int targetY) {
813
- int sourceIndex = sourceY * pixelWidth + sourceX;
814
- int targetIndex = targetY * target.pixelWidth + targetX;
697
+ int sourceWidth, int sourceHeight,
698
+ PImage target, int targetX, int targetY) {
699
+ int sourceIndex = sourceY*pixelWidth + sourceX;
700
+ int targetIndex = targetY*target.pixelWidth + targetX;
815
701
  for (int row = 0; row < sourceHeight; row++) {
816
702
  System.arraycopy(pixels, sourceIndex, target.pixels, targetIndex, sourceWidth);
817
703
  sourceIndex += pixelWidth;
@@ -819,25 +705,27 @@ public class PImage implements PConstants, Cloneable {
819
705
  }
820
706
  }
821
707
 
708
+
822
709
  /**
710
+ * ( begin auto-generated from PImage_set.xml )
823
711
  *
824
- * Changes the color of any pixel or writes an image directly into the display
825
- * window.
826
- *
712
+ * Changes the color of any pixel or writes an image directly into the
713
+ * display window.
714
+ *
827
715
  * The <b>x</b> and <b>y</b> parameters specify the pixel to change and the
828
716
  * <b>color</b> parameter specifies the color value. The color parameter is
829
717
  * affected by the current color mode (the default is RGB values from 0 to
830
- * 255). When secodeing an image, the <b>x</b> and <b>y</b> parameters define
831
- * the coordinates for the upper-left corner of the image, regardless of the
832
- * current <b>imageMode()</b>.
833
- *
834
- * Secodeing the color of a single pixel with <b>set(x, y)</b> is easy, but not
835
- * as fast as pucodeing the data directly into <b>pixels[]</b>. The equivalent
836
- * statement to <b>set(x, y, #000000)</b> using <b>pixels[]</b>
718
+ * 255). When setting an image, the <b>x</b> and <b>y</b> parameters define
719
+ * the coordinates for the upper-left corner of the image, regardless of
720
+ * the current <b>imageMode()</b>.
721
+ *
722
+ * Setting the color of a single pixel with <b>set(x, y)</b> is easy, but
723
+ * not as fast as putting the data directly into <b>pixels[]</b>. The
724
+ * equivalent statement to <b>set(x, y, #000000)</b> using <b>pixels[]</b>
837
725
  * is <b>pixels[y*width+x] = #000000</b>. See the reference for
838
726
  * <b>pixels[]</b> for more information.
839
727
  *
840
- *
728
+ * ( end auto-generated )
841
729
  *
842
730
  * @webref image:pixels
843
731
  * @brief writes a color to any pixel or writes an image into another
@@ -850,21 +738,18 @@ public class PImage implements PConstants, Cloneable {
850
738
  * @see PImage#copy(PImage, int, int, int, int, int, int, int, int)
851
739
  */
852
740
  public void set(int x, int y, int c) {
853
- if ((x < 0) || (y < 0) || (x >= pixelWidth) || (y >= pixelHeight)) {
854
- return;
855
- }
856
- pixels[y * pixelWidth + x] = c;
741
+ if ((x < 0) || (y < 0) || (x >= pixelWidth) || (y >= pixelHeight)) return;
742
+ pixels[y*pixelWidth + x] = c;
857
743
  updatePixels(x, y, 1, 1); // slow...
858
744
  }
859
745
 
746
+
860
747
  /**
861
748
  * <h3>Advanced</h3>
862
- * Efficient method of drawing an image's pixels directly to this surface. No
863
- * variations are employed, meaning that any scale, tint, or imageMode
864
- * secodeings will be ignored.
749
+ * Efficient method of drawing an image's pixels directly to this surface.
750
+ * No variations are employed, meaning that any scale, tint, or imageMode
751
+ * settings will be ignored.
865
752
  *
866
- * @param x
867
- * @param y
868
753
  * @param img image to copy into the original image
869
754
  */
870
755
  public void set(int x, int y, PImage img) {
@@ -886,33 +771,25 @@ public class PImage implements PConstants, Cloneable {
886
771
  if (x + sw > pixelWidth) { // off right edge
887
772
  sw = pixelWidth - x;
888
773
  }
889
- if (y + sh > pixelHeight) { // off bocodeom edge
774
+ if (y + sh > pixelHeight) { // off bottom edge
890
775
  sh = pixelHeight - y;
891
776
  }
892
777
 
893
778
  // this could be nonexistent
894
- if ((sw <= 0) || (sh <= 0)) {
895
- return;
896
- }
779
+ if ((sw <= 0) || (sh <= 0)) return;
897
780
 
898
781
  setImpl(img, sx, sy, sw, sh, x, y);
899
782
  }
900
783
 
784
+
901
785
  /**
902
- * Internal function to actually handle secodeing a block of pixels that has
903
- * already been properly cropped from the image to a valid region.
904
- * @param sourceImage
905
- * @param sourceX
906
- * @param sourceY
907
- * @param sourceWidth
908
- * @param sourceHeight
909
- * @param targetX
910
- * @param targetY
786
+ * Internal function to actually handle setting a block of pixels that
787
+ * has already been properly cropped from the image to a valid region.
911
788
  */
912
789
  protected void setImpl(PImage sourceImage,
913
- int sourceX, int sourceY,
914
- int sourceWidth, int sourceHeight,
915
- int targetX, int targetY) {
790
+ int sourceX, int sourceY,
791
+ int sourceWidth, int sourceHeight,
792
+ int targetX, int targetY) {
916
793
  int sourceOffset = sourceY * sourceImage.pixelWidth + sourceX;
917
794
  int targetOffset = targetY * pixelWidth + targetX;
918
795
 
@@ -926,8 +803,13 @@ public class PImage implements PConstants, Cloneable {
926
803
  updatePixels(targetX, targetY, sourceWidth, sourceHeight);
927
804
  }
928
805
 
806
+
807
+
929
808
  //////////////////////////////////////////////////////////////
809
+
930
810
  // ALPHA CHANNEL
811
+
812
+
931
813
  /**
932
814
  * @param maskArray array of integers used as the alpha channel, needs to be
933
815
  * the same length as the image's pixel array.
@@ -945,32 +827,35 @@ public class PImage implements PConstants, Cloneable {
945
827
  updatePixels();
946
828
  }
947
829
 
830
+
948
831
  /**
949
832
  * ( begin auto-generated from PImage_mask.xml )
950
833
  *
951
- * Masks part of an image from displaying by loading another image and using
952
- * it as an alpha channel. This mask image should only contain grayscale data,
953
- * but only the blue color channel is used. The mask image needs to be the
954
- * same size as the image to which it is applied.
955
- *
834
+ * Masks part of an image from displaying by loading another image and
835
+ * using it as an alpha channel. This mask image should only contain
836
+ * grayscale data, but only the blue color channel is used. The mask image
837
+ * needs to be the same size as the image to which it is applied.
838
+ *
956
839
  * In addition to using a mask image, an integer array containing the alpha
957
- * channel data can be specified directly. This method is useful for creating
958
- * dynamically generated alpha masks. This array must be of the same length as
959
- * the target image's pixels array and should contain only grayscale data of
960
- * values between 0-255.
961
- *
840
+ * channel data can be specified directly. This method is useful for
841
+ * creating dynamically generated alpha masks. This array must be of the
842
+ * same length as the target image's pixels array and should contain only
843
+ * grayscale data of values between 0-255.
962
844
  *
845
+ * ( end auto-generated )
963
846
  *
964
847
  * <h3>Advanced</h3>
965
848
  *
966
- * Set alpha channel for an image. Black colors in the source image will make
967
- * the destination image completely transparent, and white will make things
968
- * fully opaque. Gray values will be in-between steps.
849
+ * Set alpha channel for an image. Black colors in the source
850
+ * image will make the destination image completely transparent,
851
+ * and white will make things fully opaque. Gray values will
852
+ * be in-between steps.
969
853
  * <P>
970
- * Strictly speaking the "blue" value from the source image is used as the
971
- * alpha color. For a fully grayscale image, this is correct, but for a color
972
- * image it's not 100% accurate. For a more accurate conversion, first use
973
- * filter(GRAY) which will make the image into a "correct" grayscale by
854
+ * Strictly speaking the "blue" value from the source image is
855
+ * used as the alpha color. For a fully grayscale image, this
856
+ * is correct, but for a color image it's not 100% accurate.
857
+ * For a more accurate conversion, first use filter(GRAY)
858
+ * which will make the image into a "correct" grayscale by
974
859
  * performing a proper luminance-based conversion.
975
860
  *
976
861
  * @webref pimage:method
@@ -983,8 +868,13 @@ public class PImage implements PConstants, Cloneable {
983
868
  mask(img.pixels);
984
869
  }
985
870
 
871
+
872
+
986
873
  //////////////////////////////////////////////////////////////
874
+
987
875
  // IMAGE FILTERS
876
+
877
+
988
878
  public void filter(int kind) {
989
879
  loadPixels();
990
880
 
@@ -992,7 +882,7 @@ public class PImage implements PConstants, Cloneable {
992
882
  case BLUR:
993
883
  // TODO write basic low-pass filter blur here
994
884
  // what does photoshop do on the edges with this guy?
995
- // becodeer yet.. why bother? just use gaussian with radius 1
885
+ // better yet.. why bother? just use gaussian with radius 1
996
886
  filter(BLUR, 1);
997
887
  break;
998
888
 
@@ -1015,8 +905,8 @@ public class PImage implements PConstants, Cloneable {
1015
905
  // 0.30 * 256 = 77
1016
906
  // 0.59 * 256 = 151
1017
907
  // 0.11 * 256 = 28
1018
- int lum = (77 * (col >> 16 & 0xff) + 151 * (col >> 8 & 0xff) + 28 * (col & 0xff)) >> 8;
1019
- pixels[i] = (col & ALPHA_MASK) | lum << 16 | lum << 8 | lum;
908
+ int lum = (77*(col>>16&0xff) + 151*(col>>8&0xff) + 28*(col&0xff))>>8;
909
+ pixels[i] = (col & ALPHA_MASK) | lum<<16 | lum<<8 | lum;
1020
910
  }
1021
911
  }
1022
912
  break;
@@ -1029,8 +919,8 @@ public class PImage implements PConstants, Cloneable {
1029
919
  break;
1030
920
 
1031
921
  case POSTERIZE:
1032
- throw new RuntimeException("Use filter(POSTERIZE, int levels) "
1033
- + "instead of filter(POSTERIZE)");
922
+ throw new RuntimeException("Use filter(POSTERIZE, int levels) " +
923
+ "instead of filter(POSTERIZE)");
1034
924
 
1035
925
  case OPAQUE:
1036
926
  for (int i = 0; i < pixels.length; i++) {
@@ -1043,7 +933,7 @@ public class PImage implements PConstants, Cloneable {
1043
933
  filter(THRESHOLD, 0.5f);
1044
934
  break;
1045
935
 
1046
- // [toxi 050728] added new filters
936
+ // [toxi 050728] added new filters
1047
937
  case ERODE:
1048
938
  erode(); // former dilate(true);
1049
939
  break;
@@ -1055,58 +945,58 @@ public class PImage implements PConstants, Cloneable {
1055
945
  updatePixels(); // mark as modified
1056
946
  }
1057
947
 
948
+
1058
949
  /**
1059
950
  * ( begin auto-generated from PImage_filter.xml )
1060
951
  *
1061
- * Filters an image as defined by one of the following modes: THRESHOLD -
1062
- * converts the image to black and white pixels depending if they are above or
1063
- * below the threshold defined by the level parameter. The level must be
1064
- * between 0.0 (black) and 1.0(white). If no level is specified, 0.5 is used.
1065
- *
952
+ * Filters an image as defined by one of the following modes:
953
+ * THRESHOLD - converts the image to black and white pixels depending if
954
+ * they are above or below the threshold defined by the level parameter.
955
+ * The level must be between 0.0 (black) and 1.0(white). If no level is
956
+ * specified, 0.5 is used.
957
+ *
1066
958
  * GRAY - converts any colors in the image to grayscale equivalents
1067
- *
959
+ *
1068
960
  * INVERT - sets each pixel to its inverse value
1069
- *
961
+ *
1070
962
  * POSTERIZE - limits each channel of the image to the number of colors
1071
963
  * specified as the level parameter
1072
- *
964
+ *
1073
965
  * BLUR - executes a Guassian blur with the level parameter specifying the
1074
966
  * extent of the blurring. If no level parameter is used, the blur is
1075
967
  * equivalent to Guassian blur of radius 1
1076
- *
968
+ *
1077
969
  * OPAQUE - sets the alpha channel to entirely opaque
1078
- *
970
+ *
1079
971
  * ERODE - reduces the light areas with the amount defined by the level
1080
972
  * parameter
973
+ *
974
+ * DILATE - increases the light areas with the amount defined by the level parameter
1081
975
  *
1082
- * DILATE - increases the light areas with the amount defined by the level
1083
- * parameter
1084
- *
1085
- *
976
+ * ( end auto-generated )
1086
977
  *
1087
978
  * <h3>Advanced</h3>
1088
979
  * Method to apply a variety of basic filters to this image.
1089
980
  * <P>
1090
- * <ul>
1091
- * <li>filter(BLUR) provides a basic blur.
1092
- * <li>filter(GRAY) converts the image to grayscale based on luminance.
1093
- * <li>filter(INVERT) will invert the color components in the image.
1094
- * <li>filter(OPAQUE) set all the high bits in the image to opaque
1095
- * <li>filter(THRESHOLD) converts the image to black and white.
1096
- * <li>filter(DILATE) grow white/light areas
1097
- * <li>filter(ERODE) shrink white/light areas
1098
- * </ul>
981
+ * <UL>
982
+ * <LI>filter(BLUR) provides a basic blur.
983
+ * <LI>filter(GRAY) converts the image to grayscale based on luminance.
984
+ * <LI>filter(INVERT) will invert the color components in the image.
985
+ * <LI>filter(OPAQUE) set all the high bits in the image to opaque
986
+ * <LI>filter(THRESHOLD) converts the image to black and white.
987
+ * <LI>filter(DILATE) grow white/light areas
988
+ * <LI>filter(ERODE) shrink white/light areas
989
+ * </UL>
1099
990
  * Luminance conversion code contributed by
1100
- * <a href="http://www.toxi.co.uk">toxi</a>
1101
- *
991
+ * <A HREF="http://www.toxi.co.uk">toxi</A>
992
+ *
1102
993
  * Gaussian blur code contributed by
1103
- * <a href="http://incubator.quasimondo.com">Mario Klingemann</a>
994
+ * <A HREF="http://incubator.quasimondo.com">Mario Klingemann</A>
1104
995
  *
1105
996
  * @webref image:pixels
1106
997
  * @brief Converts the image to grayscale or black and white
1107
998
  * @usage web_application
1108
- * @param kind Either THRESHOLD, GRAY, OPAQUE, INVERT, POSTERIZE, BLUR, ERODE,
1109
- * or DILATE
999
+ * @param kind Either THRESHOLD, GRAY, OPAQUE, INVERT, POSTERIZE, BLUR, ERODE, or DILATE
1110
1000
  * @param param unique for each, see above
1111
1001
  */
1112
1002
  public void filter(int kind, float param) {
@@ -1114,32 +1004,37 @@ public class PImage implements PConstants, Cloneable {
1114
1004
 
1115
1005
  switch (kind) {
1116
1006
  case BLUR:
1117
- if (format == ALPHA) {
1007
+ switch (format) {
1008
+ case ALPHA:
1118
1009
  blurAlpha(param);
1119
- } else if (format == ARGB) {
1010
+ break;
1011
+ case ARGB:
1120
1012
  blurARGB(param);
1121
- } else {
1013
+ break;
1014
+ default:
1122
1015
  blurRGB(param);
1123
- }
1016
+ break;
1017
+ }
1124
1018
  break;
1125
1019
 
1020
+
1126
1021
  case GRAY:
1127
- throw new RuntimeException("Use filter(GRAY) instead of "
1128
- + "filter(GRAY, param)");
1022
+ throw new RuntimeException("Use filter(GRAY) instead of " +
1023
+ "filter(GRAY, param)");
1129
1024
 
1130
1025
  case INVERT:
1131
- throw new RuntimeException("Use filter(INVERT) instead of "
1132
- + "filter(INVERT, param)");
1026
+ throw new RuntimeException("Use filter(INVERT) instead of " +
1027
+ "filter(INVERT, param)");
1133
1028
 
1134
1029
  case OPAQUE:
1135
- throw new RuntimeException("Use filter(OPAQUE) instead of "
1136
- + "filter(OPAQUE, param)");
1030
+ throw new RuntimeException("Use filter(OPAQUE) instead of " +
1031
+ "filter(OPAQUE, param)");
1137
1032
 
1138
1033
  case POSTERIZE:
1139
- int levels = (int) param;
1034
+ int levels = (int)param;
1140
1035
  if ((levels < 2) || (levels > 255)) {
1141
- throw new RuntimeException("Levels must be between 2 and 255 for "
1142
- + "filter(POSTERIZE, levels)");
1036
+ throw new RuntimeException("Levels must be between 2 and 255 for " +
1037
+ "filter(POSTERIZE, levels)");
1143
1038
  }
1144
1039
  int levels1 = levels - 1;
1145
1040
  for (int i = 0; i < pixels.length; i++) {
@@ -1149,10 +1044,10 @@ public class PImage implements PConstants, Cloneable {
1149
1044
  rlevel = (((rlevel * levels) >> 8) * 255) / levels1;
1150
1045
  glevel = (((glevel * levels) >> 8) * 255) / levels1;
1151
1046
  blevel = (((blevel * levels) >> 8) * 255) / levels1;
1152
- pixels[i] = ((0xff000000 & pixels[i])
1153
- | (rlevel << 16)
1154
- | (glevel << 8)
1155
- | blevel);
1047
+ pixels[i] = ((0xff000000 & pixels[i]) |
1048
+ (rlevel << 16) |
1049
+ (glevel << 8) |
1050
+ blevel);
1156
1051
  }
1157
1052
  break;
1158
1053
 
@@ -1160,67 +1055,67 @@ public class PImage implements PConstants, Cloneable {
1160
1055
  int thresh = (int) (param * 255);
1161
1056
  for (int i = 0; i < pixels.length; i++) {
1162
1057
  int max = Math.max((pixels[i] & RED_MASK) >> 16,
1163
- Math.max((pixels[i] & GREEN_MASK) >> 8,
1164
- (pixels[i] & BLUE_MASK)));
1165
- pixels[i] = (pixels[i] & ALPHA_MASK)
1166
- | ((max < thresh) ? 0x000000 : 0xffffff);
1058
+ Math.max((pixels[i] & GREEN_MASK) >> 8,
1059
+ (pixels[i] & BLUE_MASK)));
1060
+ pixels[i] = (pixels[i] & ALPHA_MASK) |
1061
+ ((max < thresh) ? 0x000000 : 0xffffff);
1167
1062
  }
1168
1063
  break;
1169
1064
 
1170
- // [toxi20050728] added new filters
1171
- case ERODE:
1172
- throw new RuntimeException("Use filter(ERODE) instead of "
1173
- + "filter(ERODE, param)");
1174
- case DILATE:
1175
- throw new RuntimeException("Use filter(DILATE) instead of "
1176
- + "filter(DILATE, param)");
1065
+ // [toxi20050728] added new filters
1066
+ case ERODE:
1067
+ throw new RuntimeException("Use filter(ERODE) instead of " +
1068
+ "filter(ERODE, param)");
1069
+ case DILATE:
1070
+ throw new RuntimeException("Use filter(DILATE) instead of " +
1071
+ "filter(DILATE, param)");
1177
1072
  }
1178
1073
  updatePixels(); // mark as modified
1179
1074
  }
1180
1075
 
1181
- /**
1182
- * Set the high bits of all pixels to opaque.
1183
- */
1076
+
1077
+ /** Set the high bits of all pixels to opaque. */
1184
1078
  protected void opaque() {
1185
1079
  for (int i = 0; i < pixels.length; i++) {
1186
1080
  pixels[i] = 0xFF000000 | pixels[i];
1187
1081
  }
1188
1082
  }
1189
1083
 
1084
+
1190
1085
  /**
1191
- * Optimized code for building the blur kernel.further optimized blur code
1192
- (approx. 15% for radius=20) bigger speed gains for larger radii (~30%)
1193
- added support for various image types (ALPHA, RGB, ARGB) [toxi 050728]
1194
- * @param r
1086
+ * Optimized code for building the blur kernel.
1087
+ * further optimized blur code (approx. 15% for radius=20)
1088
+ * bigger speed gains for larger radii (~30%)
1089
+ * added support for various image types (ALPHA, RGB, ARGB)
1090
+ * [toxi 050728]
1195
1091
  */
1196
1092
  protected void buildBlurKernel(float r) {
1197
1093
  int radius = (int) (r * 3.5f);
1198
1094
  radius = (radius < 1) ? 1 : ((radius < 248) ? radius : 248);
1199
1095
  if (blurRadius != radius) {
1200
1096
  blurRadius = radius;
1201
- blurKernelSize = 1 + blurRadius << 1;
1097
+ blurKernelSize = 1 + blurRadius<<1;
1202
1098
  blurKernel = new int[blurKernelSize];
1203
1099
  blurMult = new int[blurKernelSize][256];
1204
1100
 
1205
- int bk, bki;
1206
- int[] bm, bmi;
1101
+ int bk,bki;
1102
+ int[] bm,bmi;
1207
1103
 
1208
1104
  for (int i = 1, radiusi = radius - 1; i < radius; i++) {
1209
- blurKernel[radius + i] = blurKernel[radiusi] = bki = radiusi * radiusi;
1210
- bm = blurMult[radius + i];
1211
- bmi = blurMult[radiusi--];
1212
- for (int j = 0; j < 256; j++) {
1213
- bm[j] = bmi[j] = bki * j;
1214
- }
1105
+ blurKernel[radius+i] = blurKernel[radiusi] = bki = radiusi * radiusi;
1106
+ bm=blurMult[radius+i];
1107
+ bmi=blurMult[radiusi--];
1108
+ for (int j = 0; j < 256; j++)
1109
+ bm[j] = bmi[j] = bki*j;
1215
1110
  }
1216
1111
  bk = blurKernel[radius] = radius * radius;
1217
1112
  bm = blurMult[radius];
1218
- for (int j = 0; j < 256; j++) {
1219
- bm[j] = bk * j;
1220
- }
1113
+ for (int j = 0; j < 256; j++)
1114
+ bm[j] = bk*j;
1221
1115
  }
1222
1116
  }
1223
1117
 
1118
+
1224
1119
  protected void blurAlpha(float r) {
1225
1120
  int sum, cb;
1226
1121
  int read, ri, ym, ymi, bk0;
@@ -1234,19 +1129,17 @@ public class PImage implements PConstants, Cloneable {
1234
1129
  //cb = cg = cr = sum = 0;
1235
1130
  cb = sum = 0;
1236
1131
  read = x - blurRadius;
1237
- if (read < 0) {
1238
- bk0 = -read;
1239
- read = 0;
1132
+ if (read<0) {
1133
+ bk0=-read;
1134
+ read=0;
1240
1135
  } else {
1241
- if (read >= pixelWidth) {
1136
+ if (read >= pixelWidth)
1242
1137
  break;
1243
- }
1244
- bk0 = 0;
1138
+ bk0=0;
1245
1139
  }
1246
1140
  for (int i = bk0; i < blurKernelSize; i++) {
1247
- if (read >= pixelWidth) {
1141
+ if (read >= pixelWidth)
1248
1142
  break;
1249
- }
1250
1143
  int c = pixels[read + yi];
1251
1144
  int[] bm = blurMult[i];
1252
1145
  cb += bm[c & BLUE_MASK];
@@ -1270,24 +1163,22 @@ public class PImage implements PConstants, Cloneable {
1270
1163
  bk0 = ri = -ym;
1271
1164
  read = x;
1272
1165
  } else {
1273
- if (ym >= pixelHeight) {
1166
+ if (ym >= pixelHeight)
1274
1167
  break;
1275
- }
1276
1168
  bk0 = 0;
1277
1169
  ri = ym;
1278
1170
  read = x + ymi;
1279
1171
  }
1280
1172
  for (int i = bk0; i < blurKernelSize; i++) {
1281
- if (ri >= pixelHeight) {
1173
+ if (ri >= pixelHeight)
1282
1174
  break;
1283
- }
1284
1175
  int[] bm = blurMult[i];
1285
1176
  cb += bm[b2[read]];
1286
1177
  sum += blurKernel[i];
1287
1178
  ri++;
1288
1179
  read += pixelWidth;
1289
1180
  }
1290
- pixels[x + yi] = (cb / sum);
1181
+ pixels[x+yi] = (cb/sum);
1291
1182
  }
1292
1183
  yi += pixelWidth;
1293
1184
  ymi += pixelWidth;
@@ -1295,6 +1186,7 @@ public class PImage implements PConstants, Cloneable {
1295
1186
  }
1296
1187
  }
1297
1188
 
1189
+
1298
1190
  protected void blurRGB(float r) {
1299
1191
  int sum, cr, cg, cb; //, k;
1300
1192
  int /*pixel,*/ read, ri, /*roff,*/ ym, ymi, /*riw,*/ bk0;
@@ -1368,7 +1260,7 @@ public class PImage implements PConstants, Cloneable {
1368
1260
  ri++;
1369
1261
  read += pixelWidth;
1370
1262
  }
1371
- pixels[x + yi] = 0xff000000 | (cr / sum) << 16 | (cg / sum) << 8 | (cb / sum);
1263
+ pixels[x+yi] = 0xff000000 | (cr/sum)<<16 | (cg/sum)<<8 | (cb/sum);
1372
1264
  }
1373
1265
  yi += pixelWidth;
1374
1266
  ymi += pixelWidth;
@@ -1376,6 +1268,7 @@ public class PImage implements PConstants, Cloneable {
1376
1268
  }
1377
1269
  }
1378
1270
 
1271
+
1379
1272
  protected void blurARGB(float r) {
1380
1273
  int sum, cr, cg, cb, ca;
1381
1274
  int /*pixel,*/ read, ri, /*roff,*/ ym, ymi, /*riw,*/ bk0;
@@ -1399,14 +1292,14 @@ public class PImage implements PConstants, Cloneable {
1399
1292
  if (read >= pixelWidth) {
1400
1293
  break;
1401
1294
  }
1402
- bk0 = 0;
1295
+ bk0=0;
1403
1296
  }
1404
1297
  for (int i = bk0; i < blurKernelSize; i++) {
1405
1298
  if (read >= pixelWidth) {
1406
1299
  break;
1407
1300
  }
1408
1301
  int c = pixels[read + yi];
1409
- int[] bm = blurMult[i];
1302
+ int[] bm=blurMult[i];
1410
1303
  ca += bm[(c & ALPHA_MASK) >>> 24];
1411
1304
  cr += bm[(c & RED_MASK) >> 16];
1412
1305
  cg += bm[(c & GREEN_MASK) >> 8];
@@ -1445,7 +1338,7 @@ public class PImage implements PConstants, Cloneable {
1445
1338
  if (ri >= pixelHeight) {
1446
1339
  break;
1447
1340
  }
1448
- int[] bm = blurMult[i];
1341
+ int[] bm=blurMult[i];
1449
1342
  ca += bm[a2[read]];
1450
1343
  cr += bm[r2[read]];
1451
1344
  cg += bm[g2[read]];
@@ -1454,7 +1347,7 @@ public class PImage implements PConstants, Cloneable {
1454
1347
  ri++;
1455
1348
  read += pixelWidth;
1456
1349
  }
1457
- pixels[x + yi] = (ca / sum) << 24 | (cr / sum) << 16 | (cg / sum) << 8 | (cb / sum);
1350
+ pixels[x+yi] = (ca/sum)<<24 | (cr/sum)<<16 | (cg/sum)<<8 | (cb/sum);
1458
1351
  }
1459
1352
  yi += pixelWidth;
1460
1353
  ymi += pixelWidth;
@@ -1462,9 +1355,10 @@ public class PImage implements PConstants, Cloneable {
1462
1355
  }
1463
1356
  }
1464
1357
 
1358
+
1465
1359
  /**
1466
- * Generic dilate/erode filter using luminance values as decision factor.
1467
- * [toxi 050728]
1360
+ * Generic dilate/erode filter using luminance values
1361
+ * as decision factor. [toxi 050728]
1468
1362
  */
1469
1363
  protected void dilate() { // formerly dilate(false)
1470
1364
  int index = 0;
@@ -1501,16 +1395,16 @@ public class PImage implements PConstants, Cloneable {
1501
1395
  int colRight = pixels[idxRight];
1502
1396
 
1503
1397
  // compute luminance
1504
- int currLum
1505
- = 77 * (orig >> 16 & 0xff) + 151 * (orig >> 8 & 0xff) + 28 * (orig & 0xff);
1506
- int lumLeft
1507
- = 77 * (colLeft >> 16 & 0xff) + 151 * (colLeft >> 8 & 0xff) + 28 * (colLeft & 0xff);
1508
- int lumRight
1509
- = 77 * (colRight >> 16 & 0xff) + 151 * (colRight >> 8 & 0xff) + 28 * (colRight & 0xff);
1510
- int lumUp
1511
- = 77 * (colUp >> 16 & 0xff) + 151 * (colUp >> 8 & 0xff) + 28 * (colUp & 0xff);
1512
- int lumDown
1513
- = 77 * (colDown >> 16 & 0xff) + 151 * (colDown >> 8 & 0xff) + 28 * (colDown & 0xff);
1398
+ int currLum =
1399
+ 77*(orig>>16&0xff) + 151*(orig>>8&0xff) + 28*(orig&0xff);
1400
+ int lumLeft =
1401
+ 77*(colLeft>>16&0xff) + 151*(colLeft>>8&0xff) + 28*(colLeft&0xff);
1402
+ int lumRight =
1403
+ 77*(colRight>>16&0xff) + 151*(colRight>>8&0xff) + 28*(colRight&0xff);
1404
+ int lumUp =
1405
+ 77*(colUp>>16&0xff) + 151*(colUp>>8&0xff) + 28*(colUp&0xff);
1406
+ int lumDown =
1407
+ 77*(colDown>>16&0xff) + 151*(colDown>>8&0xff) + 28*(colDown&0xff);
1514
1408
 
1515
1409
  if (lumLeft > currLum) {
1516
1410
  result = colLeft;
@@ -1534,6 +1428,7 @@ public class PImage implements PConstants, Cloneable {
1534
1428
  System.arraycopy(outgoing, 0, pixels, 0, maxIndex);
1535
1429
  }
1536
1430
 
1431
+
1537
1432
  protected void erode() { // formerly dilate(true)
1538
1433
  int index = 0;
1539
1434
  int maxIndex = pixels.length;
@@ -1569,16 +1464,16 @@ public class PImage implements PConstants, Cloneable {
1569
1464
  int colRight = pixels[idxRight];
1570
1465
 
1571
1466
  // compute luminance
1572
- int currLum
1573
- = 77 * (orig >> 16 & 0xff) + 151 * (orig >> 8 & 0xff) + 28 * (orig & 0xff);
1574
- int lumLeft
1575
- = 77 * (colLeft >> 16 & 0xff) + 151 * (colLeft >> 8 & 0xff) + 28 * (colLeft & 0xff);
1576
- int lumRight
1577
- = 77 * (colRight >> 16 & 0xff) + 151 * (colRight >> 8 & 0xff) + 28 * (colRight & 0xff);
1578
- int lumUp
1579
- = 77 * (colUp >> 16 & 0xff) + 151 * (colUp >> 8 & 0xff) + 28 * (colUp & 0xff);
1580
- int lumDown
1581
- = 77 * (colDown >> 16 & 0xff) + 151 * (colDown >> 8 & 0xff) + 28 * (colDown & 0xff);
1467
+ int currLum =
1468
+ 77*(orig>>16&0xff) + 151*(orig>>8&0xff) + 28*(orig&0xff);
1469
+ int lumLeft =
1470
+ 77*(colLeft>>16&0xff) + 151*(colLeft>>8&0xff) + 28*(colLeft&0xff);
1471
+ int lumRight =
1472
+ 77*(colRight>>16&0xff) + 151*(colRight>>8&0xff) + 28*(colRight&0xff);
1473
+ int lumUp =
1474
+ 77*(colUp>>16&0xff) + 151*(colUp>>8&0xff) + 28*(colUp&0xff);
1475
+ int lumDown =
1476
+ 77*(colDown>>16&0xff) + 151*(colDown>>8&0xff) + 28*(colDown&0xff);
1582
1477
 
1583
1478
  if (lumLeft < currLum) {
1584
1479
  result = colLeft;
@@ -1602,19 +1497,25 @@ public class PImage implements PConstants, Cloneable {
1602
1497
  System.arraycopy(outgoing, 0, pixels, 0, maxIndex);
1603
1498
  }
1604
1499
 
1500
+
1501
+
1605
1502
  //////////////////////////////////////////////////////////////
1503
+
1606
1504
  // COPY
1505
+
1506
+
1607
1507
  /**
1508
+ * ( begin auto-generated from PImage_copy.xml )
1608
1509
  *
1609
1510
  * Copies a region of pixels from one image into another. If the source and
1610
1511
  * destination regions aren't the same size, it will automatically resize
1611
- * source pixels to fit the specified target region. No alpha information is
1612
- * used in the process, however if the source image has an alpha channel set,
1613
- * it will be copied as well.
1614
- *
1512
+ * source pixels to fit the specified target region. No alpha information
1513
+ * is used in the process, however if the source image has an alpha channel
1514
+ * set, it will be copied as well.
1515
+ *
1615
1516
  * As of release 0149, this function ignores <b>imageMode()</b>.
1616
1517
  *
1617
- *
1518
+ * ( end auto-generated )
1618
1519
  *
1619
1520
  * @webref image:pixels
1620
1521
  * @brief Copies the entire image
@@ -1631,204 +1532,193 @@ public class PImage implements PConstants, Cloneable {
1631
1532
  * @see PImage#blend(PImage, int, int, int, int, int, int, int, int, int)
1632
1533
  */
1633
1534
  public void copy(int sx, int sy, int sw, int sh,
1634
- int dx, int dy, int dw, int dh) {
1535
+ int dx, int dy, int dw, int dh) {
1635
1536
  blend(this, sx, sy, sw, sh, dx, dy, dw, dh, REPLACE);
1636
1537
  }
1637
1538
 
1638
- /**
1639
- * @param src an image variable referring to the source image.
1640
- * @param sx
1641
- * @param sy
1642
- * @param sw
1643
- * @param sh
1644
- * @param dx
1645
- * @param dy
1646
- * @param dw
1647
- * @param dh
1648
- */
1539
+
1540
+ /**
1541
+ * @param src an image variable referring to the source image.
1542
+ */
1649
1543
  public void copy(PImage src,
1650
- int sx, int sy, int sw, int sh,
1651
- int dx, int dy, int dw, int dh) {
1544
+ int sx, int sy, int sw, int sh,
1545
+ int dx, int dy, int dw, int dh) {
1652
1546
  blend(src, sx, sy, sw, sh, dx, dy, dw, dh, REPLACE);
1653
1547
  }
1654
1548
 
1549
+
1550
+
1655
1551
  //////////////////////////////////////////////////////////////
1552
+
1656
1553
  // BLEND
1554
+
1555
+
1657
1556
  /**
1557
+ * ( begin auto-generated from blendColor.xml )
1658
1558
  *
1659
1559
  * Blends two color values together based on the blending mode given as the
1660
- * <b>MODE</b> parameter.The possible modes are described in the reference
1661
- for the <b>blend()</b> function.<h3>Advanced</h3>
1662
- * <ul>
1663
- * <li>REPLACE - destination colour equals colour of source pixel: C = A.
1664
- * Sometimes called "Normal" or "Copy" in other software.
1560
+ * <b>MODE</b> parameter. The possible modes are described in the reference
1561
+ * for the <b>blend()</b> function.
1665
1562
  *
1666
- * <li>BLEND - linear interpolation of colours:
1667
- * <code>C = A*factor + B</code>
1563
+ * ( end auto-generated )
1564
+ * <h3>Advanced</h3>
1565
+ * <UL>
1566
+ * <LI>REPLACE - destination colour equals colour of source pixel: C = A.
1567
+ * Sometimes called "Normal" or "Copy" in other software.
1668
1568
  *
1669
- * <li>ADD - additive blending with white clip:
1670
- * <code>C = min(A*factor + B, 255)</code>. Clipped to 0..255, Photoshop calls
1671
- * this "Linear Burn", and Director calls it "Add Pin".
1569
+ * <LI>BLEND - linear interpolation of colours:
1570
+ * <TT>C = A*factor + B</TT>
1672
1571
  *
1673
- * <li>SUBTRACT - substractive blend with black clip:
1674
- * <code>C = max(B - A*factor, 0)</code>. Clipped to 0..255, Photoshop calls this
1675
- * "Linear Dodge", and Director calls it "Subtract Pin".
1572
+ * <LI>ADD - additive blending with white clip:
1573
+ * <TT>C = min(A*factor + B, 255)</TT>.
1574
+ * Clipped to 0..255, Photoshop calls this "Linear Burn",
1575
+ * and Director calls it "Add Pin".
1676
1576
  *
1677
- * <li>DARKEST - only the darkest colour succeeds:
1678
- * <code>C = min(A*factor, B)</code>. Illustrator calls this "Darken".
1577
+ * <LI>SUBTRACT - substractive blend with black clip:
1578
+ * <TT>C = max(B - A*factor, 0)</TT>.
1579
+ * Clipped to 0..255, Photoshop calls this "Linear Dodge",
1580
+ * and Director calls it "Subtract Pin".
1679
1581
  *
1680
- * <li>LIGHTEST - only the lightest colour succeeds:
1681
- * <code>C = max(A*factor, B)</code>. Illustrator calls this "Lighten".
1582
+ * <LI>DARKEST - only the darkest colour succeeds:
1583
+ * <TT>C = min(A*factor, B)</TT>.
1584
+ * Illustrator calls this "Darken".
1682
1585
  *
1683
- * <li>DIFFERENCE - subtract colors from underlying image.
1586
+ * <LI>LIGHTEST - only the lightest colour succeeds:
1587
+ * <TT>C = max(A*factor, B)</TT>.
1588
+ * Illustrator calls this "Lighten".
1684
1589
  *
1685
- * <li>EXCLUSION - similar to DIFFERENCE, but less extreme.
1590
+ * <LI>DIFFERENCE - subtract colors from underlying image.
1686
1591
  *
1687
- * <li>MULTIPLY - Multiply the colors, result will always be darker.
1592
+ * <LI>EXCLUSION - similar to DIFFERENCE, but less extreme.
1688
1593
  *
1689
- * <li>SCREEN - Opposite multiply, uses inverse values of the colors.
1594
+ * <LI>MULTIPLY - Multiply the colors, result will always be darker.
1690
1595
  *
1691
- * <li>OVERLAY - A mix of MULTIPLY and SCREEN. Multiplies dark values, and
1692
- * screens light values.
1596
+ * <LI>SCREEN - Opposite multiply, uses inverse values of the colors.
1693
1597
  *
1694
- * <li>HARD_LIGHT - SCREEN when greater than 50% gray, MULTIPLY when lower.
1598
+ * <LI>OVERLAY - A mix of MULTIPLY and SCREEN. Multiplies dark values,
1599
+ * and screens light values.
1695
1600
  *
1696
- * <li>SOFT_LIGHT - Mix of DARKEST and LIGHTEST. Works like OVERLAY, but not
1697
- * as harsh.
1601
+ * <LI>HARD_LIGHT - SCREEN when greater than 50% gray, MULTIPLY when lower.
1698
1602
  *
1699
- * <li>DODGE - Lightens light tones and increases contrast, ignores darks.
1700
- * Called "Color Dodge" in Illustrator and Photoshop.
1603
+ * <LI>SOFT_LIGHT - Mix of DARKEST and LIGHTEST.
1604
+ * Works like OVERLAY, but not as harsh.
1701
1605
  *
1702
- * <li>BURN - Darker areas are applied, increasing contrast, ignores lights.
1703
- * Called "Color Burn" in Illustrator and Photoshop.
1704
- * </ul>
1705
- * <P>
1706
- * A useful reference for blending modes and their algorithms can be found in
1707
- * the <a href="http://www.w3.org/TR/SVG12/rendering.html">SVG</a>
1606
+ * <LI>DODGE - Lightens light tones and increases contrast, ignores darks.
1607
+ * Called "Color Dodge" in Illustrator and Photoshop.
1608
+ *
1609
+ * <LI>BURN - Darker areas are applied, increasing contrast, ignores lights.
1610
+ * Called "Color Burn" in Illustrator and Photoshop.
1611
+ * </UL>
1612
+ * <P>A useful reference for blending modes and their algorithms can be
1613
+ * found in the <A HREF="http://www.w3.org/TR/SVG12/rendering.html">SVG</A>
1708
1614
  * specification.</P>
1709
- * <P>
1710
- * It is important to note that Processing uses "fast" code, not necessarily
1711
- * "correct" code. No biggie, most software does. A nitpicker can find
1712
- * numerous "off by 1 division" problems in the blend code where
1713
- * <code>&gt;&gt;8</code> or <code>&gt;&gt;7</code> is used when strictly speaking
1714
- * <code>/255.0</code> or <code>/127.0</code> should have been used.</P>
1715
- * <P>
1716
- * For instance, exclusion (not intended for real-time use) reads
1717
- * <code>r1 + r2 - ((2 * r1 * r2) / 255)</code> because <code>255 == 1.0</code>
1718
- * not <code>256 == 1.0</code>. In other words, <code>(255*255)>>8</code> is not the
1719
- * same as <code>(255*255)/255</code>. But for real-time use the shifts are
1720
- * preferrable, and the difference is insignificant for applications built
1721
- * with Processing.</P>
1722
- *
1723
- * @return
1615
+ * <P>It is important to note that Processing uses "fast" code, not
1616
+ * necessarily "correct" code. No biggie, most software does. A nitpicker
1617
+ * can find numerous "off by 1 division" problems in the blend code where
1618
+ * <TT>&gt;&gt;8</TT> or <TT>&gt;&gt;7</TT> is used when strictly speaking
1619
+ * <TT>/255.0</TT> or <TT>/127.0</TT> should have been used.</P>
1620
+ * <P>For instance, exclusion (not intended for real-time use) reads
1621
+ * <TT>r1 + r2 - ((2 * r1 * r2) / 255)</TT> because <TT>255 == 1.0</TT>
1622
+ * not <TT>256 == 1.0</TT>. In other words, <TT>(255*255)>>8</TT> is not
1623
+ * the same as <TT>(255*255)/255</TT>. But for real-time use the shifts
1624
+ * are preferrable, and the difference is insignificant for applications
1625
+ * built with Processing.</P>
1626
+ *
1724
1627
  * @webref color:creating_reading
1725
1628
  * @usage web_application
1726
1629
  * @param c1 the first color to blend
1727
1630
  * @param c2 the second color to blend
1728
- * @param mode either BLEND, ADD, SUBTRACT, DARKEST, LIGHTEST, DIFFERENCE,
1729
- * EXCLUSION, MULTIPLY, SCREEN, OVERLAY, HARD_LIGHT, SOFT_LIGHT, DODGE, or
1730
- * BURN
1631
+ * @param mode either BLEND, ADD, SUBTRACT, DARKEST, LIGHTEST, DIFFERENCE, EXCLUSION, MULTIPLY, SCREEN, OVERLAY, HARD_LIGHT, SOFT_LIGHT, DODGE, or BURN
1731
1632
  * @see PImage#blend(PImage, int, int, int, int, int, int, int, int, int)
1732
1633
  * @see PApplet#color(float, float, float, float)
1733
1634
  */
1734
1635
  static public int blendColor(int c1, int c2, int mode) { // ignore
1735
1636
  switch (mode) {
1736
- case REPLACE:
1737
- return c2;
1738
- case BLEND:
1739
- return blend_blend(c1, c2);
1637
+ case REPLACE: return c2;
1638
+ case BLEND: return blend_blend(c1, c2);
1740
1639
 
1741
- case ADD:
1742
- return blend_add_pin(c1, c2);
1743
- case SUBTRACT:
1744
- return blend_sub_pin(c1, c2);
1640
+ case ADD: return blend_add_pin(c1, c2);
1641
+ case SUBTRACT: return blend_sub_pin(c1, c2);
1745
1642
 
1746
- case LIGHTEST:
1747
- return blend_lightest(c1, c2);
1748
- case DARKEST:
1749
- return blend_darkest(c1, c2);
1643
+ case LIGHTEST: return blend_lightest(c1, c2);
1644
+ case DARKEST: return blend_darkest(c1, c2);
1750
1645
 
1751
- case DIFFERENCE:
1752
- return blend_difference(c1, c2);
1753
- case EXCLUSION:
1754
- return blend_exclusion(c1, c2);
1646
+ case DIFFERENCE: return blend_difference(c1, c2);
1647
+ case EXCLUSION: return blend_exclusion(c1, c2);
1755
1648
 
1756
- case MULTIPLY:
1757
- return blend_multiply(c1, c2);
1758
- case SCREEN:
1759
- return blend_screen(c1, c2);
1649
+ case MULTIPLY: return blend_multiply(c1, c2);
1650
+ case SCREEN: return blend_screen(c1, c2);
1760
1651
 
1761
- case HARD_LIGHT:
1762
- return blend_hard_light(c1, c2);
1763
- case SOFT_LIGHT:
1764
- return blend_soft_light(c1, c2);
1765
- case OVERLAY:
1766
- return blend_overlay(c1, c2);
1652
+ case HARD_LIGHT: return blend_hard_light(c1, c2);
1653
+ case SOFT_LIGHT: return blend_soft_light(c1, c2);
1654
+ case OVERLAY: return blend_overlay(c1, c2);
1767
1655
 
1768
- case DODGE:
1769
- return blend_dodge(c1, c2);
1770
- case BURN:
1771
- return blend_burn(c1, c2);
1656
+ case DODGE: return blend_dodge(c1, c2);
1657
+ case BURN: return blend_burn(c1, c2);
1772
1658
  }
1773
1659
  return 0;
1774
1660
  }
1775
1661
 
1662
+
1776
1663
  public void blend(int sx, int sy, int sw, int sh,
1777
- int dx, int dy, int dw, int dh, int mode) {
1664
+ int dx, int dy, int dw, int dh, int mode) {
1778
1665
  blend(this, sx, sy, sw, sh, dx, dy, dw, dh, mode);
1779
1666
  }
1780
1667
 
1668
+
1781
1669
  /**
1670
+ * ( begin auto-generated from PImage_blend.xml )
1782
1671
  *
1783
1672
  * Blends a region of pixels into the image specified by the <b>img</b>
1784
- * parameter. These copies utilize full alpha channel support and a choice of
1785
- * the following modes to blend the colors of source pixels (A) with the ones
1786
- * of pixels in the destination image (B):
1787
- *
1673
+ * parameter. These copies utilize full alpha channel support and a choice
1674
+ * of the following modes to blend the colors of source pixels (A) with the
1675
+ * ones of pixels in the destination image (B):
1676
+ *
1788
1677
  * BLEND - linear interpolation of colours: C = A*factor + B
1789
- *
1678
+ *
1790
1679
  * ADD - additive blending with white clip: C = min(A*factor + B, 255)
1791
- *
1792
- * SUBTRACT - subtractive blending with black clip: C = max(B - A*factor, 0)
1793
- *
1680
+ *
1681
+ * SUBTRACT - subtractive blending with black clip: C = max(B - A*factor,
1682
+ * 0)
1683
+ *
1794
1684
  * DARKEST - only the darkest colour succeeds: C = min(A*factor, B)
1795
- *
1685
+ *
1796
1686
  * LIGHTEST - only the lightest colour succeeds: C = max(A*factor, B)
1797
- *
1687
+ *
1798
1688
  * DIFFERENCE - subtract colors from underlying image.
1799
- *
1689
+ *
1800
1690
  * EXCLUSION - similar to DIFFERENCE, but less extreme.
1801
- *
1691
+ *
1802
1692
  * MULTIPLY - Multiply the colors, result will always be darker.
1803
- *
1693
+ *
1804
1694
  * SCREEN - Opposite multiply, uses inverse values of the colors.
1805
- *
1806
- * OVERLAY - A mix of MULTIPLY and SCREEN. Multiplies dark values, and screens
1807
- * light values.
1808
- *
1695
+ *
1696
+ * OVERLAY - A mix of MULTIPLY and SCREEN. Multiplies dark values,
1697
+ * and screens light values.
1698
+ *
1809
1699
  * HARD_LIGHT - SCREEN when greater than 50% gray, MULTIPLY when lower.
1810
- *
1811
- * SOFT_LIGHT - Mix of DARKEST and LIGHTEST. Works like OVERLAY, but not as
1812
- * harsh.
1813
- *
1814
- * DODGE - Lightens light tones and increases contrast, ignores darks. Called
1815
- * "Color Dodge" in Illustrator and Photoshop.
1816
- *
1700
+ *
1701
+ * SOFT_LIGHT - Mix of DARKEST and LIGHTEST.
1702
+ * Works like OVERLAY, but not as harsh.
1703
+ *
1704
+ * DODGE - Lightens light tones and increases contrast, ignores darks.
1705
+ * Called "Color Dodge" in Illustrator and Photoshop.
1706
+ *
1817
1707
  * BURN - Darker areas are applied, increasing contrast, ignores lights.
1818
1708
  * Called "Color Burn" in Illustrator and Photoshop.
1819
- *
1820
- * All modes use the alpha information (highest byte) of source image pixels
1821
- * as the blending factor. If the source and destination regions are different
1822
- * sizes, the image will be automatically resized to match the destination
1823
- * size. If the <b>srcImg</b> parameter is not used, the display window is
1824
- * used as the source image.
1825
- *
1709
+ *
1710
+ * All modes use the alpha information (highest byte) of source image
1711
+ * pixels as the blending factor. If the source and destination regions are
1712
+ * different sizes, the image will be automatically resized to match the
1713
+ * destination size. If the <b>srcImg</b> parameter is not used, the
1714
+ * display window is used as the source image.
1715
+ *
1826
1716
  * As of release 0149, this function ignores <b>imageMode()</b>.
1827
1717
  *
1828
- *
1718
+ * ( end auto-generated )
1829
1719
  *
1830
1720
  * @webref image:pixels
1831
- * @brief Copies a pixel or rectangle of pixels using different blending modes
1721
+ * @brief Copies a pixel or rectangle of pixels using different blending modes
1832
1722
  * @param src an image variable referring to the source image
1833
1723
  * @param sx X coordinate of the source's upper left corner
1834
1724
  * @param sy Y coordinate of the source's upper left corner
@@ -1838,16 +1728,15 @@ public class PImage implements PConstants, Cloneable {
1838
1728
  * @param dy Y coordinate of the destinations's upper left corner
1839
1729
  * @param dw destination image width
1840
1730
  * @param dh destination image height
1841
- * @param mode Either BLEND, ADD, SUBTRACT, LIGHTEST, DARKEST, DIFFERENCE,
1842
- * EXCLUSION, MULTIPLY, SCREEN, OVERLAY, HARD_LIGHT, SOFT_LIGHT, DODGE, BURN
1731
+ * @param mode Either BLEND, ADD, SUBTRACT, LIGHTEST, DARKEST, DIFFERENCE, EXCLUSION, MULTIPLY, SCREEN, OVERLAY, HARD_LIGHT, SOFT_LIGHT, DODGE, BURN
1843
1732
  *
1844
1733
  * @see PApplet#alpha(int)
1845
1734
  * @see PImage#copy(PImage, int, int, int, int, int, int, int, int)
1846
1735
  * @see PImage#blendColor(int,int,int)
1847
1736
  */
1848
1737
  public void blend(PImage src,
1849
- int sx, int sy, int sw, int sh,
1850
- int dx, int dy, int dw, int dh, int mode) {
1738
+ int sx, int sy, int sw, int sh,
1739
+ int dx, int dy, int dw, int dh, int mode) {
1851
1740
  int sx2 = sx + sw;
1852
1741
  int sy2 = sy + sh;
1853
1742
  int dx2 = dx + dw;
@@ -1857,27 +1746,28 @@ public class PImage implements PConstants, Cloneable {
1857
1746
  if (src == this) {
1858
1747
  if (intersect(sx, sy, sx2, sy2, dx, dy, dx2, dy2)) {
1859
1748
  blit_resize(get(sx, sy, sw, sh),
1860
- 0, 0, sw, sh,
1861
- pixels, pixelWidth, pixelHeight, dx, dy, dx2, dy2, mode);
1749
+ 0, 0, sw, sh,
1750
+ pixels, pixelWidth, pixelHeight, dx, dy, dx2, dy2, mode);
1862
1751
  } else {
1863
1752
  // same as below, except skip the loadPixels() because it'd be redundant
1864
1753
  blit_resize(src, sx, sy, sx2, sy2,
1865
- pixels, pixelWidth, pixelHeight, dx, dy, dx2, dy2, mode);
1754
+ pixels, pixelWidth, pixelHeight, dx, dy, dx2, dy2, mode);
1866
1755
  }
1867
1756
  } else {
1868
1757
  src.loadPixels();
1869
1758
  blit_resize(src, sx, sy, sx2, sy2,
1870
- pixels, pixelWidth, pixelHeight, dx, dy, dx2, dy2, mode);
1759
+ pixels, pixelWidth, pixelHeight, dx, dy, dx2, dy2, mode);
1871
1760
  //src.updatePixels();
1872
1761
  }
1873
1762
  updatePixels();
1874
1763
  }
1875
1764
 
1765
+
1876
1766
  /**
1877
1767
  * Check to see if two rectangles intersect one another
1878
1768
  */
1879
1769
  private boolean intersect(int sx1, int sy1, int sx2, int sy2,
1880
- int dx1, int dy1, int dx2, int dy2) {
1770
+ int dx1, int dy1, int dx2, int dy2) {
1881
1771
  int sw = sx2 - sx1 + 1;
1882
1772
  int sh = sy2 - sy1 + 1;
1883
1773
  int dw = dx2 - dx1 + 1;
@@ -1908,29 +1798,24 @@ public class PImage implements PConstants, Cloneable {
1908
1798
  return !(dw <= 0 || dh <= 0);
1909
1799
  }
1910
1800
 
1801
+
1911
1802
  //////////////////////////////////////////////////////////////
1803
+
1804
+
1912
1805
  /**
1913
- * Internal blicodeer/resizer/copier from toxi. Uses bilinear filtering if
1914
- * smooth() has been enabled 'mode' determines the blending mode used in the
1915
- * process.
1806
+ * Internal blitter/resizer/copier from toxi.
1807
+ * Uses bilinear filtering if smooth() has been enabled
1808
+ * 'mode' determines the blending mode used in the process.
1916
1809
  */
1917
1810
  private void blit_resize(PImage img,
1918
- int srcX1, int srcY1, int srcX2, int srcY2,
1919
- int[] destPixels, int screenW, int screenH,
1920
- int destX1, int destY1, int destX2, int destY2,
1921
- int mode) {
1922
- if (srcX1 < 0) {
1923
- srcX1 = 0;
1924
- }
1925
- if (srcY1 < 0) {
1926
- srcY1 = 0;
1927
- }
1928
- if (srcX2 > img.pixelWidth) {
1929
- srcX2 = img.pixelWidth;
1930
- }
1931
- if (srcY2 > img.pixelHeight) {
1932
- srcY2 = img.pixelHeight;
1933
- }
1811
+ int srcX1, int srcY1, int srcX2, int srcY2,
1812
+ int[] destPixels, int screenW, int screenH,
1813
+ int destX1, int destY1, int destX2, int destY2,
1814
+ int mode) {
1815
+ if (srcX1 < 0) srcX1 = 0;
1816
+ if (srcY1 < 0) srcY1 = 0;
1817
+ if (srcX2 > img.pixelWidth) srcX2 = img.pixelWidth;
1818
+ if (srcY2 > img.pixelHeight) srcY2 = img.pixelHeight;
1934
1819
 
1935
1820
  int srcW = srcX2 - srcX1;
1936
1821
  int srcH = srcY2 - srcY1;
@@ -1940,14 +1825,13 @@ public class PImage implements PConstants, Cloneable {
1940
1825
  boolean smooth = true; // may as well go with the smoothing these days
1941
1826
 
1942
1827
  if (!smooth) {
1943
- srcW++;
1944
- srcH++;
1828
+ srcW++; srcH++;
1945
1829
  }
1946
1830
 
1947
- if (destW <= 0 || destH <= 0
1948
- || srcW <= 0 || srcH <= 0
1949
- || destX1 >= screenW || destY1 >= screenH
1950
- || srcX1 >= img.pixelWidth || srcY1 >= img.pixelHeight) {
1831
+ if (destW <= 0 || destH <= 0 ||
1832
+ srcW <= 0 || srcH <= 0 ||
1833
+ destX1 >= screenW || destY1 >= screenH ||
1834
+ srcX1 >= img.pixelWidth || srcY1 >= img.pixelHeight) {
1951
1835
  return;
1952
1836
  }
1953
1837
 
@@ -1980,201 +1864,201 @@ public class PImage implements PConstants, Cloneable {
1980
1864
 
1981
1865
  switch (mode) {
1982
1866
 
1983
- case BLEND:
1984
- for (int y = 0; y < destH; y++) {
1985
- filter_new_scanline();
1986
- for (int x = 0; x < destW; x++) {
1987
- // davbol - renamed old blend_multiply to blend_blend
1988
- destPixels[destOffset + x]
1989
- = blend_blend(destPixels[destOffset + x], filter_bilinear());
1990
- sX += dx;
1991
- }
1992
- destOffset += screenW;
1993
- srcYOffset += dy;
1867
+ case BLEND:
1868
+ for (int y = 0; y < destH; y++) {
1869
+ filter_new_scanline();
1870
+ for (int x = 0; x < destW; x++) {
1871
+ // davbol - renamed old blend_multiply to blend_blend
1872
+ destPixels[destOffset + x] =
1873
+ blend_blend(destPixels[destOffset + x], filter_bilinear());
1874
+ sX += dx;
1994
1875
  }
1995
- break;
1876
+ destOffset += screenW;
1877
+ srcYOffset += dy;
1878
+ }
1879
+ break;
1996
1880
 
1997
- case ADD:
1998
- for (int y = 0; y < destH; y++) {
1999
- filter_new_scanline();
2000
- for (int x = 0; x < destW; x++) {
2001
- destPixels[destOffset + x]
2002
- = blend_add_pin(destPixels[destOffset + x], filter_bilinear());
2003
- sX += dx;
2004
- }
2005
- destOffset += screenW;
2006
- srcYOffset += dy;
1881
+ case ADD:
1882
+ for (int y = 0; y < destH; y++) {
1883
+ filter_new_scanline();
1884
+ for (int x = 0; x < destW; x++) {
1885
+ destPixels[destOffset + x] =
1886
+ blend_add_pin(destPixels[destOffset + x], filter_bilinear());
1887
+ sX += dx;
2007
1888
  }
2008
- break;
1889
+ destOffset += screenW;
1890
+ srcYOffset += dy;
1891
+ }
1892
+ break;
2009
1893
 
2010
- case SUBTRACT:
2011
- for (int y = 0; y < destH; y++) {
2012
- filter_new_scanline();
2013
- for (int x = 0; x < destW; x++) {
2014
- destPixels[destOffset + x]
2015
- = blend_sub_pin(destPixels[destOffset + x], filter_bilinear());
2016
- sX += dx;
2017
- }
2018
- destOffset += screenW;
2019
- srcYOffset += dy;
1894
+ case SUBTRACT:
1895
+ for (int y = 0; y < destH; y++) {
1896
+ filter_new_scanline();
1897
+ for (int x = 0; x < destW; x++) {
1898
+ destPixels[destOffset + x] =
1899
+ blend_sub_pin(destPixels[destOffset + x], filter_bilinear());
1900
+ sX += dx;
2020
1901
  }
2021
- break;
1902
+ destOffset += screenW;
1903
+ srcYOffset += dy;
1904
+ }
1905
+ break;
2022
1906
 
2023
- case LIGHTEST:
2024
- for (int y = 0; y < destH; y++) {
2025
- filter_new_scanline();
2026
- for (int x = 0; x < destW; x++) {
2027
- destPixels[destOffset + x]
2028
- = blend_lightest(destPixels[destOffset + x], filter_bilinear());
2029
- sX += dx;
2030
- }
2031
- destOffset += screenW;
2032
- srcYOffset += dy;
1907
+ case LIGHTEST:
1908
+ for (int y = 0; y < destH; y++) {
1909
+ filter_new_scanline();
1910
+ for (int x = 0; x < destW; x++) {
1911
+ destPixels[destOffset + x] =
1912
+ blend_lightest(destPixels[destOffset + x], filter_bilinear());
1913
+ sX += dx;
2033
1914
  }
2034
- break;
1915
+ destOffset += screenW;
1916
+ srcYOffset += dy;
1917
+ }
1918
+ break;
2035
1919
 
2036
- case DARKEST:
2037
- for (int y = 0; y < destH; y++) {
2038
- filter_new_scanline();
2039
- for (int x = 0; x < destW; x++) {
2040
- destPixels[destOffset + x]
2041
- = blend_darkest(destPixels[destOffset + x], filter_bilinear());
2042
- sX += dx;
2043
- }
2044
- destOffset += screenW;
2045
- srcYOffset += dy;
1920
+ case DARKEST:
1921
+ for (int y = 0; y < destH; y++) {
1922
+ filter_new_scanline();
1923
+ for (int x = 0; x < destW; x++) {
1924
+ destPixels[destOffset + x] =
1925
+ blend_darkest(destPixels[destOffset + x], filter_bilinear());
1926
+ sX += dx;
2046
1927
  }
2047
- break;
1928
+ destOffset += screenW;
1929
+ srcYOffset += dy;
1930
+ }
1931
+ break;
2048
1932
 
2049
- case REPLACE:
2050
- for (int y = 0; y < destH; y++) {
2051
- filter_new_scanline();
2052
- for (int x = 0; x < destW; x++) {
2053
- destPixels[destOffset + x] = filter_bilinear();
2054
- sX += dx;
2055
- }
2056
- destOffset += screenW;
2057
- srcYOffset += dy;
1933
+ case REPLACE:
1934
+ for (int y = 0; y < destH; y++) {
1935
+ filter_new_scanline();
1936
+ for (int x = 0; x < destW; x++) {
1937
+ destPixels[destOffset + x] = filter_bilinear();
1938
+ sX += dx;
2058
1939
  }
2059
- break;
1940
+ destOffset += screenW;
1941
+ srcYOffset += dy;
1942
+ }
1943
+ break;
2060
1944
 
2061
- case DIFFERENCE:
2062
- for (int y = 0; y < destH; y++) {
2063
- filter_new_scanline();
2064
- for (int x = 0; x < destW; x++) {
2065
- destPixels[destOffset + x]
2066
- = blend_difference(destPixels[destOffset + x], filter_bilinear());
2067
- sX += dx;
2068
- }
2069
- destOffset += screenW;
2070
- srcYOffset += dy;
1945
+ case DIFFERENCE:
1946
+ for (int y = 0; y < destH; y++) {
1947
+ filter_new_scanline();
1948
+ for (int x = 0; x < destW; x++) {
1949
+ destPixels[destOffset + x] =
1950
+ blend_difference(destPixels[destOffset + x], filter_bilinear());
1951
+ sX += dx;
2071
1952
  }
2072
- break;
1953
+ destOffset += screenW;
1954
+ srcYOffset += dy;
1955
+ }
1956
+ break;
2073
1957
 
2074
- case EXCLUSION:
2075
- for (int y = 0; y < destH; y++) {
2076
- filter_new_scanline();
2077
- for (int x = 0; x < destW; x++) {
2078
- destPixels[destOffset + x]
2079
- = blend_exclusion(destPixels[destOffset + x], filter_bilinear());
2080
- sX += dx;
2081
- }
2082
- destOffset += screenW;
2083
- srcYOffset += dy;
1958
+ case EXCLUSION:
1959
+ for (int y = 0; y < destH; y++) {
1960
+ filter_new_scanline();
1961
+ for (int x = 0; x < destW; x++) {
1962
+ destPixels[destOffset + x] =
1963
+ blend_exclusion(destPixels[destOffset + x], filter_bilinear());
1964
+ sX += dx;
2084
1965
  }
2085
- break;
1966
+ destOffset += screenW;
1967
+ srcYOffset += dy;
1968
+ }
1969
+ break;
2086
1970
 
2087
- case MULTIPLY:
2088
- for (int y = 0; y < destH; y++) {
2089
- filter_new_scanline();
2090
- for (int x = 0; x < destW; x++) {
2091
- destPixels[destOffset + x]
2092
- = blend_multiply(destPixels[destOffset + x], filter_bilinear());
2093
- sX += dx;
2094
- }
2095
- destOffset += screenW;
2096
- srcYOffset += dy;
1971
+ case MULTIPLY:
1972
+ for (int y = 0; y < destH; y++) {
1973
+ filter_new_scanline();
1974
+ for (int x = 0; x < destW; x++) {
1975
+ destPixels[destOffset + x] =
1976
+ blend_multiply(destPixels[destOffset + x], filter_bilinear());
1977
+ sX += dx;
2097
1978
  }
2098
- break;
1979
+ destOffset += screenW;
1980
+ srcYOffset += dy;
1981
+ }
1982
+ break;
2099
1983
 
2100
- case SCREEN:
2101
- for (int y = 0; y < destH; y++) {
2102
- filter_new_scanline();
2103
- for (int x = 0; x < destW; x++) {
2104
- destPixels[destOffset + x]
2105
- = blend_screen(destPixels[destOffset + x], filter_bilinear());
2106
- sX += dx;
2107
- }
2108
- destOffset += screenW;
2109
- srcYOffset += dy;
1984
+ case SCREEN:
1985
+ for (int y = 0; y < destH; y++) {
1986
+ filter_new_scanline();
1987
+ for (int x = 0; x < destW; x++) {
1988
+ destPixels[destOffset + x] =
1989
+ blend_screen(destPixels[destOffset + x], filter_bilinear());
1990
+ sX += dx;
2110
1991
  }
2111
- break;
1992
+ destOffset += screenW;
1993
+ srcYOffset += dy;
1994
+ }
1995
+ break;
2112
1996
 
2113
- case OVERLAY:
2114
- for (int y = 0; y < destH; y++) {
2115
- filter_new_scanline();
2116
- for (int x = 0; x < destW; x++) {
2117
- destPixels[destOffset + x]
2118
- = blend_overlay(destPixels[destOffset + x], filter_bilinear());
2119
- sX += dx;
2120
- }
2121
- destOffset += screenW;
2122
- srcYOffset += dy;
1997
+ case OVERLAY:
1998
+ for (int y = 0; y < destH; y++) {
1999
+ filter_new_scanline();
2000
+ for (int x = 0; x < destW; x++) {
2001
+ destPixels[destOffset + x] =
2002
+ blend_overlay(destPixels[destOffset + x], filter_bilinear());
2003
+ sX += dx;
2123
2004
  }
2124
- break;
2005
+ destOffset += screenW;
2006
+ srcYOffset += dy;
2007
+ }
2008
+ break;
2125
2009
 
2126
- case HARD_LIGHT:
2127
- for (int y = 0; y < destH; y++) {
2128
- filter_new_scanline();
2129
- for (int x = 0; x < destW; x++) {
2130
- destPixels[destOffset + x]
2131
- = blend_hard_light(destPixels[destOffset + x], filter_bilinear());
2132
- sX += dx;
2133
- }
2134
- destOffset += screenW;
2135
- srcYOffset += dy;
2010
+ case HARD_LIGHT:
2011
+ for (int y = 0; y < destH; y++) {
2012
+ filter_new_scanline();
2013
+ for (int x = 0; x < destW; x++) {
2014
+ destPixels[destOffset + x] =
2015
+ blend_hard_light(destPixels[destOffset + x], filter_bilinear());
2016
+ sX += dx;
2136
2017
  }
2137
- break;
2018
+ destOffset += screenW;
2019
+ srcYOffset += dy;
2020
+ }
2021
+ break;
2138
2022
 
2139
- case SOFT_LIGHT:
2140
- for (int y = 0; y < destH; y++) {
2141
- filter_new_scanline();
2142
- for (int x = 0; x < destW; x++) {
2143
- destPixels[destOffset + x]
2144
- = blend_soft_light(destPixels[destOffset + x], filter_bilinear());
2145
- sX += dx;
2146
- }
2147
- destOffset += screenW;
2148
- srcYOffset += dy;
2023
+ case SOFT_LIGHT:
2024
+ for (int y = 0; y < destH; y++) {
2025
+ filter_new_scanline();
2026
+ for (int x = 0; x < destW; x++) {
2027
+ destPixels[destOffset + x] =
2028
+ blend_soft_light(destPixels[destOffset + x], filter_bilinear());
2029
+ sX += dx;
2149
2030
  }
2150
- break;
2031
+ destOffset += screenW;
2032
+ srcYOffset += dy;
2033
+ }
2034
+ break;
2151
2035
 
2152
- // davbol - proposed 2007-01-09
2153
- case DODGE:
2154
- for (int y = 0; y < destH; y++) {
2155
- filter_new_scanline();
2156
- for (int x = 0; x < destW; x++) {
2157
- destPixels[destOffset + x]
2158
- = blend_dodge(destPixels[destOffset + x], filter_bilinear());
2159
- sX += dx;
2160
- }
2161
- destOffset += screenW;
2162
- srcYOffset += dy;
2036
+ // davbol - proposed 2007-01-09
2037
+ case DODGE:
2038
+ for (int y = 0; y < destH; y++) {
2039
+ filter_new_scanline();
2040
+ for (int x = 0; x < destW; x++) {
2041
+ destPixels[destOffset + x] =
2042
+ blend_dodge(destPixels[destOffset + x], filter_bilinear());
2043
+ sX += dx;
2163
2044
  }
2164
- break;
2045
+ destOffset += screenW;
2046
+ srcYOffset += dy;
2047
+ }
2048
+ break;
2165
2049
 
2166
- case BURN:
2167
- for (int y = 0; y < destH; y++) {
2168
- filter_new_scanline();
2169
- for (int x = 0; x < destW; x++) {
2170
- destPixels[destOffset + x]
2171
- = blend_burn(destPixels[destOffset + x], filter_bilinear());
2172
- sX += dx;
2173
- }
2174
- destOffset += screenW;
2175
- srcYOffset += dy;
2050
+ case BURN:
2051
+ for (int y = 0; y < destH; y++) {
2052
+ filter_new_scanline();
2053
+ for (int x = 0; x < destW; x++) {
2054
+ destPixels[destOffset + x] =
2055
+ blend_burn(destPixels[destOffset + x], filter_bilinear());
2056
+ sX += dx;
2176
2057
  }
2177
- break;
2058
+ destOffset += screenW;
2059
+ srcYOffset += dy;
2060
+ }
2061
+ break;
2178
2062
 
2179
2063
  }
2180
2064
 
@@ -2182,235 +2066,236 @@ public class PImage implements PConstants, Cloneable {
2182
2066
  // nearest neighbour scaling (++fast!)
2183
2067
  switch (mode) {
2184
2068
 
2185
- case BLEND:
2186
- for (int y = 0; y < destH; y++) {
2187
- sX = srcXOffset;
2188
- sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
2189
- for (int x = 0; x < destW; x++) {
2190
- // davbol - renamed old blend_multiply to blend_blend
2191
- destPixels[destOffset + x]
2192
- = blend_blend(destPixels[destOffset + x],
2193
- srcBuffer[sY + (sX >> PRECISIONB)]);
2194
- sX += dx;
2195
- }
2196
- destOffset += screenW;
2197
- srcYOffset += dy;
2069
+ case BLEND:
2070
+ for (int y = 0; y < destH; y++) {
2071
+ sX = srcXOffset;
2072
+ sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
2073
+ for (int x = 0; x < destW; x++) {
2074
+ // davbol - renamed old blend_multiply to blend_blend
2075
+ destPixels[destOffset + x] =
2076
+ blend_blend(destPixels[destOffset + x],
2077
+ srcBuffer[sY + (sX >> PRECISIONB)]);
2078
+ sX += dx;
2198
2079
  }
2199
- break;
2080
+ destOffset += screenW;
2081
+ srcYOffset += dy;
2082
+ }
2083
+ break;
2200
2084
 
2201
- case ADD:
2202
- for (int y = 0; y < destH; y++) {
2203
- sX = srcXOffset;
2204
- sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
2205
- for (int x = 0; x < destW; x++) {
2206
- destPixels[destOffset + x]
2207
- = blend_add_pin(destPixels[destOffset + x],
2208
- srcBuffer[sY + (sX >> PRECISIONB)]);
2209
- sX += dx;
2210
- }
2211
- destOffset += screenW;
2212
- srcYOffset += dy;
2085
+ case ADD:
2086
+ for (int y = 0; y < destH; y++) {
2087
+ sX = srcXOffset;
2088
+ sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
2089
+ for (int x = 0; x < destW; x++) {
2090
+ destPixels[destOffset + x] =
2091
+ blend_add_pin(destPixels[destOffset + x],
2092
+ srcBuffer[sY + (sX >> PRECISIONB)]);
2093
+ sX += dx;
2213
2094
  }
2214
- break;
2095
+ destOffset += screenW;
2096
+ srcYOffset += dy;
2097
+ }
2098
+ break;
2215
2099
 
2216
- case SUBTRACT:
2217
- for (int y = 0; y < destH; y++) {
2218
- sX = srcXOffset;
2219
- sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
2220
- for (int x = 0; x < destW; x++) {
2221
- destPixels[destOffset + x]
2222
- = blend_sub_pin(destPixels[destOffset + x],
2223
- srcBuffer[sY + (sX >> PRECISIONB)]);
2224
- sX += dx;
2225
- }
2226
- destOffset += screenW;
2227
- srcYOffset += dy;
2100
+ case SUBTRACT:
2101
+ for (int y = 0; y < destH; y++) {
2102
+ sX = srcXOffset;
2103
+ sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
2104
+ for (int x = 0; x < destW; x++) {
2105
+ destPixels[destOffset + x] =
2106
+ blend_sub_pin(destPixels[destOffset + x],
2107
+ srcBuffer[sY + (sX >> PRECISIONB)]);
2108
+ sX += dx;
2228
2109
  }
2229
- break;
2110
+ destOffset += screenW;
2111
+ srcYOffset += dy;
2112
+ }
2113
+ break;
2230
2114
 
2231
- case LIGHTEST:
2232
- for (int y = 0; y < destH; y++) {
2233
- sX = srcXOffset;
2234
- sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
2235
- for (int x = 0; x < destW; x++) {
2236
- destPixels[destOffset + x]
2237
- = blend_lightest(destPixels[destOffset + x],
2238
- srcBuffer[sY + (sX >> PRECISIONB)]);
2239
- sX += dx;
2240
- }
2241
- destOffset += screenW;
2242
- srcYOffset += dy;
2115
+ case LIGHTEST:
2116
+ for (int y = 0; y < destH; y++) {
2117
+ sX = srcXOffset;
2118
+ sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
2119
+ for (int x = 0; x < destW; x++) {
2120
+ destPixels[destOffset + x] =
2121
+ blend_lightest(destPixels[destOffset + x],
2122
+ srcBuffer[sY + (sX >> PRECISIONB)]);
2123
+ sX += dx;
2243
2124
  }
2244
- break;
2125
+ destOffset += screenW;
2126
+ srcYOffset += dy;
2127
+ }
2128
+ break;
2245
2129
 
2246
- case DARKEST:
2247
- for (int y = 0; y < destH; y++) {
2248
- sX = srcXOffset;
2249
- sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
2250
- for (int x = 0; x < destW; x++) {
2251
- destPixels[destOffset + x]
2252
- = blend_darkest(destPixels[destOffset + x],
2253
- srcBuffer[sY + (sX >> PRECISIONB)]);
2254
- sX += dx;
2255
- }
2256
- destOffset += screenW;
2257
- srcYOffset += dy;
2130
+ case DARKEST:
2131
+ for (int y = 0; y < destH; y++) {
2132
+ sX = srcXOffset;
2133
+ sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
2134
+ for (int x = 0; x < destW; x++) {
2135
+ destPixels[destOffset + x] =
2136
+ blend_darkest(destPixels[destOffset + x],
2137
+ srcBuffer[sY + (sX >> PRECISIONB)]);
2138
+ sX += dx;
2258
2139
  }
2259
- break;
2140
+ destOffset += screenW;
2141
+ srcYOffset += dy;
2142
+ }
2143
+ break;
2260
2144
 
2261
- case REPLACE:
2262
- for (int y = 0; y < destH; y++) {
2263
- sX = srcXOffset;
2264
- sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
2265
- for (int x = 0; x < destW; x++) {
2266
- destPixels[destOffset + x] = srcBuffer[sY + (sX >> PRECISIONB)];
2267
- sX += dx;
2268
- }
2269
- destOffset += screenW;
2270
- srcYOffset += dy;
2145
+ case REPLACE:
2146
+ for (int y = 0; y < destH; y++) {
2147
+ sX = srcXOffset;
2148
+ sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
2149
+ for (int x = 0; x < destW; x++) {
2150
+ destPixels[destOffset + x] = srcBuffer[sY + (sX >> PRECISIONB)];
2151
+ sX += dx;
2271
2152
  }
2272
- break;
2153
+ destOffset += screenW;
2154
+ srcYOffset += dy;
2155
+ }
2156
+ break;
2273
2157
 
2274
- case DIFFERENCE:
2275
- for (int y = 0; y < destH; y++) {
2276
- sX = srcXOffset;
2277
- sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
2278
- for (int x = 0; x < destW; x++) {
2279
- destPixels[destOffset + x]
2280
- = blend_difference(destPixels[destOffset + x],
2281
- srcBuffer[sY + (sX >> PRECISIONB)]);
2282
- sX += dx;
2283
- }
2284
- destOffset += screenW;
2285
- srcYOffset += dy;
2158
+ case DIFFERENCE:
2159
+ for (int y = 0; y < destH; y++) {
2160
+ sX = srcXOffset;
2161
+ sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
2162
+ for (int x = 0; x < destW; x++) {
2163
+ destPixels[destOffset + x] =
2164
+ blend_difference(destPixels[destOffset + x],
2165
+ srcBuffer[sY + (sX >> PRECISIONB)]);
2166
+ sX += dx;
2286
2167
  }
2287
- break;
2168
+ destOffset += screenW;
2169
+ srcYOffset += dy;
2170
+ }
2171
+ break;
2288
2172
 
2289
- case EXCLUSION:
2290
- for (int y = 0; y < destH; y++) {
2291
- sX = srcXOffset;
2292
- sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
2293
- for (int x = 0; x < destW; x++) {
2294
- destPixels[destOffset + x]
2295
- = blend_exclusion(destPixels[destOffset + x],
2296
- srcBuffer[sY + (sX >> PRECISIONB)]);
2297
- sX += dx;
2298
- }
2299
- destOffset += screenW;
2300
- srcYOffset += dy;
2173
+ case EXCLUSION:
2174
+ for (int y = 0; y < destH; y++) {
2175
+ sX = srcXOffset;
2176
+ sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
2177
+ for (int x = 0; x < destW; x++) {
2178
+ destPixels[destOffset + x] =
2179
+ blend_exclusion(destPixels[destOffset + x],
2180
+ srcBuffer[sY + (sX >> PRECISIONB)]);
2181
+ sX += dx;
2301
2182
  }
2302
- break;
2183
+ destOffset += screenW;
2184
+ srcYOffset += dy;
2185
+ }
2186
+ break;
2303
2187
 
2304
- case MULTIPLY:
2305
- for (int y = 0; y < destH; y++) {
2306
- sX = srcXOffset;
2307
- sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
2308
- for (int x = 0; x < destW; x++) {
2309
- destPixels[destOffset + x]
2310
- = blend_multiply(destPixels[destOffset + x],
2311
- srcBuffer[sY + (sX >> PRECISIONB)]);
2312
- sX += dx;
2313
- }
2314
- destOffset += screenW;
2315
- srcYOffset += dy;
2188
+ case MULTIPLY:
2189
+ for (int y = 0; y < destH; y++) {
2190
+ sX = srcXOffset;
2191
+ sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
2192
+ for (int x = 0; x < destW; x++) {
2193
+ destPixels[destOffset + x] =
2194
+ blend_multiply(destPixels[destOffset + x],
2195
+ srcBuffer[sY + (sX >> PRECISIONB)]);
2196
+ sX += dx;
2316
2197
  }
2317
- break;
2198
+ destOffset += screenW;
2199
+ srcYOffset += dy;
2200
+ }
2201
+ break;
2318
2202
 
2319
- case SCREEN:
2320
- for (int y = 0; y < destH; y++) {
2321
- sX = srcXOffset;
2322
- sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
2323
- for (int x = 0; x < destW; x++) {
2324
- destPixels[destOffset + x]
2325
- = blend_screen(destPixels[destOffset + x],
2326
- srcBuffer[sY + (sX >> PRECISIONB)]);
2327
- sX += dx;
2328
- }
2329
- destOffset += screenW;
2330
- srcYOffset += dy;
2203
+ case SCREEN:
2204
+ for (int y = 0; y < destH; y++) {
2205
+ sX = srcXOffset;
2206
+ sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
2207
+ for (int x = 0; x < destW; x++) {
2208
+ destPixels[destOffset + x] =
2209
+ blend_screen(destPixels[destOffset + x],
2210
+ srcBuffer[sY + (sX >> PRECISIONB)]);
2211
+ sX += dx;
2331
2212
  }
2332
- break;
2213
+ destOffset += screenW;
2214
+ srcYOffset += dy;
2215
+ }
2216
+ break;
2333
2217
 
2334
- case OVERLAY:
2335
- for (int y = 0; y < destH; y++) {
2336
- sX = srcXOffset;
2337
- sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
2338
- for (int x = 0; x < destW; x++) {
2339
- destPixels[destOffset + x]
2340
- = blend_overlay(destPixels[destOffset + x],
2341
- srcBuffer[sY + (sX >> PRECISIONB)]);
2342
- sX += dx;
2343
- }
2344
- destOffset += screenW;
2345
- srcYOffset += dy;
2218
+ case OVERLAY:
2219
+ for (int y = 0; y < destH; y++) {
2220
+ sX = srcXOffset;
2221
+ sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
2222
+ for (int x = 0; x < destW; x++) {
2223
+ destPixels[destOffset + x] =
2224
+ blend_overlay(destPixels[destOffset + x],
2225
+ srcBuffer[sY + (sX >> PRECISIONB)]);
2226
+ sX += dx;
2346
2227
  }
2347
- break;
2228
+ destOffset += screenW;
2229
+ srcYOffset += dy;
2230
+ }
2231
+ break;
2348
2232
 
2349
- case HARD_LIGHT:
2350
- for (int y = 0; y < destH; y++) {
2351
- sX = srcXOffset;
2352
- sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
2353
- for (int x = 0; x < destW; x++) {
2354
- destPixels[destOffset + x]
2355
- = blend_hard_light(destPixels[destOffset + x],
2356
- srcBuffer[sY + (sX >> PRECISIONB)]);
2357
- sX += dx;
2358
- }
2359
- destOffset += screenW;
2360
- srcYOffset += dy;
2233
+ case HARD_LIGHT:
2234
+ for (int y = 0; y < destH; y++) {
2235
+ sX = srcXOffset;
2236
+ sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
2237
+ for (int x = 0; x < destW; x++) {
2238
+ destPixels[destOffset + x] =
2239
+ blend_hard_light(destPixels[destOffset + x],
2240
+ srcBuffer[sY + (sX >> PRECISIONB)]);
2241
+ sX += dx;
2361
2242
  }
2362
- break;
2243
+ destOffset += screenW;
2244
+ srcYOffset += dy;
2245
+ }
2246
+ break;
2363
2247
 
2364
- case SOFT_LIGHT:
2365
- for (int y = 0; y < destH; y++) {
2366
- sX = srcXOffset;
2367
- sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
2368
- for (int x = 0; x < destW; x++) {
2369
- destPixels[destOffset + x]
2370
- = blend_soft_light(destPixels[destOffset + x],
2371
- srcBuffer[sY + (sX >> PRECISIONB)]);
2372
- sX += dx;
2373
- }
2374
- destOffset += screenW;
2375
- srcYOffset += dy;
2248
+ case SOFT_LIGHT:
2249
+ for (int y = 0; y < destH; y++) {
2250
+ sX = srcXOffset;
2251
+ sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
2252
+ for (int x = 0; x < destW; x++) {
2253
+ destPixels[destOffset + x] =
2254
+ blend_soft_light(destPixels[destOffset + x],
2255
+ srcBuffer[sY + (sX >> PRECISIONB)]);
2256
+ sX += dx;
2376
2257
  }
2377
- break;
2258
+ destOffset += screenW;
2259
+ srcYOffset += dy;
2260
+ }
2261
+ break;
2378
2262
 
2379
- // davbol - proposed 2007-01-09
2380
- case DODGE:
2381
- for (int y = 0; y < destH; y++) {
2382
- sX = srcXOffset;
2383
- sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
2384
- for (int x = 0; x < destW; x++) {
2385
- destPixels[destOffset + x]
2386
- = blend_dodge(destPixels[destOffset + x],
2387
- srcBuffer[sY + (sX >> PRECISIONB)]);
2388
- sX += dx;
2389
- }
2390
- destOffset += screenW;
2391
- srcYOffset += dy;
2263
+ // davbol - proposed 2007-01-09
2264
+ case DODGE:
2265
+ for (int y = 0; y < destH; y++) {
2266
+ sX = srcXOffset;
2267
+ sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
2268
+ for (int x = 0; x < destW; x++) {
2269
+ destPixels[destOffset + x] =
2270
+ blend_dodge(destPixels[destOffset + x],
2271
+ srcBuffer[sY + (sX >> PRECISIONB)]);
2272
+ sX += dx;
2392
2273
  }
2393
- break;
2274
+ destOffset += screenW;
2275
+ srcYOffset += dy;
2276
+ }
2277
+ break;
2394
2278
 
2395
- case BURN:
2396
- for (int y = 0; y < destH; y++) {
2397
- sX = srcXOffset;
2398
- sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
2399
- for (int x = 0; x < destW; x++) {
2400
- destPixels[destOffset + x]
2401
- = blend_burn(destPixels[destOffset + x],
2402
- srcBuffer[sY + (sX >> PRECISIONB)]);
2403
- sX += dx;
2404
- }
2405
- destOffset += screenW;
2406
- srcYOffset += dy;
2279
+ case BURN:
2280
+ for (int y = 0; y < destH; y++) {
2281
+ sX = srcXOffset;
2282
+ sY = (srcYOffset >> PRECISIONB) * img.pixelWidth;
2283
+ for (int x = 0; x < destW; x++) {
2284
+ destPixels[destOffset + x] =
2285
+ blend_burn(destPixels[destOffset + x],
2286
+ srcBuffer[sY + (sX >> PRECISIONB)]);
2287
+ sX += dx;
2407
2288
  }
2408
- break;
2289
+ destOffset += screenW;
2290
+ srcYOffset += dy;
2291
+ }
2292
+ break;
2409
2293
 
2410
2294
  }
2411
2295
  }
2412
2296
  }
2413
2297
 
2298
+
2414
2299
  private void filter_new_scanline() {
2415
2300
  sX = srcXOffset;
2416
2301
  fracV = srcYOffset & PREC_MAXVAL;
@@ -2419,6 +2304,7 @@ public class PImage implements PConstants, Cloneable {
2419
2304
  v2 = min((srcYOffset >> PRECISIONB) + 1, ih1) * iw;
2420
2305
  }
2421
2306
 
2307
+
2422
2308
  private int filter_bilinear() {
2423
2309
  fracU = sX & PREC_MAXVAL;
2424
2310
  ifU = PREC_MAXVAL - fracU + 1;
@@ -2435,36 +2321,44 @@ public class PImage implements PConstants, Cloneable {
2435
2321
  cLL = srcBuffer[v2 + u1];
2436
2322
  cLR = srcBuffer[v2 + u2];
2437
2323
 
2438
- r = ((ul * ((cUL & RED_MASK) >> 16) + ll * ((cLL & RED_MASK) >> 16)
2439
- + ur * ((cUR & RED_MASK) >> 16) + lr * ((cLR & RED_MASK) >> 16))
2440
- << PREC_RED_SHIFT) & RED_MASK;
2324
+ r = ((ul*((cUL&RED_MASK)>>16) + ll*((cLL&RED_MASK)>>16) +
2325
+ ur*((cUR&RED_MASK)>>16) + lr*((cLR&RED_MASK)>>16))
2326
+ << PREC_RED_SHIFT) & RED_MASK;
2441
2327
 
2442
- g = ((ul * (cUL & GREEN_MASK) + ll * (cLL & GREEN_MASK)
2443
- + ur * (cUR & GREEN_MASK) + lr * (cLR & GREEN_MASK))
2444
- >>> PRECISIONB) & GREEN_MASK;
2328
+ g = ((ul*(cUL&GREEN_MASK) + ll*(cLL&GREEN_MASK) +
2329
+ ur*(cUR&GREEN_MASK) + lr*(cLR&GREEN_MASK))
2330
+ >>> PRECISIONB) & GREEN_MASK;
2445
2331
 
2446
- b = (ul * (cUL & BLUE_MASK) + ll * (cLL & BLUE_MASK)
2447
- + ur * (cUR & BLUE_MASK) + lr * (cLR & BLUE_MASK))
2448
- >>> PRECISIONB;
2332
+ b = (ul*(cUL&BLUE_MASK) + ll*(cLL&BLUE_MASK) +
2333
+ ur*(cUR&BLUE_MASK) + lr*(cLR&BLUE_MASK))
2334
+ >>> PRECISIONB;
2449
2335
 
2450
- a = ((ul * ((cUL & ALPHA_MASK) >>> 24) + ll * ((cLL & ALPHA_MASK) >>> 24)
2451
- + ur * ((cUR & ALPHA_MASK) >>> 24) + lr * ((cLR & ALPHA_MASK) >>> 24))
2452
- << PREC_ALPHA_SHIFT) & ALPHA_MASK;
2336
+ a = ((ul*((cUL&ALPHA_MASK)>>>24) + ll*((cLL&ALPHA_MASK)>>>24) +
2337
+ ur*((cUR&ALPHA_MASK)>>>24) + lr*((cLR&ALPHA_MASK)>>>24))
2338
+ << PREC_ALPHA_SHIFT) & ALPHA_MASK;
2453
2339
 
2454
2340
  return a | r | g | b;
2455
2341
  }
2456
2342
 
2343
+
2344
+
2457
2345
  //////////////////////////////////////////////////////////////
2346
+
2458
2347
  // internal blending methods
2348
+
2349
+
2459
2350
  private static int min(int a, int b) {
2460
2351
  return (a < b) ? a : b;
2461
2352
  }
2462
2353
 
2354
+
2463
2355
  private static int max(int a, int b) {
2464
2356
  return (a > b) ? a : b;
2465
2357
  }
2466
2358
 
2359
+
2467
2360
  /////////////////////////////////////////////////////////////
2361
+
2468
2362
  // BLEND MODE IMPLEMENTATIONS
2469
2363
 
2470
2364
  /*
@@ -2502,16 +2396,16 @@ public class PImage implements PConstants, Cloneable {
2502
2396
  * 2) Behavior at extremes (set colorCount to 256):
2503
2397
  * - values of all corners are printed to the console
2504
2398
  * 3) Rounding errors:
2505
- * - set colorCount to lower value to becodeer see color bands
2399
+ * - set colorCount to lower value to better see color bands
2506
2400
  *
2507
2401
 
2508
2402
  // use powers of 2 in range 2..256
2509
- // to becodeer see color bands
2403
+ // to better see color bands
2510
2404
  final int colorCount = 256;
2511
2405
 
2512
2406
  final int blockSize = 3;
2513
2407
 
2514
- void secodeings() {
2408
+ void settings() {
2515
2409
  size(blockSize * 256, blockSize * 256);
2516
2410
  }
2517
2411
 
@@ -2553,11 +2447,13 @@ int testFunction(int dst, int src) {
2553
2447
  *
2554
2448
  *
2555
2449
  */
2450
+
2556
2451
  private static final int RB_MASK = 0x00FF00FF;
2557
2452
  private static final int GN_MASK = 0x0000FF00;
2558
2453
 
2559
2454
  /**
2560
- * Blend O = S
2455
+ * Blend
2456
+ * O = S
2561
2457
  */
2562
2458
  private static int blend_blend(int dst, int src) {
2563
2459
  int a = src >>> 24;
@@ -2565,13 +2461,15 @@ int testFunction(int dst, int src) {
2565
2461
  int s_a = a + (a >= 0x7F ? 1 : 0);
2566
2462
  int d_a = 0x100 - s_a;
2567
2463
 
2568
- return min((dst >>> 24) + a, 0xFF) << 24
2569
- | ((dst & RB_MASK) * d_a + (src & RB_MASK) * s_a) >>> 8 & RB_MASK
2570
- | ((dst & GN_MASK) * d_a + (src & GN_MASK) * s_a) >>> 8 & GN_MASK;
2464
+ return min((dst >>> 24) + a, 0xFF) << 24 |
2465
+ ((dst & RB_MASK) * d_a + (src & RB_MASK) * s_a) >>> 8 & RB_MASK |
2466
+ ((dst & GN_MASK) * d_a + (src & GN_MASK) * s_a) >>> 8 & GN_MASK;
2571
2467
  }
2572
2468
 
2469
+
2573
2470
  /**
2574
- * Add O = MIN(D + S, 1)
2471
+ * Add
2472
+ * O = MIN(D + S, 1)
2575
2473
  */
2576
2474
  private static int blend_add_pin(int dst, int src) {
2577
2475
  int a = src >>> 24;
@@ -2581,31 +2479,35 @@ int testFunction(int dst, int src) {
2581
2479
  int rb = (dst & RB_MASK) + ((src & RB_MASK) * s_a >>> 8 & RB_MASK);
2582
2480
  int gn = (dst & GN_MASK) + ((src & GN_MASK) * s_a >>> 8);
2583
2481
 
2584
- return min((dst >>> 24) + a, 0xFF) << 24
2585
- | min(rb & 0xFFFF0000, RED_MASK)
2586
- | min(gn & 0x00FFFF00, GREEN_MASK)
2587
- | min(rb & 0x0000FFFF, BLUE_MASK);
2482
+ return min((dst >>> 24) + a, 0xFF) << 24 |
2483
+ min(rb & 0xFFFF0000, RED_MASK) |
2484
+ min(gn & 0x00FFFF00, GREEN_MASK) |
2485
+ min(rb & 0x0000FFFF, BLUE_MASK);
2588
2486
  }
2589
2487
 
2488
+
2590
2489
  /**
2591
- * Subtract O = MAX(0, D - S)
2490
+ * Subtract
2491
+ * O = MAX(0, D - S)
2592
2492
  */
2593
2493
  private static int blend_sub_pin(int dst, int src) {
2594
2494
  int a = src >>> 24;
2595
2495
 
2596
2496
  int s_a = a + (a >= 0x7F ? 1 : 0);
2597
2497
 
2598
- int rb = ((src & RB_MASK) * s_a >>> 8);
2498
+ int rb = ((src & RB_MASK) * s_a >>> 8);
2599
2499
  int gn = ((src & GREEN_MASK) * s_a >>> 8);
2600
2500
 
2601
- return min((dst >>> 24) + a, 0xFF) << 24
2602
- | max((dst & RED_MASK) - (rb & RED_MASK), 0)
2603
- | max((dst & GREEN_MASK) - (gn & GREEN_MASK), 0)
2604
- | max((dst & BLUE_MASK) - (rb & BLUE_MASK), 0);
2501
+ return min((dst >>> 24) + a, 0xFF) << 24 |
2502
+ max((dst & RED_MASK) - (rb & RED_MASK), 0) |
2503
+ max((dst & GREEN_MASK) - (gn & GREEN_MASK), 0) |
2504
+ max((dst & BLUE_MASK) - (rb & BLUE_MASK), 0);
2605
2505
  }
2606
2506
 
2507
+
2607
2508
  /**
2608
- * Lightest O = MAX(D, S)
2509
+ * Lightest
2510
+ * O = MAX(D, S)
2609
2511
  */
2610
2512
  private static int blend_lightest(int dst, int src) {
2611
2513
  int a = src >>> 24;
@@ -2613,17 +2515,19 @@ int testFunction(int dst, int src) {
2613
2515
  int s_a = a + (a >= 0x7F ? 1 : 0);
2614
2516
  int d_a = 0x100 - s_a;
2615
2517
 
2616
- int rb = max(src & RED_MASK, dst & RED_MASK)
2617
- | max(src & BLUE_MASK, dst & BLUE_MASK);
2518
+ int rb = max(src & RED_MASK, dst & RED_MASK) |
2519
+ max(src & BLUE_MASK, dst & BLUE_MASK);
2618
2520
  int gn = max(src & GREEN_MASK, dst & GREEN_MASK);
2619
2521
 
2620
- return min((dst >>> 24) + a, 0xFF) << 24
2621
- | ((dst & RB_MASK) * d_a + rb * s_a) >>> 8 & RB_MASK
2622
- | ((dst & GN_MASK) * d_a + gn * s_a) >>> 8 & GN_MASK;
2522
+ return min((dst >>> 24) + a, 0xFF) << 24 |
2523
+ ((dst & RB_MASK) * d_a + rb * s_a) >>> 8 & RB_MASK |
2524
+ ((dst & GN_MASK) * d_a + gn * s_a) >>> 8 & GN_MASK;
2623
2525
  }
2624
2526
 
2527
+
2625
2528
  /**
2626
- * Darkest O = MIN(D, S)
2529
+ * Darkest
2530
+ * O = MIN(D, S)
2627
2531
  */
2628
2532
  private static int blend_darkest(int dst, int src) {
2629
2533
  int a = src >>> 24;
@@ -2631,17 +2535,19 @@ int testFunction(int dst, int src) {
2631
2535
  int s_a = a + (a >= 0x7F ? 1 : 0);
2632
2536
  int d_a = 0x100 - s_a;
2633
2537
 
2634
- int rb = min(src & RED_MASK, dst & RED_MASK)
2635
- | min(src & BLUE_MASK, dst & BLUE_MASK);
2538
+ int rb = min(src & RED_MASK, dst & RED_MASK) |
2539
+ min(src & BLUE_MASK, dst & BLUE_MASK);
2636
2540
  int gn = min(src & GREEN_MASK, dst & GREEN_MASK);
2637
2541
 
2638
- return min((dst >>> 24) + a, 0xFF) << 24
2639
- | ((dst & RB_MASK) * d_a + rb * s_a) >>> 8 & RB_MASK
2640
- | ((dst & GN_MASK) * d_a + gn * s_a) >>> 8 & GN_MASK;
2542
+ return min((dst >>> 24) + a, 0xFF) << 24 |
2543
+ ((dst & RB_MASK) * d_a + rb * s_a) >>> 8 & RB_MASK |
2544
+ ((dst & GN_MASK) * d_a + gn * s_a) >>> 8 & GN_MASK;
2641
2545
  }
2642
2546
 
2547
+
2643
2548
  /**
2644
- * Difference O = ABS(D - S)
2549
+ * Difference
2550
+ * O = ABS(D - S)
2645
2551
  */
2646
2552
  private static int blend_difference(int dst, int src) {
2647
2553
  int a = src >>> 24;
@@ -2649,21 +2555,24 @@ int testFunction(int dst, int src) {
2649
2555
  int s_a = a + (a >= 0x7F ? 1 : 0);
2650
2556
  int d_a = 0x100 - s_a;
2651
2557
 
2652
- int r = (dst & RED_MASK) - (src & RED_MASK);
2653
- int b = (dst & BLUE_MASK) - (src & BLUE_MASK);
2558
+ int r = (dst & RED_MASK) - (src & RED_MASK);
2559
+ int b = (dst & BLUE_MASK) - (src & BLUE_MASK);
2654
2560
  int g = (dst & GREEN_MASK) - (src & GREEN_MASK);
2655
2561
 
2656
- int rb = (r < 0 ? -r : r)
2657
- | (b < 0 ? -b : b);
2562
+ int rb = (r < 0 ? -r : r) |
2563
+ (b < 0 ? -b : b);
2658
2564
  int gn = (g < 0 ? -g : g);
2659
2565
 
2660
- return min((dst >>> 24) + a, 0xFF) << 24
2661
- | ((dst & RB_MASK) * d_a + rb * s_a) >>> 8 & RB_MASK
2662
- | ((dst & GN_MASK) * d_a + gn * s_a) >>> 8 & GN_MASK;
2566
+ return min((dst >>> 24) + a, 0xFF) << 24 |
2567
+ ((dst & RB_MASK) * d_a + rb * s_a) >>> 8 & RB_MASK |
2568
+ ((dst & GN_MASK) * d_a + gn * s_a) >>> 8 & GN_MASK;
2663
2569
  }
2664
2570
 
2571
+
2665
2572
  /**
2666
- * Exclusion O = (1 - S)D + S(1 - D) O = D + S - 2DS
2573
+ * Exclusion
2574
+ * O = (1 - S)D + S(1 - D)
2575
+ * O = D + S - 2DS
2667
2576
  */
2668
2577
  private static int blend_exclusion(int dst, int src) {
2669
2578
  int a = src >>> 24;
@@ -2679,16 +2588,16 @@ int testFunction(int dst, int src) {
2679
2588
  int f_r = (dst & RED_MASK) >> 16;
2680
2589
  int f_b = (dst & BLUE_MASK);
2681
2590
 
2682
- int rb_sub
2683
- = ((src & RED_MASK) * (f_r + (f_r >= 0x7F ? 1 : 0))
2684
- | (src & BLUE_MASK) * (f_b + (f_b >= 0x7F ? 1 : 0)))
2685
- >>> 7 & 0x01FF01FF;
2591
+ int rb_sub =
2592
+ ((src & RED_MASK) * (f_r + (f_r >= 0x7F ? 1 : 0)) |
2593
+ (src & BLUE_MASK) * (f_b + (f_b >= 0x7F ? 1 : 0)))
2594
+ >>> 7 & 0x01FF01FF;
2686
2595
  int gn_sub = s_gn * (d_gn + (d_gn >= 0x7F00 ? 0x100 : 0))
2687
- >>> 15 & 0x0001FF00;
2596
+ >>> 15 & 0x0001FF00;
2688
2597
 
2689
- return min((dst >>> 24) + a, 0xFF) << 24
2690
- | (d_rb * d_a + (d_rb + (src & RB_MASK) - rb_sub) * s_a) >>> 8 & RB_MASK
2691
- | (d_gn * d_a + (d_gn + s_gn - gn_sub) * s_a) >>> 8 & GN_MASK;
2598
+ return min((dst >>> 24) + a, 0xFF) << 24 |
2599
+ (d_rb * d_a + (d_rb + (src & RB_MASK) - rb_sub) * s_a) >>> 8 & RB_MASK |
2600
+ (d_gn * d_a + (d_gn + s_gn - gn_sub) * s_a) >>> 8 & GN_MASK;
2692
2601
  }
2693
2602
 
2694
2603
 
@@ -2707,21 +2616,24 @@ int testFunction(int dst, int src) {
2707
2616
  int f_r = (dst & RED_MASK) >> 16;
2708
2617
  int f_b = (dst & BLUE_MASK);
2709
2618
 
2710
- int rb
2711
- = ((src & RED_MASK) * (f_r + 1)
2712
- | (src & BLUE_MASK) * (f_b + 1))
2713
- >>> 8 & RB_MASK;
2714
- int gn
2715
- = (src & GREEN_MASK) * (d_gn + 0x100)
2716
- >>> 16 & GN_MASK;
2619
+ int rb =
2620
+ ((src & RED_MASK) * (f_r + 1) |
2621
+ (src & BLUE_MASK) * (f_b + 1))
2622
+ >>> 8 & RB_MASK;
2623
+ int gn =
2624
+ (src & GREEN_MASK) * (d_gn + 0x100)
2625
+ >>> 16 & GN_MASK;
2717
2626
 
2718
- return min((dst >>> 24) + a, 0xFF) << 24
2719
- | ((dst & RB_MASK) * d_a + rb * s_a) >>> 8 & RB_MASK
2720
- | (d_gn * d_a + gn * s_a) >>> 8 & GN_MASK;
2627
+ return min((dst >>> 24) + a, 0xFF) << 24 |
2628
+ ((dst & RB_MASK) * d_a + rb * s_a) >>> 8 & RB_MASK |
2629
+ (d_gn * d_a + gn * s_a) >>> 8 & GN_MASK;
2721
2630
  }
2722
2631
 
2632
+
2723
2633
  /**
2724
- * Screen O = 1 - (1 - D)(1 - S) O = D + S - DS
2634
+ * Screen
2635
+ * O = 1 - (1 - D)(1 - S)
2636
+ * O = D + S - DS
2725
2637
  */
2726
2638
  private static int blend_screen(int dst, int src) {
2727
2639
  int a = src >>> 24;
@@ -2737,21 +2649,23 @@ int testFunction(int dst, int src) {
2737
2649
  int f_r = (dst & RED_MASK) >> 16;
2738
2650
  int f_b = (dst & BLUE_MASK);
2739
2651
 
2740
- int rb_sub
2741
- = ((src & RED_MASK) * (f_r + 1)
2742
- | (src & BLUE_MASK) * (f_b + 1))
2743
- >>> 8 & RB_MASK;
2652
+ int rb_sub =
2653
+ ((src & RED_MASK) * (f_r + 1) |
2654
+ (src & BLUE_MASK) * (f_b + 1))
2655
+ >>> 8 & RB_MASK;
2744
2656
  int gn_sub = s_gn * (d_gn + 0x100)
2745
- >>> 16 & GN_MASK;
2657
+ >>> 16 & GN_MASK;
2746
2658
 
2747
- return min((dst >>> 24) + a, 0xFF) << 24
2748
- | (d_rb * d_a + (d_rb + (src & RB_MASK) - rb_sub) * s_a) >>> 8 & RB_MASK
2749
- | (d_gn * d_a + (d_gn + s_gn - gn_sub) * s_a) >>> 8 & GN_MASK;
2659
+ return min((dst >>> 24) + a, 0xFF) << 24 |
2660
+ (d_rb * d_a + (d_rb + (src & RB_MASK) - rb_sub) * s_a) >>> 8 & RB_MASK |
2661
+ (d_gn * d_a + (d_gn + s_gn - gn_sub) * s_a) >>> 8 & GN_MASK;
2750
2662
  }
2751
2663
 
2664
+
2752
2665
  /**
2753
- * Overlay O = 2 * MULTIPLY(D, S) = 2DS for D < 0.5 O = 2 * SCREEN(D, S) - 1 =
2754
- * 2(S + D - DS) - 1 otherwise
2666
+ * Overlay
2667
+ * O = 2 * MULTIPLY(D, S) = 2DS for D < 0.5
2668
+ * O = 2 * SCREEN(D, S) - 1 = 2(S + D - DS) - 1 otherwise
2755
2669
  */
2756
2670
  private static int blend_overlay(int dst, int src) {
2757
2671
  int a = src >>> 24;
@@ -2767,26 +2681,28 @@ int testFunction(int dst, int src) {
2767
2681
  int s_g = src & GREEN_MASK;
2768
2682
  int s_b = src & BLUE_MASK;
2769
2683
 
2770
- int r = (d_r < 0x800000)
2771
- ? d_r * ((s_r >>> 16) + 1) >>> 7
2772
- : 0xFF0000 - ((0x100 - (s_r >>> 16)) * (RED_MASK - d_r) >>> 7);
2773
- int g = (d_g < 0x8000)
2774
- ? d_g * (s_g + 0x100) >>> 15
2775
- : (0xFF00 - ((0x10000 - s_g) * (GREEN_MASK - d_g) >>> 15));
2776
- int b = (d_b < 0x80)
2777
- ? d_b * (s_b + 1) >>> 7
2778
- : (0xFF00 - ((0x100 - s_b) * (BLUE_MASK - d_b) << 1)) >>> 8;
2684
+ int r = (d_r < 0x800000) ?
2685
+ d_r * ((s_r >>> 16) + 1) >>> 7 :
2686
+ 0xFF0000 - ((0x100 - (s_r >>> 16)) * (RED_MASK - d_r) >>> 7);
2687
+ int g = (d_g < 0x8000) ?
2688
+ d_g * (s_g + 0x100) >>> 15 :
2689
+ (0xFF00 - ((0x10000 - s_g) * (GREEN_MASK - d_g) >>> 15));
2690
+ int b = (d_b < 0x80) ?
2691
+ d_b * (s_b + 1) >>> 7 :
2692
+ (0xFF00 - ((0x100 - s_b) * (BLUE_MASK - d_b) << 1)) >>> 8;
2779
2693
 
2780
- return min((dst >>> 24) + a, 0xFF) << 24
2781
- | ((dst & RB_MASK) * d_a + ((r | b) & RB_MASK) * s_a) >>> 8 & RB_MASK
2782
- | ((dst & GN_MASK) * d_a + (g & GN_MASK) * s_a) >>> 8 & GN_MASK;
2694
+ return min((dst >>> 24) + a, 0xFF) << 24 |
2695
+ ((dst & RB_MASK) * d_a + ((r | b) & RB_MASK) * s_a) >>> 8 & RB_MASK |
2696
+ ((dst & GN_MASK) * d_a + (g & GN_MASK) * s_a) >>> 8 & GN_MASK;
2783
2697
  }
2784
2698
 
2699
+
2785
2700
  /**
2786
- * Hard Light O = OVERLAY(S, D)
2701
+ * Hard Light
2702
+ * O = OVERLAY(S, D)
2787
2703
  *
2788
- * O = 2 * MULTIPLY(D, S) = 2DS for S < 0.5 O = 2 * SCREEN(D, S) - 1 = 2(S + D
2789
- * - DS) - 1 otherwise
2704
+ * O = 2 * MULTIPLY(D, S) = 2DS for S < 0.5
2705
+ * O = 2 * SCREEN(D, S) - 1 = 2(S + D - DS) - 1 otherwise
2790
2706
  */
2791
2707
  private static int blend_hard_light(int dst, int src) {
2792
2708
  int a = src >>> 24;
@@ -2802,24 +2718,27 @@ int testFunction(int dst, int src) {
2802
2718
  int s_g = src & GREEN_MASK;
2803
2719
  int s_b = src & BLUE_MASK;
2804
2720
 
2805
- int r = (s_r < 0x800000)
2806
- ? s_r * ((d_r >>> 16) + 1) >>> 7
2807
- : 0xFF0000 - ((0x100 - (d_r >>> 16)) * (RED_MASK - s_r) >>> 7);
2808
- int g = (s_g < 0x8000)
2809
- ? s_g * (d_g + 0x100) >>> 15
2810
- : (0xFF00 - ((0x10000 - d_g) * (GREEN_MASK - s_g) >>> 15));
2811
- int b = (s_b < 0x80)
2812
- ? s_b * (d_b + 1) >>> 7
2813
- : (0xFF00 - ((0x100 - d_b) * (BLUE_MASK - s_b) << 1)) >>> 8;
2721
+ int r = (s_r < 0x800000) ?
2722
+ s_r * ((d_r >>> 16) + 1) >>> 7 :
2723
+ 0xFF0000 - ((0x100 - (d_r >>> 16)) * (RED_MASK - s_r) >>> 7);
2724
+ int g = (s_g < 0x8000) ?
2725
+ s_g * (d_g + 0x100) >>> 15 :
2726
+ (0xFF00 - ((0x10000 - d_g) * (GREEN_MASK - s_g) >>> 15));
2727
+ int b = (s_b < 0x80) ?
2728
+ s_b * (d_b + 1) >>> 7 :
2729
+ (0xFF00 - ((0x100 - d_b) * (BLUE_MASK - s_b) << 1)) >>> 8;
2814
2730
 
2815
- return min((dst >>> 24) + a, 0xFF) << 24
2816
- | ((dst & RB_MASK) * d_a + ((r | b) & RB_MASK) * s_a) >>> 8 & RB_MASK
2817
- | ((dst & GN_MASK) * d_a + (g & GN_MASK) * s_a) >>> 8 & GN_MASK;
2731
+ return min((dst >>> 24) + a, 0xFF) << 24 |
2732
+ ((dst & RB_MASK) * d_a + ((r | b) & RB_MASK) * s_a) >>> 8 & RB_MASK |
2733
+ ((dst & GN_MASK) * d_a + (g & GN_MASK) * s_a) >>> 8 & GN_MASK;
2818
2734
  }
2819
2735
 
2736
+
2820
2737
  /**
2821
- * Soft Light (Pegtop) O = (1 - D) * MULTIPLY(D, S) + D * SCREEN(D, S) O = (1
2822
- * - D) * DS + D * (1 - (1 - D)(1 - S)) O = 2DS + DD - 2DDS
2738
+ * Soft Light (Pegtop)
2739
+ * O = (1 - D) * MULTIPLY(D, S) + D * SCREEN(D, S)
2740
+ * O = (1 - D) * DS + D * (1 - (1 - D)(1 - S))
2741
+ * O = 2DS + DD - 2DDS
2823
2742
  */
2824
2743
  private static int blend_soft_light(int dst, int src) {
2825
2744
  int a = src >>> 24;
@@ -2836,23 +2755,25 @@ int testFunction(int dst, int src) {
2836
2755
  int s_b1 = src & BLUE_MASK;
2837
2756
 
2838
2757
  int d_r1 = (d_r >> 16) + (s_r1 < 7F ? 1 : 0);
2839
- int d_g1 = (d_g >> 8) + (s_g1 < 7F ? 1 : 0);
2840
- int d_b1 = d_b + (s_b1 < 7F ? 1 : 0);
2758
+ int d_g1 = (d_g >> 8) + (s_g1 < 7F ? 1 : 0);
2759
+ int d_b1 = d_b + (s_b1 < 7F ? 1 : 0);
2841
2760
 
2842
- int r = (s_r1 * d_r >> 7) + 0xFF * d_r1 * (d_r1 + 1)
2843
- - ((s_r1 * d_r1 * d_r1) << 1) & RED_MASK;
2844
- int g = (s_g1 * d_g << 1) + 0xFF * d_g1 * (d_g1 + 1)
2845
- - ((s_g1 * d_g1 * d_g1) << 1) >>> 8 & GREEN_MASK;
2846
- int b = (s_b1 * d_b << 9) + 0xFF * d_b1 * (d_b1 + 1)
2847
- - ((s_b1 * d_b1 * d_b1) << 1) >>> 16;
2761
+ int r = (s_r1 * d_r >> 7) + 0xFF * d_r1 * (d_r1 + 1) -
2762
+ ((s_r1 * d_r1 * d_r1) << 1) & RED_MASK;
2763
+ int g = (s_g1 * d_g << 1) + 0xFF * d_g1 * (d_g1 + 1) -
2764
+ ((s_g1 * d_g1 * d_g1) << 1) >>> 8 & GREEN_MASK;
2765
+ int b = (s_b1 * d_b << 9) + 0xFF * d_b1 * (d_b1 + 1) -
2766
+ ((s_b1 * d_b1 * d_b1) << 1) >>> 16;
2848
2767
 
2849
- return min((dst >>> 24) + a, 0xFF) << 24
2850
- | ((dst & RB_MASK) * d_a + (r | b) * s_a) >>> 8 & RB_MASK
2851
- | ((dst & GN_MASK) * d_a + g * s_a) >>> 8 & GN_MASK;
2768
+ return min((dst >>> 24) + a, 0xFF) << 24 |
2769
+ ((dst & RB_MASK) * d_a + (r | b) * s_a) >>> 8 & RB_MASK |
2770
+ ((dst & GN_MASK) * d_a + g * s_a) >>> 8 & GN_MASK;
2852
2771
  }
2853
2772
 
2773
+
2854
2774
  /**
2855
- * Dodge O = D / (1 - S)
2775
+ * Dodge
2776
+ * O = D / (1 - S)
2856
2777
  */
2857
2778
  private static int blend_dodge(int dst, int src) {
2858
2779
  int a = src >>> 24;
@@ -2860,23 +2781,25 @@ int testFunction(int dst, int src) {
2860
2781
  int s_a = a + (a >= 0x7F ? 1 : 0);
2861
2782
  int d_a = 0x100 - s_a;
2862
2783
 
2863
- int r = (dst & RED_MASK) / (256 - ((src & RED_MASK) >> 16));
2784
+ int r = (dst & RED_MASK) / (256 - ((src & RED_MASK) >> 16));
2864
2785
  int g = ((dst & GREEN_MASK) << 8) / (256 - ((src & GREEN_MASK) >> 8));
2865
- int b = ((dst & BLUE_MASK) << 8) / (256 - (src & BLUE_MASK));
2786
+ int b = ((dst & BLUE_MASK) << 8) / (256 - (src & BLUE_MASK));
2866
2787
 
2867
- int rb
2868
- = (r > 0xFF00 ? 0xFF0000 : ((r << 8) & RED_MASK))
2869
- | (b > 0x00FF ? 0x0000FF : b);
2870
- int gn
2871
- = (g > 0xFF00 ? 0x00FF00 : (g & GREEN_MASK));
2788
+ int rb =
2789
+ (r > 0xFF00 ? 0xFF0000 : ((r << 8) & RED_MASK)) |
2790
+ (b > 0x00FF ? 0x0000FF : b);
2791
+ int gn =
2792
+ (g > 0xFF00 ? 0x00FF00 : (g & GREEN_MASK));
2872
2793
 
2873
- return min((dst >>> 24) + a, 0xFF) << 24
2874
- | ((dst & RB_MASK) * d_a + rb * s_a) >>> 8 & RB_MASK
2875
- | ((dst & GN_MASK) * d_a + gn * s_a) >>> 8 & GN_MASK;
2794
+ return min((dst >>> 24) + a, 0xFF) << 24 |
2795
+ ((dst & RB_MASK) * d_a + rb * s_a) >>> 8 & RB_MASK |
2796
+ ((dst & GN_MASK) * d_a + gn * s_a) >>> 8 & GN_MASK;
2876
2797
  }
2877
2798
 
2799
+
2878
2800
  /**
2879
- * Burn O = 1 - (1 - A) / B
2801
+ * Burn
2802
+ * O = 1 - (1 - A) / B
2880
2803
  */
2881
2804
  private static int blend_burn(int dst, int src) {
2882
2805
  int a = src >>> 24;
@@ -2884,59 +2807,61 @@ int testFunction(int dst, int src) {
2884
2807
  int s_a = a + (a >= 0x7F ? 1 : 0);
2885
2808
  int d_a = 0x100 - s_a;
2886
2809
 
2887
- int r = ((0xFF0000 - (dst & RED_MASK))) / (1 + (src & RED_MASK >> 16));
2810
+ int r = ((0xFF0000 - (dst & RED_MASK))) / (1 + (src & RED_MASK >> 16));
2888
2811
  int g = ((0x00FF00 - (dst & GREEN_MASK)) << 8) / (1 + (src & GREEN_MASK >> 8));
2889
- int b = ((0x0000FF - (dst & BLUE_MASK)) << 8) / (1 + (src & BLUE_MASK));
2812
+ int b = ((0x0000FF - (dst & BLUE_MASK)) << 8) / (1 + (src & BLUE_MASK));
2890
2813
 
2891
- int rb = RB_MASK
2892
- - (r > 0xFF00 ? 0xFF0000 : ((r << 8) & RED_MASK))
2893
- - (b > 0x00FF ? 0x0000FF : b);
2894
- int gn = GN_MASK
2895
- - (g > 0xFF00 ? 0x00FF00 : (g & GREEN_MASK));
2814
+ int rb = RB_MASK -
2815
+ (r > 0xFF00 ? 0xFF0000 : ((r << 8) & RED_MASK)) -
2816
+ (b > 0x00FF ? 0x0000FF : b);
2817
+ int gn = GN_MASK -
2818
+ (g > 0xFF00 ? 0x00FF00 : (g & GREEN_MASK));
2896
2819
 
2897
- return min((dst >>> 24) + a, 0xFF) << 24
2898
- | ((dst & RB_MASK) * d_a + rb * s_a) >>> 8 & RB_MASK
2899
- | ((dst & GN_MASK) * d_a + gn * s_a) >>> 8 & GN_MASK;
2820
+ return min((dst >>> 24) + a, 0xFF) << 24 |
2821
+ ((dst & RB_MASK) * d_a + rb * s_a) >>> 8 & RB_MASK |
2822
+ ((dst & GN_MASK) * d_a + gn * s_a) >>> 8 & GN_MASK;
2900
2823
  }
2901
2824
 
2825
+
2902
2826
  //////////////////////////////////////////////////////////////
2827
+
2903
2828
  // FILE I/O
2829
+
2830
+
2904
2831
  protected boolean saveImpl(String filename) {
2905
2832
  return false;
2906
2833
  }
2907
2834
 
2835
+
2908
2836
  static public PImage loadTIFF(InputStream input) { // ignore
2909
2837
  byte tiff[] = PApplet.loadBytes(input);
2910
2838
 
2911
- if ((tiff[42] != tiff[102])
2912
- || // width/height in both places
2913
- (tiff[43] != tiff[103])) {
2839
+ if ((tiff[42] != tiff[102]) || // width/height in both places
2840
+ (tiff[43] != tiff[103])) {
2914
2841
  System.err.println(TIFF_ERROR);
2915
2842
  return null;
2916
2843
  }
2917
2844
 
2918
- int width
2919
- = ((tiff[30] & 0xff) << 8) | (tiff[31] & 0xff);
2920
- int height
2921
- = ((tiff[42] & 0xff) << 8) | (tiff[43] & 0xff);
2845
+ int width =
2846
+ ((tiff[30] & 0xff) << 8) | (tiff[31] & 0xff);
2847
+ int height =
2848
+ ((tiff[42] & 0xff) << 8) | (tiff[43] & 0xff);
2922
2849
 
2923
- int count
2924
- = ((tiff[114] & 0xff) << 24)
2925
- | ((tiff[115] & 0xff) << 16)
2926
- | ((tiff[116] & 0xff) << 8)
2927
- | (tiff[117] & 0xff);
2850
+ int count =
2851
+ ((tiff[114] & 0xff) << 24) |
2852
+ ((tiff[115] & 0xff) << 16) |
2853
+ ((tiff[116] & 0xff) << 8) |
2854
+ (tiff[117] & 0xff);
2928
2855
  if (count != width * height * 3) {
2929
- System.err.println(TIFF_ERROR + " (" + width + ", " + height + ")");
2856
+ System.err.println(TIFF_ERROR + " (" + width + ", " + height +")");
2930
2857
  return null;
2931
2858
  }
2932
2859
 
2933
2860
  // check the rest of the header
2934
2861
  for (int i = 0; i < TIFF_HEADER.length; i++) {
2935
- if ((i == 30) || (i == 31) || (i == 42) || (i == 43)
2936
- || (i == 102) || (i == 103)
2937
- || (i == 114) || (i == 115) || (i == 116) || (i == 117)) {
2938
- continue;
2939
- }
2862
+ if ((i == 30) || (i == 31) || (i == 42) || (i == 43) ||
2863
+ (i == 102) || (i == 103) ||
2864
+ (i == 114) || (i == 115) || (i == 116) || (i == 117)) continue;
2940
2865
 
2941
2866
  if (tiff[i] != TIFF_HEADER[i]) {
2942
2867
  System.err.println(TIFF_ERROR + " (" + i + ")");
@@ -2948,23 +2873,23 @@ int testFunction(int dst, int src) {
2948
2873
  int index = 768;
2949
2874
  count /= 3;
2950
2875
  for (int i = 0; i < count; i++) {
2951
- outgoing.pixels[i]
2952
- = 0xFF000000
2953
- | (tiff[index++] & 0xff) << 16
2954
- | (tiff[index++] & 0xff) << 8
2955
- | (tiff[index++] & 0xff);
2876
+ outgoing.pixels[i] =
2877
+ 0xFF000000 |
2878
+ (tiff[index++] & 0xff) << 16 |
2879
+ (tiff[index++] & 0xff) << 8 |
2880
+ (tiff[index++] & 0xff);
2956
2881
  }
2957
2882
  return outgoing;
2958
2883
  }
2959
2884
 
2960
2885
  protected boolean saveTIFF(OutputStream output) {
2961
- // shucodeing off the warning, people can figure this out themselves
2886
+ // shutting off the warning, people can figure this out themselves
2962
2887
  /*
2963
2888
  if (format != RGB) {
2964
2889
  System.err.println("Warning: only RGB information is saved with " +
2965
2890
  ".tif files. Use .tga or .png for ARGB images and others.");
2966
2891
  }
2967
- */
2892
+ */
2968
2893
  try {
2969
2894
  byte[] tiff = new byte[768];
2970
2895
  System.arraycopy(TIFF_HEADER, 0, tiff, 0, TIFF_HEADER.length);
@@ -2974,7 +2899,7 @@ int testFunction(int dst, int src) {
2974
2899
  tiff[42] = tiff[102] = (byte) ((pixelHeight >> 8) & 0xff);
2975
2900
  tiff[43] = tiff[103] = (byte) ((pixelHeight) & 0xff);
2976
2901
 
2977
- int count = pixelWidth * pixelHeight * 3;
2902
+ int count = pixelWidth*pixelHeight*3;
2978
2903
  tiff[114] = (byte) ((count >> 24) & 0xff);
2979
2904
  tiff[115] = (byte) ((count >> 16) & 0xff);
2980
2905
  tiff[116] = (byte) ((count >> 8) & 0xff);
@@ -2992,35 +2917,31 @@ int testFunction(int dst, int src) {
2992
2917
  return true;
2993
2918
 
2994
2919
  } catch (IOException e) {
2995
-
2996
2920
  }
2997
2921
  return false;
2998
2922
  }
2999
2923
 
2924
+
3000
2925
  /**
3001
2926
  * Targa image loader for RLE-compressed TGA files.
3002
2927
  * <p>
3003
- * Rewricodeen for 0115 to read/write RLE-encoded targa images. For 0125,
3004
- * non-RLE encoded images are now supported, along with images whose y-order
3005
- * is reversed (which is standard for TGA files).
2928
+ * Rewritten for 0115 to read/write RLE-encoded targa images.
2929
+ * For 0125, non-RLE encoded images are now supported, along with
2930
+ * images whose y-order is reversed (which is standard for TGA files).
3006
2931
  * <p>
3007
- * A version of this function is in MovieMaker.java. Any fixes here should be
3008
- * applied over in MovieMaker as well.
2932
+ * A version of this function is in MovieMaker.java. Any fixes here
2933
+ * should be applied over in MovieMaker as well.
3009
2934
  * <p>
3010
2935
  * Known issue with RLE encoding and odd behavior in some apps:
3011
- * https://github.com/processing/processing/issues/2096 Please help!
3012
- * @param input
3013
- * @return
3014
- * @throws java.io.IOException
2936
+ * https://github.com/processing/processing/issues/2096
2937
+ * Please help!
3015
2938
  */
3016
2939
  static public PImage loadTGA(InputStream input) throws IOException { // ignore
3017
2940
  byte[] header = new byte[18];
3018
2941
  int offset = 0;
3019
2942
  do {
3020
2943
  int count = input.read(header, offset, header.length - offset);
3021
- if (count == -1) {
3022
- return null;
3023
- }
2944
+ if (count == -1) return null;
3024
2945
  offset += count;
3025
2946
  } while (offset < 18);
3026
2947
 
@@ -3039,26 +2960,23 @@ int testFunction(int dst, int src) {
3039
2960
 
3040
2961
  7 6 5 4 3 2 1 0
3041
2962
  128 64 32 16 8 4 2 1
3042
- */
2963
+ */
2964
+
3043
2965
  int format = 0;
3044
2966
 
3045
- if (((header[2] == 3) || (header[2] == 11))
3046
- && // B&W, plus RLE or not
3047
- (header[16] == 8)
3048
- && // 8 bits
3049
- ((header[17] == 0x8) || (header[17] == 0x28))) { // origin, 32 bit
2967
+ if (((header[2] == 3) || (header[2] == 11)) && // B&W, plus RLE or not
2968
+ (header[16] == 8) && // 8 bits
2969
+ ((header[17] == 0x8) || (header[17] == 0x28))) { // origin, 32 bit
3050
2970
  format = ALPHA;
3051
2971
 
3052
- } else if (((header[2] == 2) || (header[2] == 10))
3053
- && // RGB, RLE or not
3054
- (header[16] == 24)
3055
- && // 24 bits
3056
- ((header[17] == 0x20) || (header[17] == 0))) { // origin
2972
+ } else if (((header[2] == 2) || (header[2] == 10)) && // RGB, RLE or not
2973
+ (header[16] == 24) && // 24 bits
2974
+ ((header[17] == 0x20) || (header[17] == 0))) { // origin
3057
2975
  format = RGB;
3058
2976
 
3059
- } else if (((header[2] == 2) || (header[2] == 10))
3060
- && (header[16] == 32)
3061
- && ((header[17] == 0x8) || (header[17] == 0x28))) { // origin, 32
2977
+ } else if (((header[2] == 2) || (header[2] == 10)) &&
2978
+ (header[16] == 32) &&
2979
+ ((header[17] == 0x8) || (header[17] == 0x28))) { // origin, 32
3062
2980
  format = ARGB;
3063
2981
  }
3064
2982
 
@@ -3079,58 +2997,58 @@ int testFunction(int dst, int src) {
3079
2997
 
3080
2998
  if ((header[2] == 2) || (header[2] == 3)) { // not RLE encoded
3081
2999
  if (reversed) {
3082
- int index = (h - 1) * w;
3000
+ int index = (h-1) * w;
3083
3001
  switch (format) {
3084
- case ALPHA:
3085
- for (int y = h - 1; y >= 0; y--) {
3086
- for (int x = 0; x < w; x++) {
3087
- outgoing.pixels[index + x] = input.read();
3088
- }
3089
- index -= w;
3002
+ case ALPHA:
3003
+ for (int y = h-1; y >= 0; y--) {
3004
+ for (int x = 0; x < w; x++) {
3005
+ outgoing.pixels[index + x] = input.read();
3090
3006
  }
3091
- break;
3092
- case RGB:
3093
- for (int y = h - 1; y >= 0; y--) {
3094
- for (int x = 0; x < w; x++) {
3095
- outgoing.pixels[index + x]
3096
- = input.read() | (input.read() << 8) | (input.read() << 16)
3097
- | 0xff000000;
3098
- }
3099
- index -= w;
3007
+ index -= w;
3008
+ }
3009
+ break;
3010
+ case RGB:
3011
+ for (int y = h-1; y >= 0; y--) {
3012
+ for (int x = 0; x < w; x++) {
3013
+ outgoing.pixels[index + x] =
3014
+ input.read() | (input.read() << 8) | (input.read() << 16) |
3015
+ 0xff000000;
3100
3016
  }
3101
- break;
3102
- case ARGB:
3103
- for (int y = h - 1; y >= 0; y--) {
3104
- for (int x = 0; x < w; x++) {
3105
- outgoing.pixels[index + x]
3106
- = input.read() | (input.read() << 8) | (input.read() << 16)
3107
- | (input.read() << 24);
3108
- }
3109
- index -= w;
3017
+ index -= w;
3018
+ }
3019
+ break;
3020
+ case ARGB:
3021
+ for (int y = h-1; y >= 0; y--) {
3022
+ for (int x = 0; x < w; x++) {
3023
+ outgoing.pixels[index + x] =
3024
+ input.read() | (input.read() << 8) | (input.read() << 16) |
3025
+ (input.read() << 24);
3110
3026
  }
3027
+ index -= w;
3028
+ }
3111
3029
  }
3112
3030
  } else { // not reversed
3113
3031
  int count = w * h;
3114
3032
  switch (format) {
3115
- case ALPHA:
3116
- for (int i = 0; i < count; i++) {
3117
- outgoing.pixels[i] = input.read();
3118
- }
3119
- break;
3120
- case RGB:
3121
- for (int i = 0; i < count; i++) {
3122
- outgoing.pixels[i]
3123
- = input.read() | (input.read() << 8) | (input.read() << 16)
3124
- | 0xff000000;
3125
- }
3126
- break;
3127
- case ARGB:
3128
- for (int i = 0; i < count; i++) {
3129
- outgoing.pixels[i]
3130
- = input.read() | (input.read() << 8) | (input.read() << 16)
3131
- | (input.read() << 24);
3132
- }
3133
- break;
3033
+ case ALPHA:
3034
+ for (int i = 0; i < count; i++) {
3035
+ outgoing.pixels[i] = input.read();
3036
+ }
3037
+ break;
3038
+ case RGB:
3039
+ for (int i = 0; i < count; i++) {
3040
+ outgoing.pixels[i] =
3041
+ input.read() | (input.read() << 8) | (input.read() << 16) |
3042
+ 0xff000000;
3043
+ }
3044
+ break;
3045
+ case ARGB:
3046
+ for (int i = 0; i < count; i++) {
3047
+ outgoing.pixels[i] =
3048
+ input.read() | (input.read() << 8) | (input.read() << 16) |
3049
+ (input.read() << 24);
3050
+ }
3051
+ break;
3134
3052
  }
3135
3053
  }
3136
3054
 
@@ -3145,59 +3063,56 @@ int testFunction(int dst, int src) {
3145
3063
  num -= 127; // (num & 0x7F) + 1
3146
3064
  int pixel = 0;
3147
3065
  switch (format) {
3148
- case ALPHA:
3149
- pixel = input.read();
3150
- break;
3151
- case RGB:
3152
- pixel = 0xFF000000
3153
- | input.read() | (input.read() << 8) | (input.read() << 16);
3154
- //(is.read() << 16) | (is.read() << 8) | is.read();
3155
- break;
3156
- case ARGB:
3157
- pixel = input.read()
3158
- | (input.read() << 8) | (input.read() << 16) | (input.read() << 24);
3159
- break;
3066
+ case ALPHA:
3067
+ pixel = input.read();
3068
+ break;
3069
+ case RGB:
3070
+ pixel = 0xFF000000 |
3071
+ input.read() | (input.read() << 8) | (input.read() << 16);
3072
+ //(is.read() << 16) | (is.read() << 8) | is.read();
3073
+ break;
3074
+ case ARGB:
3075
+ pixel = input.read() |
3076
+ (input.read() << 8) | (input.read() << 16) | (input.read() << 24);
3077
+ break;
3160
3078
  }
3161
3079
  for (int i = 0; i < num; i++) {
3162
3080
  px[index++] = pixel;
3163
- if (index == px.length) {
3164
- break;
3165
- }
3081
+ if (index == px.length) break;
3166
3082
  }
3167
3083
  } else { // write up to 127 bytes as uncompressed
3168
3084
  num += 1;
3169
3085
  switch (format) {
3170
- case ALPHA:
3171
- for (int i = 0; i < num; i++) {
3172
- px[index++] = input.read();
3173
- }
3174
- break;
3175
- case RGB:
3176
- for (int i = 0; i < num; i++) {
3177
- px[index++] = 0xFF000000
3178
- | input.read() | (input.read() << 8) | (input.read() << 16);
3179
- //(is.read() << 16) | (is.read() << 8) | is.read();
3180
- }
3181
- break;
3182
- case ARGB:
3183
- for (int i = 0; i < num; i++) {
3184
- px[index++] = input.read()
3185
- | //(is.read() << 24) |
3186
- (input.read() << 8) | (input.read() << 16) | (input.read() << 24);
3187
- //(is.read() << 16) | (is.read() << 8) | is.read();
3188
- }
3189
- break;
3086
+ case ALPHA:
3087
+ for (int i = 0; i < num; i++) {
3088
+ px[index++] = input.read();
3089
+ }
3090
+ break;
3091
+ case RGB:
3092
+ for (int i = 0; i < num; i++) {
3093
+ px[index++] = 0xFF000000 |
3094
+ input.read() | (input.read() << 8) | (input.read() << 16);
3095
+ //(is.read() << 16) | (is.read() << 8) | is.read();
3096
+ }
3097
+ break;
3098
+ case ARGB:
3099
+ for (int i = 0; i < num; i++) {
3100
+ px[index++] = input.read() | //(is.read() << 24) |
3101
+ (input.read() << 8) | (input.read() << 16) | (input.read() << 24);
3102
+ //(is.read() << 16) | (is.read() << 8) | is.read();
3103
+ }
3104
+ break;
3190
3105
  }
3191
3106
  }
3192
3107
  }
3193
3108
 
3194
3109
  if (!reversed) {
3195
3110
  int[] temp = new int[w];
3196
- for (int y = 0; y < h / 2; y++) {
3197
- int z = (h - 1) - y;
3198
- System.arraycopy(px, y * w, temp, 0, w);
3199
- System.arraycopy(px, z * w, px, y * w, w);
3200
- System.arraycopy(temp, 0, px, z * w, w);
3111
+ for (int y = 0; y < h/2; y++) {
3112
+ int z = (h-1) - y;
3113
+ System.arraycopy(px, y*w, temp, 0, w);
3114
+ System.arraycopy(px, z*w, px, y*w, w);
3115
+ System.arraycopy(temp, 0, px, z*w, w);
3201
3116
  }
3202
3117
  }
3203
3118
  }
@@ -3205,25 +3120,24 @@ int testFunction(int dst, int src) {
3205
3120
  return outgoing;
3206
3121
  }
3207
3122
 
3123
+
3208
3124
  /**
3209
- * Creates a Targa32 formatted byte sequence of specified pixel buffer using
3210
- * RLE compression.
3125
+ * Creates a Targa32 formatted byte sequence of specified
3126
+ * pixel buffer using RLE compression.
3211
3127
  * <p>
3212
- * Also figured out how to avoid parsing the image upside-down (there's a
3213
- * header flag to set the image origin to top-left)
3214
- *
3215
- * Starting with revision 0092, the format secodeing is taken into account:
3216
- * <ul>
3217
- * <li><code>ALPHA</code> images wricodeen as 8bit grayscale (uses lowest byte)
3218
- * <li><code>RGB</code> &rarr; 24 bits
3219
- * <li><code>ARGB</code> &rarr; 32 bits
3220
- * </ul>
3221
- * All versions are RLE compressed.
3128
+ * Also figured out how to avoid parsing the image upside-down
3129
+ * (there's a header flag to set the image origin to top-left)
3222
3130
  * </p>
3131
+ * Starting with revision 0092, the format setting is taken into account:
3132
+ * <UL>
3133
+ * <LI><TT>ALPHA</TT> images written as 8bit grayscale (uses lowest byte)
3134
+ * <LI><TT>RGB</TT> &rarr; 24 bits
3135
+ * <LI><TT>ARGB</TT> &rarr; 32 bits
3136
+ * </UL>
3137
+ * All versions are RLE compressed.
3138
+ *
3223
3139
  * Contributed by toxi 8-10 May 2005, based on this RLE
3224
- * <a href="http://www.wotsit.org/download.asp?f=tga">specification</a>
3225
- * @param output
3226
- * @return
3140
+ * <A HREF="http://www.wotsit.org/download.asp?f=tga">specification</A>
3227
3141
  */
3228
3142
  protected boolean saveTGA(OutputStream output) {
3229
3143
  byte[] header = new byte[18];
@@ -3248,227 +3162,216 @@ int testFunction(int dst, int src) {
3248
3162
  default:
3249
3163
  throw new RuntimeException("Image format not recognized inside save()");
3250
3164
  }
3251
- // set image dimensions lo-hi byte order
3252
- header[12] = (byte) (pixelWidth & 0xff);
3253
- header[13] = (byte) (pixelWidth >> 8);
3254
- header[14] = (byte) (pixelHeight & 0xff);
3255
- header[15] = (byte) (pixelHeight >> 8);
3256
-
3257
- try {
3258
- output.write(header);
3259
-
3260
- int maxLen = pixelHeight * pixelWidth;
3261
- int index = 0;
3262
- int col; //, prevCol;
3263
- int[] currChunk = new int[128];
3264
-
3265
- // 8bit image exporter is in separate loop
3266
- // to avoid excessive conditionals...
3267
- if (format == ALPHA) {
3268
- while (index < maxLen) {
3269
- boolean isRLE = false;
3270
- int rle = 1;
3271
- currChunk[0] = col = pixels[index] & 0xff;
3272
- while (index + rle < maxLen) {
3273
- if (col != (pixels[index + rle] & 0xff) || rle == 128) {
3274
- isRLE = (rle > 1);
3275
- break;
3276
- }
3277
- rle++;
3278
- }
3279
- if (isRLE) {
3280
- output.write(0x80 | (rle - 1));
3281
- output.write(col);
3282
-
3283
- } else {
3284
- rle = 1;
3285
- while (index + rle < maxLen) {
3286
- int cscan = pixels[index + rle] & 0xff;
3287
- if ((col != cscan && rle < 128) || rle < 3) {
3288
- currChunk[rle] = col = cscan;
3289
- } else {
3290
- if (col == cscan) {
3291
- rle -= 2;
3292
- }
3293
- break;
3294
- }
3295
- rle++;
3296
- }
3297
- output.write(rle - 1);
3298
- for (int i = 0; i < rle; i++) {
3299
- output.write(currChunk[i]);
3300
- }
3301
- }
3302
- index += rle;
3303
- }
3304
- } else { // export 24/32 bit TARGA
3305
- while (index < maxLen) {
3306
- boolean isRLE = false;
3307
- currChunk[0] = col = pixels[index];
3308
- int rle = 1;
3309
- // try to find repeating bytes (min. len = 2 pixels)
3310
- // maximum chunk size is 128 pixels
3311
- while (index + rle < maxLen) {
3312
- if (col != pixels[index + rle] || rle == 128) {
3313
- isRLE = (rle > 1); // set flag for RLE chunk
3314
- break;
3315
- }
3316
- rle++;
3317
- }
3318
- if (isRLE) {
3319
- output.write(128 | (rle - 1));
3320
- output.write(col & 0xff);
3321
- output.write(col >> 8 & 0xff);
3322
- output.write(col >> 16 & 0xff);
3323
- if (format == ARGB) {
3324
- output.write(col >>> 24 & 0xff);
3325
- }
3326
-
3327
- } else { // not RLE
3328
- rle = 1;
3329
- while (index + rle < maxLen) {
3330
- if ((col != pixels[index + rle] && rle < 128) || rle < 3) {
3331
- currChunk[rle] = col = pixels[index + rle];
3332
- } else {
3333
- // check if the exit condition was the start of
3334
- // a repeating colour
3335
- if (col == pixels[index + rle]) {
3336
- rle -= 2;
3337
- }
3338
- break;
3339
- }
3340
- rle++;
3341
- }
3342
- // write uncompressed chunk
3343
- output.write(rle - 1);
3344
- if (format == ARGB) {
3345
- for (int i = 0; i < rle; i++) {
3346
- col = currChunk[i];
3347
- output.write(col & 0xff);
3348
- output.write(col >> 8 & 0xff);
3349
- output.write(col >> 16 & 0xff);
3350
- output.write(col >>> 24 & 0xff);
3351
- }
3352
- } else {
3353
- for (int i = 0; i < rle; i++) {
3354
- col = currChunk[i];
3355
- output.write(col & 0xff);
3356
- output.write(col >> 8 & 0xff);
3357
- output.write(col >> 16 & 0xff);
3358
- }
3359
- }
3360
- }
3361
- index += rle;
3362
- }
3363
- }
3364
- output.flush();
3365
- return true;
3366
-
3367
- } catch (IOException e) {
3368
-
3369
- return false;
3370
- }
3165
+ // set image dimensions lo-hi byte order
3166
+ header[12] = (byte) (pixelWidth & 0xff);
3167
+ header[13] = (byte) (pixelWidth >> 8);
3168
+ header[14] = (byte) (pixelHeight & 0xff);
3169
+ header[15] = (byte) (pixelHeight >> 8);
3170
+
3171
+ try {
3172
+ output.write(header);
3173
+
3174
+ int maxLen = pixelHeight * pixelWidth;
3175
+ int index = 0;
3176
+ int col; //, prevCol;
3177
+ int[] currChunk = new int[128];
3178
+
3179
+ // 8bit image exporter is in separate loop
3180
+ // to avoid excessive conditionals...
3181
+ if (format == ALPHA) {
3182
+ while (index < maxLen) {
3183
+ boolean isRLE = false;
3184
+ int rle = 1;
3185
+ currChunk[0] = col = pixels[index] & 0xff;
3186
+ while (index + rle < maxLen) {
3187
+ if (col != (pixels[index + rle]&0xff) || rle == 128) {
3188
+ isRLE = (rle > 1);
3189
+ break;
3190
+ }
3191
+ rle++;
3192
+ }
3193
+ if (isRLE) {
3194
+ output.write(0x80 | (rle - 1));
3195
+ output.write(col);
3196
+
3197
+ } else {
3198
+ rle = 1;
3199
+ while (index + rle < maxLen) {
3200
+ int cscan = pixels[index + rle] & 0xff;
3201
+ if ((col != cscan && rle < 128) || rle < 3) {
3202
+ currChunk[rle] = col = cscan;
3203
+ } else {
3204
+ if (col == cscan) rle -= 2;
3205
+ break;
3206
+ }
3207
+ rle++;
3208
+ }
3209
+ output.write(rle - 1);
3210
+ for (int i = 0; i < rle; i++) output.write(currChunk[i]);
3211
+ }
3212
+ index += rle;
3213
+ }
3214
+ } else { // export 24/32 bit TARGA
3215
+ while (index < maxLen) {
3216
+ boolean isRLE = false;
3217
+ currChunk[0] = col = pixels[index];
3218
+ int rle = 1;
3219
+ // try to find repeating bytes (min. len = 2 pixels)
3220
+ // maximum chunk size is 128 pixels
3221
+ while (index + rle < maxLen) {
3222
+ if (col != pixels[index + rle] || rle == 128) {
3223
+ isRLE = (rle > 1); // set flag for RLE chunk
3224
+ break;
3225
+ }
3226
+ rle++;
3227
+ }
3228
+ if (isRLE) {
3229
+ output.write(128 | (rle - 1));
3230
+ output.write(col & 0xff);
3231
+ output.write(col >> 8 & 0xff);
3232
+ output.write(col >> 16 & 0xff);
3233
+ if (format == ARGB) output.write(col >>> 24 & 0xff);
3234
+
3235
+ } else { // not RLE
3236
+ rle = 1;
3237
+ while (index + rle < maxLen) {
3238
+ if ((col != pixels[index + rle] && rle < 128) || rle < 3) {
3239
+ currChunk[rle] = col = pixels[index + rle];
3240
+ } else {
3241
+ // check if the exit condition was the start of
3242
+ // a repeating colour
3243
+ if (col == pixels[index + rle]) rle -= 2;
3244
+ break;
3245
+ }
3246
+ rle++;
3247
+ }
3248
+ // write uncompressed chunk
3249
+ output.write(rle - 1);
3250
+ if (format == ARGB) {
3251
+ for (int i = 0; i < rle; i++) {
3252
+ col = currChunk[i];
3253
+ output.write(col & 0xff);
3254
+ output.write(col >> 8 & 0xff);
3255
+ output.write(col >> 16 & 0xff);
3256
+ output.write(col >>> 24 & 0xff);
3257
+ }
3258
+ } else {
3259
+ for (int i = 0; i < rle; i++) {
3260
+ col = currChunk[i];
3261
+ output.write(col & 0xff);
3262
+ output.write(col >> 8 & 0xff);
3263
+ output.write(col >> 16 & 0xff);
3264
+ }
3265
+ }
3266
+ }
3267
+ index += rle;
3268
+ }
3269
+ }
3270
+ output.flush();
3271
+ return true;
3272
+
3273
+ } catch (IOException e) {
3274
+ return false;
3275
+ }
3371
3276
  }
3372
3277
 
3278
+
3373
3279
  /**
3374
3280
  * ( begin auto-generated from PImage_save.xml )
3375
3281
  *
3376
- * Saves the image into a file.Append a file extension to the name of the
3377
- file, to indicate the file format to be used: either TIFF (.tif), TARGA
3378
- (.tga), JPEG (.jpg), or PNG (.png). If no extension is included in the
3379
- filename, the image will save in TIFF format and .tif will be added to the
3380
- name. These files are saved to the sketch's folder, which may be opened by
3381
- selecting "Show sketch folder" from the "Sketch" menu. To save an image
3382
- created within the code, rather than through loading, it's necessary to
3383
- make the image with the
3384
- <b>createImage()</b> function so it is aware of the location of the program
3385
- * and can therefore save the file to the right place. See the
3282
+ * Saves the image into a file. Append a file extension to the name of
3283
+ * the file, to indicate the file format to be used: either TIFF (.tif),
3284
+ * TARGA (.tga), JPEG (.jpg), or PNG (.png). If no extension is included
3285
+ * in the filename, the image will save in TIFF format and .tif will be
3286
+ * added to the name. These files are saved to the sketch's folder, which
3287
+ * may be opened by selecting "Show sketch folder" from the "Sketch" menu.
3288
+ * To save an image created within the code, rather
3289
+ * than through loading, it's necessary to make the image with the
3290
+ * <b>createImage()</b> function so it is aware of the location of the
3291
+ * program and can therefore save the file to the right place. See the
3386
3292
  * <b>createImage()</b> reference for more information.
3387
3293
  *
3388
- *
3294
+ * ( end auto-generated )
3389
3295
  * <h3>Advanced</h3>
3390
3296
  * Save this image to disk.
3391
3297
  * <p>
3392
- * As of revision 0100, this function requires an absolute path, in order to
3393
- * avoid confusion. To save inside the sketch folder, use the function
3394
- * savePath() from PApplet, or use saveFrame() instead. As of revision 0116,
3395
- * savePath() is not needed if this object has been created (as recommended)
3396
- * via createImage() or createGraphics() or one of its neighbors.
3298
+ * As of revision 0100, this function requires an absolute path,
3299
+ * in order to avoid confusion. To save inside the sketch folder,
3300
+ * use the function savePath() from PApplet, or use saveFrame() instead.
3301
+ * As of revision 0116, savePath() is not needed if this object has been
3302
+ * created (as recommended) via createImage() or createGraphics() or
3303
+ * one of its neighbors.
3397
3304
  * <p>
3398
- * As of revision 0115, when using Java 1.4 and later, you can write to
3399
- * several formats besides tga and tiff. If Java 1.4 is installed and the
3400
- * extension used is supported (usually png, jpg, jpeg, bmp, and tiff), then
3401
- * those methods will be used to write the image. To get a list of the
3402
- * supported formats for writing, use: <BR>
3403
- * <code>println(javax.imageio.ImageIO.getReaderFormatNames())</code>
3305
+ * As of revision 0115, when using Java 1.4 and later, you can write
3306
+ * to several formats besides tga and tiff. If Java 1.4 is installed
3307
+ * and the extension used is supported (usually png, jpg, jpeg, bmp,
3308
+ * and tiff), then those methods will be used to write the image.
3309
+ * To get a list of the supported formats for writing, use: <BR>
3310
+ * <TT>println(javax.imageio.ImageIO.getReaderFormatNames())</TT>
3404
3311
  * <p>
3405
3312
  * To use the original built-in image writers, use .tga or .tif as the
3406
- * extension, or don't include an extension. When no extension is used, the
3407
- * extension .tif will be added to the file name.
3313
+ * extension, or don't include an extension. When no extension is used,
3314
+ * the extension .tif will be added to the file name.
3408
3315
  * <p>
3409
- * The ImageIO API claims to support wbmp files, however they probably require
3410
- * a black and white image. Basic testing produced a zero-length file with no
3411
- * error.
3316
+ * The ImageIO API claims to support wbmp files, however they probably
3317
+ * require a black and white image. Basic testing produced a zero-length
3318
+ * file with no error.
3412
3319
  *
3413
- * @return
3414
3320
  * @webref pimage:method
3415
3321
  * @brief Saves the image to a TIFF, TARGA, PNG, or JPEG file
3416
3322
  * @usage application
3417
- * @param filename a sequence of lecodeers and numbers
3323
+ * @param filename a sequence of letters and numbers
3418
3324
  */
3419
- public boolean save(String filename) { // ignore
3420
- boolean success = false;
3421
-
3422
- if (parent != null) {
3423
- // use savePath(), so that the intermediate directories are created
3424
- filename = parent.savePath(filename);
3425
-
3426
- } else {
3427
- File file = new File(filename);
3428
- if (file.isAbsolute()) {
3429
- // make sure that the intermediate folders have been created
3430
- PApplet.createPath(file);
3431
- } else {
3432
- String msg
3433
- = "PImage.save() requires an absolute path. "
3434
- + "Use createImage(), or pass savePath() to save().";
3435
- PGraphics.showException(msg);
3436
- }
3437
- }
3438
-
3439
- // Make sure the pixel data is ready to go
3440
- loadPixels();
3441
-
3442
- try {
3443
- OutputStream os = null;
3444
-
3445
- if (saveImpl(filename)) {
3446
- return true;
3447
- }
3448
-
3449
- String filenameLower = filename.toLowerCase();
3450
- if (filenameLower.endsWith(".png")) {
3451
- return saveViaImageIO(this, filename); // Currently no viable PNG saving alternative.
3452
- } else if (filenameLower.endsWith(".tga")) {
3453
- os = new BufferedOutputStream(new FileOutputStream(filename), 32768);
3454
- success = saveTGA(os); //, pixels, width, height, format);
3455
- } else {
3456
- if (!filename.toLowerCase().endsWith(".tif")
3457
- && !filename.toLowerCase().endsWith(".tiff")) {
3458
- // if no .tif extension, add it..
3459
- filename += ".tif";
3460
- }
3461
- os = new BufferedOutputStream(new FileOutputStream(filename), 32768);
3462
- success = saveTIFF(os); //, pixels, width, height);
3463
- }
3464
- os.flush();
3465
- os.close();
3466
-
3467
- } catch (IOException e) {
3468
- System.err.println("Error while saving image.");
3469
-
3470
- success = false;
3471
- }
3472
- return success;
3473
- }
3325
+ public boolean save(String filename) { // ignore
3326
+ boolean success = false;
3327
+
3328
+ if (parent != null) {
3329
+ // use savePath(), so that the intermediate directories are created
3330
+ filename = parent.savePath(filename);
3331
+
3332
+ } else {
3333
+ File file = new File(filename);
3334
+ if (file.isAbsolute()) {
3335
+ // make sure that the intermediate folders have been created
3336
+ PApplet.createPath(file);
3337
+ } else {
3338
+ String msg =
3339
+ "PImage.save() requires an absolute path. " +
3340
+ "Use createImage(), or pass savePath() to save().";
3341
+ PGraphics.showException(msg);
3342
+ }
3343
+ }
3344
+
3345
+ // Make sure the pixel data is ready to go
3346
+ loadPixels();
3347
+
3348
+ try {
3349
+ OutputStream os = null;
3350
+
3351
+ if (saveImpl(filename)) {
3352
+ return true;
3353
+ }
3354
+
3355
+ if (filename.toLowerCase().endsWith(".tga")) {
3356
+ os = new BufferedOutputStream(new FileOutputStream(filename), 32768);
3357
+ success = saveTGA(os); //, pixels, width, height, format);
3358
+
3359
+ } else {
3360
+ if (!filename.toLowerCase().endsWith(".tif") &&
3361
+ !filename.toLowerCase().endsWith(".tiff")) {
3362
+ // if no .tif extension, add it..
3363
+ filename += ".tif";
3364
+ }
3365
+ os = new BufferedOutputStream(new FileOutputStream(filename), 32768);
3366
+ success = saveTIFF(os); //, pixels, width, height);
3367
+ }
3368
+ os.flush();
3369
+ os.close();
3370
+
3371
+ } catch (IOException e) {
3372
+ System.err.println("Error while saving image.");
3373
+ success = false;
3374
+ }
3375
+ return success;
3376
+ }
3474
3377
  }