propane 3.2.0-java → 3.3.0-java

data/src/main/java/processing/core/util/image/save/ImageSaveUtil.java

@@ -0,0 +1,48 @@
+/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
+/*
+  Part of the Processing project - http://processing.org
+
+  Copyright (c) 2012-18 The Processing Foundation
+  Copyright (c) 2004-12 Ben Fry and Casey Reas
+  Copyright (c) 2001-04 Massachusetts Institute of Technology
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation, version 2.1.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  Public License along with this library; if not, write to the
+  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+  Boston, MA  02111-1307  USA
+*/
+
+package processing.core.util.image.save;
+
+import java.io.BufferedOutputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.OutputStream;
+
+
+/**
+ * Common convenience functions for file saving.
+ */
+public class ImageSaveUtil {
+
+  /**
+   * Create an output stream for a file.
+   *
+   * @param filename The filename at which the output stream should be created.
+   * @return The newly created output stream.
+   */
+  public static OutputStream createForFile(String filename) throws FileNotFoundException {
+    return new BufferedOutputStream(new FileOutputStream(filename), 32768);
+  }
+
+}

data/src/main/java/processing/core/util/image/save/ImageWriterImageSaveStrategy.java

@@ -0,0 +1,179 @@
+/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
+/*
+  Part of the Processing project - http://processing.org
+
+  Copyright (c) 2012-18 The Processing Foundation
+  Copyright (c) 2004-12 Ben Fry and Casey Reas
+  Copyright (c) 2001-04 Massachusetts Institute of Technology
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation, version 2.1.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  Public License along with this library; if not, write to the
+  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+  Boston, MA  02111-1307  USA
+*/
+
+package processing.core.util.image.save;
+
+import processing.core.PApplet;
+import processing.core.PConstants;
+import processing.core.util.io.PathUtil;
+
+import javax.imageio.*;
+import javax.imageio.metadata.IIOInvalidTreeException;
+import javax.imageio.metadata.IIOMetadata;
+import javax.imageio.metadata.IIOMetadataNode;
+import java.awt.image.BufferedImage;
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.util.Iterator;
+
+
+/**
+ * Strategy to use ImageIO functions to save an image.
+ */
+public class ImageWriterImageSaveStrategy implements ImageSaveStrategy {
+
+  /**
+   * Use ImageIO functions from Java 1.4 and later to handle image save.
+   * Various formats are supported, typically jpeg, png, bmp, and wbmp.
+   * To get a list of the supported formats for writing, use: <BR>
+   * <TT>println(javax.imageio.ImageIO.getReaderFormatNames())</TT>
+   */
+  @Override
+  public boolean save(int[] pixels, int pixelWidth, int pixelHeight, int format,
+      String path) throws IOException {
+
+    try {
+      int outputFormat = (format == PConstants.ARGB) ?
+          BufferedImage.TYPE_INT_ARGB : BufferedImage.TYPE_INT_RGB;
+
+      String extension = PathUtil.cleanExtension(
+          PathUtil.parseExtension(path)
+      );
+
+      // JPEG and BMP images that have an alpha channel set get pretty unhappy.
+      // BMP just doesn't write, and JPEG writes it as a CMYK image.
+      // http://code.google.com/p/processing/issues/detail?id=415
+      if (isRgbImage(extension)) {
+        outputFormat = BufferedImage.TYPE_INT_RGB;
+      }
+
+      BufferedImage bimage = new BufferedImage(pixelWidth, pixelHeight, outputFormat);
+      bimage.setRGB(0, 0, pixelWidth, pixelHeight, pixels, 0, pixelWidth);
+
+      File file = new File(path);
+
+      ImageWriter writer = null;
+      ImageWriteParam param = null;
+      IIOMetadata metadata = null;
+
+      if (isJpeg(extension)) {
+        if ((writer = getImageIoWriter("jpeg")) != null) {
+          // Set JPEG quality to 90% with baseline optimization. Setting this
+          // to 1 was a huge jump (about triple the size), so this seems good.
+          // Oddly, a smaller file size than Photoshop at 90%, but I suppose
+          // it's a completely different algorithm.
+          param = writer.getDefaultWriteParam();
+          param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
+          param.setCompressionQuality(0.9f);
+        }
+      }
+
+      if (isPng(extension)) {
+        if ((writer = getImageIoWriter("png")) != null) {
+          param = writer.getDefaultWriteParam();
+          if (false) {
+            metadata = getImageIoDpi(writer, param, 100);
+          }
+        }
+      }
+
+      if (writer != null) {
+        BufferedOutputStream output =
+            new BufferedOutputStream(PApplet.createOutput(file));
+        writer.setOutput(ImageIO.createImageOutputStream(output));
+//        writer.write(null, new IIOImage(bimage, null, null), param);
+        writer.write(metadata, new IIOImage(bimage, null, metadata), param);
+        writer.dispose();
+
+        output.flush();
+        output.close();
+        return true;
+      }
+      // If iter.hasNext() somehow fails up top, it falls through to here
+      return javax.imageio.ImageIO.write(bimage, extension, file);
+
+    } catch (Exception e) {
+      e.printStackTrace();
+      throw new IOException("image save failed.");
+    }
+  }
+
+  private ImageWriter getImageIoWriter(String extension) {
+    Iterator<ImageWriter> iter = ImageIO.getImageWritersByFormatName(extension);
+    if (iter.hasNext()) {
+      return iter.next();
+    }
+    return null;
+  }
+
+  private IIOMetadata getImageIoDpi(ImageWriter writer, ImageWriteParam param, double dpi) {
+    // http://stackoverflow.com/questions/321736/how-to-set-dpi-information-in-an-image
+    ImageTypeSpecifier typeSpecifier =
+        ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_INT_RGB);
+    IIOMetadata metadata =
+        writer.getDefaultImageMetadata(typeSpecifier, param);
+
+    if (!metadata.isReadOnly() && metadata.isStandardMetadataFormatSupported()) {
+      // for PNG, it's dots per millimeter
+      double dotsPerMilli = dpi / 25.4;
+
+      IIOMetadataNode horiz = new IIOMetadataNode("HorizontalPixelSize");
+      horiz.setAttribute("value", Double.toString(dotsPerMilli));
+
+      IIOMetadataNode vert = new IIOMetadataNode("VerticalPixelSize");
+      vert.setAttribute("value", Double.toString(dotsPerMilli));
+
+      IIOMetadataNode dim = new IIOMetadataNode("Dimension");
+      dim.appendChild(horiz);
+      dim.appendChild(vert);
+
+      IIOMetadataNode root = new IIOMetadataNode("javax_imageio_1.0");
+      root.appendChild(dim);
+
+      try {
+        metadata.mergeTree("javax_imageio_1.0", root);
+        return metadata;
+
+      } catch (IIOInvalidTreeException e) {
+        System.err.println("Could not set the DPI of the output image");
+        e.printStackTrace();
+      }
+    }
+    return null;
+  }
+
+  private boolean isRgbImage(String extension) {
+    return extension.equals("bmp") || isJpeg(extension);
+  }
+
+  private boolean isJpeg(String extension) {
+    return extension.equals("jpg") || extension.equals("jpeg");
+  }
+
+  private boolean isPng(String extension) {
+    return extension.equals("png");
+  }
+
+}

