Introduce noise delegate pattern

Author: monkstone

CHANGELOG.md

@@ -1,3 +1,5 @@
+**v3.8.0** Refactor noise to delegate pattern, improve default implementation and add simplex noise option
+
 **v3.7.1** Recommend JRuby-9.2.15.0 use
 
 **v3.5.0** Rebase processing core code around Sam Pottingers latest fixes for JOGL an image save, does mean breaking some of Diwis and Joshua Davis examples, but one hopes codeanticode knows what he's doing.

lib/propane/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Propane
-  VERSION = '3.7.1'
+  VERSION = '3.8.0'
 end

pom.rb

@@ -2,7 +2,7 @@
 
 project 'propane', 'https://github.com/monkstone/propane' do
   model_version '4.0.0'
-  id 'propane:propane:3.7.1'
+  id 'propane:propane:3.8.0'
   packaging 'jar'
 
   description 'An integrated processing-core (somewhat hacked), with additional java code for a jruby version of processing.'

src/main/java/monkstone/fastmath/DegLutTables.java

@@ -0,0 +1,111 @@
+/* 
+ * Copyright (c) 2021 Martin Prout
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * http://creativecommons.org/licenses/LGPL/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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package monkstone.fastmath;
+
+public final class DegLutTables {
+
+    /**
+     *
+     */
+    static public final float PI = 3.1415927f;
+
+    /**
+     *
+     */
+    static public final float PI2 = PI * 2;
+    static private final int SIN_BITS = 15; // 16KB. Adjust for accuracy.
+    static private final int SIN_MASK = ~(-1 << SIN_BITS);
+    static private final int SIN_COUNT = SIN_MASK + 1;
+
+    static private final float RAD_FULL = PI * 2;
+    static private final float DEG_FULL = 360;
+    static private final float RAD_TO_INDEX = SIN_COUNT / RAD_FULL;
+    static private final float DEG_TO_INDEX = SIN_COUNT / DEG_FULL;
+
+    /**
+     * multiply by this to convert from radians to degrees
+     */
+    static public final float RADIANS_TO_DEGREES = 180f / PI;
+
+    /**
+     *
+     */
+    static public final float RAD_DEG = RADIANS_TO_DEGREES;
+    /**
+     * multiply by this to convert from degrees to radians
+     */
+    static public final float DEGREES_TO_RADIANS = PI / 180;
+
+    /**
+     *
+     */
+    static public final float DEG_RAD = DEGREES_TO_RADIANS;
+
+    static private class Sin {
+
+        static final float[] table = new float[SIN_COUNT];
+
+        static {
+            for (int i = 0; i < SIN_COUNT; i++) {
+                table[i] = (float) Math.sin((i + 0.5f) / SIN_COUNT * RAD_FULL);
+            }
+            for (int i = 0; i < 360; i += 90) {
+                table[(int) (i * DEG_TO_INDEX) & SIN_MASK] = (float) Math.sin(i * DEGREES_TO_RADIANS);
+            }
+        }
+    }
+
+    /**
+     * Returns the sine in radians from a lookup table.
+     * @param radians
+     * @return 
+     */
+    static public final float sin(float radians) {
+        return Sin.table[(int) (radians * RAD_TO_INDEX) & SIN_MASK];
+    }
+
+    /**
+     * Returns the cosine in radians from a lookup table.
+     * @param radians
+     * @return 
+     */
+    static public final float cos(float radians) {
+        return Sin.table[(int) ((radians + PI / 2) * RAD_TO_INDEX) & SIN_MASK];
+    }
+
+    /**
+     * Returns the sine in radians from a lookup table.
+     * @param degrees
+     * @return 
+     */
+    static public final float sinDeg(float degrees) {
+        return Sin.table[(int) (degrees * DEG_TO_INDEX) & SIN_MASK];
+    }
+
+    /**
+     * Returns the cosine in radians from a lookup table.
+     * @param degrees
+     * @return 
+     */
+    static public final float cosDeg(float degrees) {
+        return Sin.table[(int) ((degrees + 90) * DEG_TO_INDEX) & SIN_MASK];
+    }
+}
+

src/main/java/monkstone/fastmath/Deglut.java

