picrate 2.0.1-java → 2.1.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f7698cb99a4ff6ebff96bc82f20a3121bda1af52118a1cdcfd48942bec2ed7a4
-  data.tar.gz: 42555f15e9ed7f238283878ec6291f84242d3a3782b5d9d41c23abc62eed45dd
+  metadata.gz: 815b6e840309b917ad6161954369b0e9bb959ea37395f55305686aeaafda8cc0
+  data.tar.gz: c8f489adb6e0819610d265498baf205b458badf6306fcfa9d0c75813fb539218
 SHA512:
-  metadata.gz: a3c695a7cbbb47660d0cf472ac1ce50e859ecdb4e6271bdb6b9e1862a9a94b479a58ad4be146632d245322660995d020b517ae171acc665a252e41a885cc4757
-  data.tar.gz: 94eaeb3df23ea29ad3bf58cfd8b1d8a5008c21133c52a76bbf709b87a1c0954fcaca6bcc4457d3d804c92c761fdcfc62e202bb26b947bef4c8a4fdd89b851563
+  metadata.gz: 2b32a35a68e3fd8c35a59f45207fc13e0548e0efd8578d4ca74c4e2910308bf7f5ea1e9ba3573b56ada55508090e2b8592f13720ce2992f31537425e22df2a6b
+  data.tar.gz: 016cb1f2b2afc5b32d35620eaa6854f3d3e2bf28befd7de20267db10442a534676482836ba6aa7822132755a1f6adc285dee9352d5aa640d9819232bbc3157e4

data/CHANGELOG.md

@@ -1,3 +1,5 @@
+v2.1.0 Refactor how we configure geany so we can use ENV['HOME'] rather hard code config file. Bump to JRuby-9.2.12.0, include Sam Pottingers July 2020 staging changes.
+
 v2.0.1 Use JOGL-2.4.0-rc fixes reflection warnings, remove geomerative and wordcram gem dependencies since can now be in step with JRubyArt and propane (re jdk compatibility), bump version for release. Removed Gottfreid Haider shaders, warn legacy driver doesn't work with P2D and P3D sketches. Support aarch64 architecture on RaspberriPI4.
 
 v2.0.0 Use JDK11+ update to processing-3.5.4 suggest jruby-9.2.11.0

data/docs/_posts/2020-05-11-getting_started_manjaro.md

@@ -5,12 +5,12 @@ date:   2020-05-11 07:34:13
 categories: PiCrate update
 permalink: /getting_manjaro/
 ---
-Currently Manjaro does not come with a pre-installed java. So the first step is to install a `jdk` we currently recommend installing hotspot adopt-openjdk11 from the AdoptOpenJDK project. Setting the JDK_HOME environment and then manually install the latest JRuby. It is probably worth creating a symbolic links to `/usr/bin/jruby` and `/usr/bin/jgem` from wherever you installed jruby eg /opt folder.
-```
+Currently Manjaro does not come with a pre-installed java. So the first step is to install a `jdk` we currently recommend installing hotspot adopt-openjdk11 from the AdoptOpenJDK project (there may be issues with distro version). Setting the JDK_HOME environment (easiest done `/etc/profile.d`) and then manually install the latest JRuby. It is probably worth creating a symbolic links to `/usr/bin/jruby` and `/usr/bin/jgem` from wherever you installed jruby eg /opt folder.
 
 ```bash
 mkdir -p ~/.gem/jruby/2.5.0
 ```
+
 Now set your `GEM_HOME`, `GEM_PATH` and amend your `PATH` as follows:-
 
 ```bash
@@ -27,7 +27,7 @@ jgem install rake
 To install latest picrate and its dependencies:-
 
 ```bash
-jgem install picrate --pre
+jgem install picrate
 ```
 __For a first install:-__
 