data/src/main/java/processing/core/util/image/save/SaveImageException.java

@@ -0,0 +1,41 @@
+/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
+/*
+  Part of the Processing project - http://processing.org
+
+  Copyright (c) 2012-18 The Processing Foundation
+  Copyright (c) 2004-12 Ben Fry and Casey Reas
+  Copyright (c) 2001-04 Massachusetts Institute of Technology
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation, version 2.1.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  Public License along with this library; if not, write to the
+  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+  Boston, MA  02111-1307  USA
+*/
+
+package processing.core.util.image.save;
+
+
+/**
+ * Exception describing an issue encountered while saving an image.
+ */
+public class SaveImageException extends RuntimeException {
+
+  /**
+   * Create a new exception with a description of why image saving failed.
+   * @param msg The message describing failure cause.
+   */
+  public SaveImageException(String msg) {
+    super(msg);
+  }
+
+}

data/src/main/java/processing/core/util/image/save/TgaImageSaveStrategy.java

@@ -0,0 +1,198 @@
+/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
+/*
+  Part of the Processing project - http://processing.org
+
+  Copyright (c) 2012-18 The Processing Foundation
+  Copyright (c) 2004-12 Ben Fry and Casey Reas
+  Copyright (c) 2001-04 Massachusetts Institute of Technology
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation, version 2.1.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  Public License along with this library; if not, write to the
+  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+  Boston, MA  02111-1307  USA
+*/
+
+package processing.core.util.image.save;
+
+import processing.core.PConstants;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.OutputStream;
+
+
+/**
+ * Strategy for creating tga (targa32) images.
+ */
+public class TgaImageSaveStrategy implements ImageSaveStrategy {
+
+  /**
+   * Creates a Targa32 formatted byte sequence of specified
+   * pixel buffer using RLE compression.
+   * </p>
+   * Also figured out how to avoid parsing the image upside-down
+   * (there's a header flag to set the image origin to top-left)
+   * </p>
+   * Starting with revision 0092, the format setting is taken into account:
+   * <UL>
+   * <LI><TT>ALPHA</TT> images written as 8bit grayscale (uses lowest byte)
+   * <LI><TT>RGB</TT> &rarr; 24 bits
+   * <LI><TT>ARGB</TT> &rarr; 32 bits
+   * </UL>
+   * All versions are RLE compressed.
+   * </p>
+   * Contributed by toxi 8-10 May 2005, based on this RLE
+   * <A HREF="http://www.wotsit.org/download.asp?f=tga">specification</A>
+   */
+  @Override
+  public boolean save(int[] pixels, int pixelWidth, int pixelHeight, int format,
+      String filename) throws FileNotFoundException {
+
+    OutputStream output = ImageSaveUtil.createForFile(filename);
+
+    byte header[] = new byte[18];
+
+    if (format == PConstants.ALPHA) {  // save ALPHA images as 8bit grayscale
+      header[2] = 0x0B;
+      header[16] = 0x08;
+      header[17] = 0x28;
+
+    } else if (format == PConstants.RGB) {
+      header[2] = 0x0A;
+      header[16] = 24;
+      header[17] = 0x20;
+
+    } else if (format == PConstants.ARGB) {
+      header[2] = 0x0A;
+      header[16] = 32;
+      header[17] = 0x28;
+
+    } else {
+      throw new RuntimeException("Image format not recognized inside save()");
+    }
+    // set image dimensions lo-hi byte order
+    header[12] = (byte) (pixelWidth & 0xff);
+    header[13] = (byte) (pixelWidth >> 8);
+    header[14] = (byte) (pixelHeight & 0xff);
+    header[15] = (byte) (pixelHeight >> 8);
+
+    try {
+      output.write(header);
+
+      int maxLen = pixelHeight * pixelWidth;
+      int index = 0;
+      int col; //, prevCol;
+      int[] currChunk = new int[128];
+
+      // 8bit image exporter is in separate loop
+      // to avoid excessive conditionals...
+      if (format == PConstants.ALPHA) {
+        while (index < maxLen) {
+          boolean isRLE = false;
+          int rle = 1;
+          currChunk[0] = col = pixels[index] & 0xff;
+          while (index + rle < maxLen) {
+            if (col != (pixels[index + rle]&0xff) || rle == 128) {
+              isRLE = (rle > 1);
+              break;
+            }
+            rle++;
+          }
+          if (isRLE) {
+            output.write(0x80 | (rle - 1));
+            output.write(col);
+
+          } else {
+            rle = 1;
+            while (index + rle < maxLen) {
+              int cscan = pixels[index + rle] & 0xff;
+              if ((col != cscan && rle < 128) || rle < 3) {
+                currChunk[rle] = col = cscan;
+              } else {
+                if (col == cscan) rle -= 2;
+                break;
+              }
+              rle++;
+            }
+            output.write(rle - 1);
+            for (int i = 0; i < rle; i++) output.write(currChunk[i]);
+          }
+          index += rle;
+        }
+      } else {  // export 24/32 bit TARGA
+        while (index < maxLen) {
+          boolean isRLE = false;
+          currChunk[0] = col = pixels[index];
+          int rle = 1;
+          // try to find repeating bytes (min. len = 2 pixels)
+          // maximum chunk size is 128 pixels
+          while (index + rle < maxLen) {
+            if (col != pixels[index + rle] || rle == 128) {
+              isRLE = (rle > 1); // set flag for RLE chunk
+              break;
+            }
+            rle++;
+          }
+          if (isRLE) {
+            output.write(128 | (rle - 1));
+            output.write(col & 0xff);
+            output.write(col >> 8 & 0xff);
+            output.write(col >> 16 & 0xff);
+            if (format == PConstants.ARGB) output.write(col >>> 24 & 0xff);
+
+          } else {  // not RLE
+            rle = 1;
+            while (index + rle < maxLen) {
+              if ((col != pixels[index + rle] && rle < 128) || rle < 3) {
+                currChunk[rle] = col = pixels[index + rle];
+              } else {
+                // check if the exit condition was the start of
+                // a repeating colour
+                if (col == pixels[index + rle]) rle -= 2;
+                break;
+              }
+              rle++;
+            }
+            // write uncompressed chunk
+            output.write(rle - 1);
+            if (format == PConstants.ARGB) {
+              for (int i = 0; i < rle; i++) {
+                col = currChunk[i];
+                output.write(col & 0xff);
+                output.write(col >> 8 & 0xff);
+                output.write(col >> 16 & 0xff);
+                output.write(col >>> 24 & 0xff);
+              }
+            } else {
+              for (int i = 0; i < rle; i++) {
+                col = currChunk[i];
+                output.write(col & 0xff);
+                output.write(col >> 8 & 0xff);
+                output.write(col >> 16 & 0xff);
+              }
+            }
+          }
+          index += rle;
+        }
+      }
+      output.flush();
+      output.close();
+      return true;
+
+    } catch (IOException e) {
+      e.printStackTrace();
+      return false;
+    }
+  }
+
+}