@@ -1,5 +1,5 @@
 /* 
- * Copyright (c) 2015-20 Martin Prout
+ * Copyright (c) 2015-21 Martin Prout
  * 
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -20,7 +20,7 @@
 package monkstone.fastmath;
 
 import org.jruby.Ruby;
-import org.jruby.RubyInteger;
+import org.jruby.RubyNumeric;
 import org.jruby.RubyModule;
 import org.jruby.anno.JRubyModule;
 import org.jruby.anno.JRubyMethod;
@@ -34,46 +34,13 @@
 @JRubyModule(name = "DegLut")
 public class Deglut {
 
-    /**
-     * Lookup table for degree cosine/sine, has a fixed precision 1.0 degrees
-     * Quite accurate but imprecise
-     *
-     * @author Martin Prout <[email protected]>
-     */
-    static final double[] SIN_DEG_LUT = new double[91];
-    /**
-     *
-     */
-    public static final double TO_RADIANS = Math.PI / 180;
-    /**
-     *
-     */
-    private static boolean initialized = false;
-
-    private final static int NINETY = 90;
-    private final static int FULL = 360;
-    private static final long serialVersionUID = -1466528933765940101L;
-
-    /**
-     * Initialize sin table with values (first quadrant only)
-     */
-    public static final void initTable() {
-        if (initialized == false) {
-            for (int i = 0; i <= NINETY; i++) {
-                SIN_DEG_LUT[i] = Math.sin(TO_RADIANS * i);
-            }
-            initialized = true;
-        }
-    }
-
     /**
      *
      * @param runtime Ruby
      */
     public static void createDeglut(final Ruby runtime) {
         RubyModule deglutModule = runtime.defineModule("DegLut");
         deglutModule.defineAnnotatedMethods(Deglut.class);
-        Deglut.initTable();
     }
 
     /**
@@ -84,18 +51,9 @@ public static void createDeglut(final Ruby runtime) {
      * @return sin IRubyObject
      */
     @JRubyMethod(name = "sin", module = true)
-
     public static IRubyObject sin(ThreadContext context, IRubyObject recv, IRubyObject other) {
-        int thet = (int) ((RubyInteger) other).getLongValue();
-        while (thet < 0) {
-            thet += FULL; // Needed because negative modulus plays badly in java
-        }
-        int theta = thet % FULL;
-        int y = theta % NINETY;
-        double result = (theta < NINETY) ? SIN_DEG_LUT[y] : (theta < 180)
-                ? SIN_DEG_LUT[NINETY - y] : (theta < 270)
-                        ? -SIN_DEG_LUT[y] : -SIN_DEG_LUT[NINETY - y];
-        return context.runtime.newFloat(result);
+        float thet = (float) ((RubyNumeric) other).getLongValue();
+        return context.runtime.newFloat(DegLutTables.sinDeg(thet));
     }
 
     /**
@@ -107,15 +65,7 @@ public static IRubyObject sin(ThreadContext context, IRubyObject recv, IRubyObje
      */
     @JRubyMethod(name = "cos", module = true)
     public static IRubyObject cos(ThreadContext context, IRubyObject recv, IRubyObject other) {
-        int thet = (int) ((RubyInteger) other).getLongValue();
-        while (thet < 0) {
-            thet += FULL; // Needed because negative modulus plays badly in java
-        }
-        int theta = thet % FULL;
-        int y = theta % NINETY;
-        double result = (theta < NINETY) ? SIN_DEG_LUT[NINETY - y] : (theta < 180)
-                ? -SIN_DEG_LUT[y] : (theta < 270)
-                        ? -SIN_DEG_LUT[NINETY - y] : SIN_DEG_LUT[y];
-        return context.runtime.newFloat(result);
+        float thet = (float) ((RubyNumeric) other).getLongValue();
+        return context.runtime.newFloat(DegLutTables.cosDeg(thet));
     }
 }

src/main/java/monkstone/noise/Noise.java