@@ -37,7 +37,7 @@ picrate --install # no args, install samples and geany config
 picrate -i Samples # to omit geany config
 ```
 
-This installs example sketches in `~/projects/examples` and ties them into a `geany` project `examples.geany`. It should also be possible to run sketches from the `geany` ide.
+This installs example sketches in `~/projects/examples` and ties them into a `geany` project `examples.geany`. It should also be possible to run sketches from the `geany` ide. Sketches need to be run in VTE terminal on Manjaro ARM the terminal emulator, does not give access to local environment variables in the version of Geany supplied.
 
 To create a template sketch from the command line:-
 

data/lib/picrate/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PiCrate
-  VERSION = '2.0.1'
+  VERSION = '2.1.0'
 end

data/pom.rb

@@ -2,7 +2,7 @@
 
 project 'picrate', 'http://maven.apache.org' do
   model_version '4.0.0'
-  id 'ruby-processing:picrate:2.0.1'
+  id 'ruby-processing:picrate:2.1.0'
   packaging 'jar'
 
   description 'An integrated processing-core (somewhat hacked), with additional java code for a jruby version of processing.'
@@ -31,7 +31,7 @@ project 'picrate', 'http://maven.apache.org' do
              'project.build.sourceEncoding' => 'utf-8',
              'polyglot.dump.pom' => 'pom.xml')
 
-  pom 'org.jruby:jruby:9.2.11.0'
+  pom 'org.jruby:jruby:9.2.12.0'
   jar 'org.jogamp.jogl:jogl-all:${jogl.version}'
   jar 'org.jogamp.gluegen:gluegen-rt-main:${jogl.version}'
   jar 'org.processing:video:3.0.2'

data/pom.xml

@@ -11,7 +11,7 @@ DO NOT MODIFIY - GENERATED CODE
   <modelVersion>4.0.0</modelVersion>
   <groupId>ruby-processing</groupId>
   <artifactId>picrate</artifactId>
-  <version>2.0.1</version>
+  <version>2.1.0</version>
   <name>picrate</name>
   <description>An integrated processing-core (somewhat hacked), with additional java code for a jruby version of processing.</description>
   <url>http://maven.apache.org</url>
@@ -76,7 +76,7 @@ DO NOT MODIFIY - GENERATED CODE
     <dependency>
       <groupId>org.jruby</groupId>
       <artifactId>jruby</artifactId>
-      <version>9.2.11.0</version>
+      <version>9.2.12.0</version>
       <type>pom</type>
     </dependency>
     <dependency>

data/src/main/java/processing/awt/PGraphicsJava2D.java

@@ -29,7 +29,6 @@ import java.awt.font.TextAttribute;
 import java.awt.geom.*;
 import java.awt.image.*;
 import java.util.Arrays;
-import java.util.HashMap;
 import java.util.Map;
 
 import processing.core.*;
@@ -295,10 +294,10 @@ public class PGraphicsJava2D extends PGraphics {
    * is going to return the {@link Graphics2D} object.
      * @return 
    */
-  @Override
-  public Image getImage() {
-    return image;
-  }
+//  @Override
+//  public Image getImage() {
+//    return image;
+//  }
 
 
   /** Returns the java.awt.Graphics2D object used by this renderer.
@@ -346,30 +345,30 @@ public class PGraphicsJava2D extends PGraphics {
 //        image = new BufferedImage(width * pixelFactor, height * pixelFactor
 //                                  format == RGB ?  BufferedImage.TYPE_INT_ARGB);
 
-      GraphicsConfiguration gc = null;
-      if (surface != null) {
-        Component comp = null;  //surface.getComponent();
-        if (comp == null) {
-//          System.out.println("component null, but parent.frame is " + parent.frame);
-          comp = parent.frame;
-        }
-        if (comp != null) {
-          gc = comp.getGraphicsConfiguration();
-        }
-      }
-      // If not realized (off-screen, i.e the Color Selector Tool), gc will be null.
-      if (gc == null) {
-        //System.err.println("GraphicsConfiguration null in initImage()");
-        GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
-        gc = ge.getDefaultScreenDevice().getDefaultConfiguration();
-      }
+//      GraphicsConfiguration gc = null;
+//      if (surface != null) {
+//        Component comp = null;  //surface.getComponent();
+//        if (comp == null) {
+////          System.out.println("component null, but parent.frame is " + parent.frame);
+//          comp = parent.frame;
+//        }
+//        if (comp != null) {
+//          gc = comp.getGraphicsConfiguration();
+//        }
+//      }
+//      // If not realized (off-screen, i.e the Color Selector Tool), gc will be null.
+//      if (gc == null) {
+//        //System.err.println("GraphicsConfiguration null in initImage()");
+//        GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
+//        gc = ge.getDefaultScreenDevice().getDefaultConfiguration();
+//      }
 
       // Formerly this was broken into separate versions based on offscreen or
       // not, but we may as well create a compatible image; it won't hurt, right?
       int wide = width * pixelDensity;
       int high = height * pixelDensity;
 //      System.out.println("re-creating image");
-      image = gc.createCompatibleImage(wide, high, Transparency.TRANSLUCENT);
+      image = new BufferedImage(wide, high, BufferedImage.TYPE_INT_ARGB);
 //      image = gc.createCompatibleVolatileImage(wide, high);
       //image = surface.getComponent().createImage(width, height);
     }

data/src/main/java/processing/awt/PImageAWT.java

@@ -0,0 +1,377 @@
+/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
+/*
+  Part of the Processing project - http://processing.org
+
+  Copyright (c) 2015 The Processing Foundation
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License version 2.1 as published by the Free Software Foundation.
+
+  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.awt;
+
+import java.awt.Graphics2D;
+import java.awt.Image;
+import java.awt.RenderingHints;
+import java.awt.Transparency;
+import java.awt.image.BufferedImage;
+import java.awt.image.DataBuffer;
+import java.awt.image.DataBufferInt;
+import java.awt.image.PixelGrabber;
+import java.awt.image.WritableRaster;
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.util.Iterator;
+
+import javax.imageio.IIOImage;
+import javax.imageio.ImageIO;
+import javax.imageio.ImageTypeSpecifier;
+import javax.imageio.ImageWriteParam;
+import javax.imageio.ImageWriter;
+import javax.imageio.metadata.IIOInvalidTreeException;
+import javax.imageio.metadata.IIOMetadata;
+import javax.imageio.metadata.IIOMetadataNode;
+
+import processing.core.PApplet;
+import processing.core.PImage;
+
+
+public class PImageAWT extends PImage {
+
+  /**
+   * Construct a new PImage from a java.awt.Image. This constructor assumes
+   * that you've done the work of making sure a MediaTracker has been used
+   * to fully download the data and that the img is valid.
+   *
+   * @nowebref
+   * @param img assumes a MediaTracker has been used to fully download
+   * the data and the img is valid
+   */
+  public PImageAWT(Image img) {
+    format = RGB;
+    if (img instanceof BufferedImage) {
+      BufferedImage bi = (BufferedImage) img;
+      width = bi.getWidth();
+      height = bi.getHeight();
+      int type = bi.getType();
+      if (type == BufferedImage.TYPE_3BYTE_BGR ||
+          type == BufferedImage.TYPE_4BYTE_ABGR) {
+        pixels = new int[width * height];
+        bi.getRGB(0, 0, width, height, pixels, 0, width);
+        if (type == BufferedImage.TYPE_4BYTE_ABGR) {
+          format = ARGB;
+        } else {
+          opaque();
+        }
+      } else {
+        DataBuffer db = bi.getRaster().getDataBuffer();
+        if (db instanceof DataBufferInt) {
+          pixels = ((DataBufferInt) db).getData();
+          if (type == BufferedImage.TYPE_INT_ARGB) {
+            format = ARGB;
+          } else if (type == BufferedImage.TYPE_INT_RGB) {
+            opaque();
+          }
+        }
+      }
+    }
+    // Implements fall-through if not DataBufferInt above, or not a
+    // known type, or not DataBufferInt for the data itself.
+    if (pixels == null) {  // go the old school Java 1.0 route
+      width = img.getWidth(null);
+      height = img.getHeight(null);
+      pixels = new int[width * height];
+      PixelGrabber pg =
+        new PixelGrabber(img, 0, 0, width, height, pixels, 0, width);
+      try {
+        pg.grabPixels();
+      } catch (InterruptedException e) { }
+    }
+    pixelDensity = 1;
+    pixelWidth = width;
+    pixelHeight = height;
+  }
+
+
+  /**
+   * Use the getNative() method instead, which allows library interfaces to be
+   * written in a cross-platform fashion for desktop, Android, and others.
+   * This is still included for PGraphics objects, which may need the image.
+   */
+  public Image getImage() {  // ignore
+    return (Image) getNative();
+  }
+
+
+  /**
+   * Returns a native BufferedImage from this PImage.
+   */
+  @Override
+  public Object getNative() {  // ignore
+    loadPixels();
+    int type = (format == RGB) ?
+      BufferedImage.TYPE_INT_RGB : BufferedImage.TYPE_INT_ARGB;
+    BufferedImage image = new BufferedImage(pixelWidth, pixelHeight, type);
+    WritableRaster wr = image.getRaster();
+    wr.setDataElements(0, 0, pixelWidth, pixelHeight, pixels);
+    return image;
+  }
+
+
+  @Override
+  public void resize(int w, int h) {  // ignore
+    if (w <= 0 && h <= 0) {
+      throw new IllegalArgumentException("width or height must be > 0 for resize");
+    }
+
+    if (w == 0) {  // Use height to determine relative size
+      float diff = (float) h / (float) height;
+      w = (int) (width * diff);
+    } else if (h == 0) {  // Use the width to determine relative size
+      float diff = (float) w / (float) width;
+      h = (int) (height * diff);
+    }
+
+    BufferedImage img =
+      shrinkImage((BufferedImage) getNative(), w*pixelDensity, h*pixelDensity);
+
+    PImage temp = new PImageAWT(img);
+    this.pixelWidth = temp.width;
+    this.pixelHeight = temp.height;
+
+    // Get the resized pixel array
+    this.pixels = temp.pixels;
+
+    this.width = pixelWidth / pixelDensity;
+    this.height = pixelHeight / pixelDensity;
+
+    // Mark the pixels array as altered
+    updatePixels();
+  }
+
+
+  // Adapted from getFasterScaledInstance() method from page 111 of
+  // "Filthy Rich Clients" by Chet Haase and Romain Guy
+  // Additional modifications and simplifications have been added,
+  // plus a fix to deal with an infinite loop if images are expanded.
+  // http://code.google.com/p/processing/issues/detail?id=1463
+  static private BufferedImage shrinkImage(BufferedImage img,
+                                           int targetWidth, int targetHeight) {
+    int type = (img.getTransparency() == Transparency.OPAQUE) ?
+      BufferedImage.TYPE_INT_RGB : BufferedImage.TYPE_INT_ARGB;
+    BufferedImage outgoing = img;
+    BufferedImage scratchImage = null;
+    Graphics2D g2 = null;
+    int prevW = outgoing.getWidth();
+    int prevH = outgoing.getHeight();
+    boolean isTranslucent = img.getTransparency() != Transparency.OPAQUE;
+
+    // Use multi-step technique: start with original size, then scale down in
+    // multiple passes with drawImage() until the target size is reached
+    int w = img.getWidth();
+    int h = img.getHeight();
+
+    do {
+      if (w > targetWidth) {
+        w /= 2;
+        // if this is the last step, do the exact size
+        if (w < targetWidth) {
+          w = targetWidth;
+        }
+      } else if (targetWidth >= w) {
+        w = targetWidth;
+      }
+      if (h > targetHeight) {
+        h /= 2;
+        if (h < targetHeight) {
+          h = targetHeight;
+        }
+      } else if (targetHeight >= h) {
+        h = targetHeight;
+      }
+      if (scratchImage == null || isTranslucent) {
+        // Use a single scratch buffer for all iterations and then copy
+        // to the final, correctly-sized image before returning
+        scratchImage = new BufferedImage(w, h, type);
+        g2 = scratchImage.createGraphics();
+      }
+      g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
+                          RenderingHints.VALUE_INTERPOLATION_BILINEAR);
+      g2.drawImage(outgoing, 0, 0, w, h, 0, 0, prevW, prevH, null);
+      prevW = w;
+      prevH = h;
+      outgoing = scratchImage;
+    } while (w != targetWidth || h != targetHeight);
+    g2.dispose();
+
+
+    // If we used a scratch buffer that is larger than our target size,
+    // create an image of the right size and copy the results into it
+    if (targetWidth != outgoing.getWidth() ||
+        targetHeight != outgoing.getHeight()) {
+      scratchImage = new BufferedImage(targetWidth, targetHeight, type);
+      g2 = scratchImage.createGraphics();
+      g2.drawImage(outgoing, 0, 0, null);
+      g2.dispose();
+      outgoing = scratchImage;
+    }
+    return outgoing;
+  }
+
+
+  @Override
+  protected boolean saveImpl(String filename) {
+    if (saveImageFormats == null) {
+      saveImageFormats = javax.imageio.ImageIO.getWriterFormatNames();
+    }
+    try {
+      if (saveImageFormats != null) {
+        for (String saveImageFormat : saveImageFormats) {
+          if (filename.endsWith("." + saveImageFormat)) {
+            if (!saveImageIO(filename)) {
+              System.err.println("Error while saving image.");
+              return false;
+            }
+            return true;
+          }
+        }
+      }
+    } catch (IOException e) {
+    }
+    return false;
+  }
+
+
+  protected String[] saveImageFormats;
+
+
+  /**
+   * 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>
+   *
+   * @path The path to which the file should be written.
+   */
+  protected boolean saveImageIO(String path) throws IOException {
+    try {
+      int outputFormat = (format == ARGB) ?
+        BufferedImage.TYPE_INT_ARGB : BufferedImage.TYPE_INT_RGB;
+
+      String extension =
+        path.substring(path.lastIndexOf('.') + 1).toLowerCase();
+
+      // 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 (extension.equals("bmp") || extension.equals("jpg") || extension.equals("jpeg")) {
+        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 (extension.equals("jpg") || extension.equals("jpeg")) {
+        if ((writer = imageioWriter("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 (extension.equals("png")) {
+        if ((writer = imageioWriter("png")) != null) {
+          param = writer.getDefaultWriteParam();
+          if (false) {
+            metadata = imageioDPI(writer, param, 100);
+          }
+        }
+      }
+
+      if (writer != null) {
+        try (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();
+        }
+        return true;
+      }
+      // If iter.hasNext() somehow fails up top, it falls through to here
+      return javax.imageio.ImageIO.write(bimage, extension, file);
+
+    } catch (IOException e) {
+      throw new IOException("image save failed.");
+    }
+  }
+
+
+  private ImageWriter imageioWriter(String extension) {
+    Iterator<ImageWriter> iter = ImageIO.getImageWritersByFormatName(extension);
+    if (iter.hasNext()) {
+      return iter.next();
+    }
+    return null;
+  }
+
+
+  private IIOMetadata imageioDPI(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");
+      }
+    }
+    return null;
+  }
+}