@@ -0,0 +1,112 @@
+package monkstone.noise;
+
+/*
+ * Copyright (c) 2021 Martin Prout
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation; either
+ * version 3.0 of the License, or (at your option) any later version.
+ *
+ * http://creativecommons.org/licenses/LGPL/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 General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+public interface Noise {
+
+    /**
+     *
+     * @param x
+     * @return
+     */
+    default float noise(float x) {
+        return noise(x, 0);
+    }
+
+    /**
+     *
+     * @param x
+     * @param y
+     * @return
+     */
+    default float noise(float x, float y) {
+        return noise(x, y, 0);
+    }
+
+    /**
+     * <p>
+     * Returns the Perlin noise value at specified coordinates. Perlin noise is
+     * a random sequence generator producing a more natural ordered, harmonic
+     * succession of numbers compared to the standard <b>random()</b> function.
+     * It was invented by Ken Perlin in the 1980s and been used since in
+     * graphical applications to produce procedural textures, natural motion,
+     * shapes, terrains etc. The main difference to the
+     * <b>random()</b> function is that Perlin noise is defined in an infinite
+     * n-dimensional space where each pair of coordinates corresponds to a fixed
+     * semi-random value (fixed only for the lifespan of the program). The
+     * resulting value will always be between 0.0 and 1.0. Processing can
+     * compute 1D, 2D and 3D noise, depending on the number of coordinates
+     * given. The noise value can be animated by moving through the noise space
+     * as demonstrated in the example above. The 2nd and 3rd dimension can also
+     * be interpreted as time.The actual noise is structured similar to an audio
+     * signal, in respect to the function's use of frequencies. Similar to the
+     * concept of harmonics in physics, perlin noise is computed over several
+     * octaves which are added together for the final result. Another way to
+     * adjust the character of the resulting sequence is the scale of the input
+     * coordinates. As the function works within an infinite space the value of
+     * the coordinates doesn't matter as such, only the distance between
+     * successive coordinates does (eg. when using <b>noise()</b> within a
+     * loop). As a general rule the smaller the difference between coordinates,
+     * the smoother the resulting noise sequence will be. Steps of 0.005-0.03
+     * work best for most applications, but this will differ depending on use.
+     * <p>
+     * @param x x-coordinate in noise space
+     * @param y y-coordinate in noise space
+     * @param z z-coordinate in noise space
+     * @return
+     */
+    float noise(float x, float y, float z);
+
+    /**
+     * Adjusts the character and level of detail produced by the Perlin noise
+     * function.Similar to harmonics in physics, noise is computed over several
+     * octaves. Lower octaves contribute more to the output signal and as such
+     * define the overal intensity of the noise, whereas higher octaves create
+     * finer grained details in the noise sequence. By default, noise is
+     * computed over 4 octaves with each octave contributing exactly half than
+     * its predecessor, starting at 50% strength for the 1st octave. This
+     * falloff amount can be changed by adding an additional function parameter.
+     * Eg. a falloff factor of 0.75 means each octave will now have 75% impact
+     * (25% less) of the previous lower octave. Any value between 0.0 and 1.0 is
+     * valid, however note that values greater than 0.5 might result in greater
+     * than 1.0 values returned by <b>noise()</b>.By changing these parameters,
+     * the signal created by the <b>noise()</b>
+     * function can be adapted to fit very specific needs and characteristics.
+     *
+     * @param lod
+     */
+    void noiseDetail(int lod);
+
+    /**
+     * @param lod
+     * @param falloff falloff factor for each octave
+     */
+    void noiseDetail(int lod, float falloff);
+
+    /**
+     * Sets the seed value for <b>noise()</b>.By default, <b>noise()</b>
+     * produces different results each time the program is run. Set the
+     * <b>value</b> parameter to a constant to return the same pseudo-random
+     * numbers each time the software is run.
+     *
+     * @param seed
+     */
+    void noiseSeed(long seed);
+}

src/main/java/monkstone/noise/NoiseGenerator.java

@@ -0,0 +1,45 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package monkstone.noise;
+
+/**
+ *
+ * @author Martin Prout
+ */
+public class NoiseGenerator implements Noise{
+    
+    private final Noise implementation;
+    
+    public NoiseGenerator(){
+        this.implementation = new ValueNoise();
+           
+    }
+    
+    public NoiseGenerator(Noise implementation){
+        this.implementation = implementation;
+       }
+    
+    @Override
+    public float noise(float x, float y, float z) {
+        return implementation.noise(x, y, z);
+    }
+
+    @Override
+    public void noiseDetail(int lod) {
+        implementation.noiseDetail(lod);
+    }
+
+    @Override
+    public void noiseDetail(int lod, float falloff) {
+        implementation.noiseDetail(lod, falloff);
+    }
+
+    @Override
+    public void noiseSeed(long seed) {
+        implementation.noiseSeed(seed);
+    }
+    
+}