toxiclibs 0.2-java → 0.5.0-java

data/src/toxi/math/NonLinearScaleMap.java

@@ -0,0 +1,101 @@
+package toxi.math;
+
+import java.util.NavigableSet;
+import java.util.SortedSet;
+import java.util.TreeSet;
+
+/**
+ *
+ * @author tux
+ */
+public class NonLinearScaleMap {
+
+    /**
+     *
+     */
+    public class Sample implements Comparable<Sample> {
+
+        public final double x,
+
+        /**
+         *
+         */
+        y;
+
+        /**
+         *
+         * @param x
+         * @param y
+         */
+        public Sample(double x, double y) {
+            this.x = x;
+            this.y = y;
+        }
+
+        /**
+         *
+         * @param b
+         * @return
+         */
+        @Override
+        public int compareTo(Sample b) {
+            return (int) Math.signum(x - b.x);
+        }
+    }
+
+    private final TreeSet<Sample> samples;
+
+    private double rangeMin = Float.MAX_VALUE;
+    private double rangeMax = Float.MIN_VALUE;
+
+    /**
+     *
+     */
+    public NonLinearScaleMap() {
+        samples = new TreeSet<>();
+    }
+
+    /**
+     *
+     * @param x
+     * @param y
+     * @return
+     */
+    public NonLinearScaleMap addSample(double x, double y) {
+        samples.add(new Sample(x, y));
+        rangeMin = MathUtils.min(y, rangeMin);
+        rangeMax = MathUtils.max(y, rangeMax);
+        return this;
+    }
+
+    /**
+     *
+     * @return
+     */
+    public NavigableSet<Sample> getSamples() {
+        return samples;
+    }
+
+    /**
+     *
+     * @param x
+     * @return
+     */
+    public double map(double x) {
+        Sample t = new Sample(x, 0);
+        SortedSet<Sample> aset = samples.headSet(t);
+        SortedSet<Sample> bset = samples.tailSet(t);
+        if (aset.isEmpty()) {
+            return bset.first().y;
+        } else {
+            if (bset.isEmpty()) {
+                return aset.last().y;
+            } else {
+                Sample a = aset.last();
+                Sample b = bset.first();
+                return MathUtils.lerp(a.y, b.y, (x - a.x) / (b.x - a.x));
+            }
+        }
+    }
+
+}

data/src/toxi/math/ScaleMap.java

@@ -0,0 +1,183 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * Copyright (c) 2006-2011 Karsten Schmidt
+ * 
+ * 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 toxi.math;
+
+import toxi.util.datatypes.DoubleRange;
+
+/**
+ * This class maps values from one interval into another. By default the mapping
+ * is using linear projection, but can be changed by using alternative
+ * {@link toxi.math.InterpolateStrategy} implementations to achieve a
+ * non-regular mapping.
+ */
+public class ScaleMap {
+
+    /**
+     * The actual mapping behaviour function.
+     * 
+     * @see toxi.math.InterpolateStrategy
+     */
+    protected InterpolateStrategy mapFunction = new LinearInterpolation();
+
+    /**
+     *
+     */
+    protected double interval;
+
+    /**
+     *
+     */
+    protected double mapRange;
+
+    protected DoubleRange in,
+
+    /**
+     *
+     */
+
+    /**
+     *
+     */
+    out;
+
+    /**
+     * Creates a new instance to map values between the 2 number ranges
+     * specified. By default linear projection is used.
+     * 
+     * @param minIn
+     * @param maxIn
+     * @param minOut
+     * @param maxOut
+     */
+    public ScaleMap(double minIn, double maxIn, double minOut, double maxOut) {
+        setInputRange(minIn, maxIn);
+        setOutputRange(minOut, maxOut);
+    }
+
+    /**
+     * Computes mapped value in the target interval and ensures the input value
+     * is clipped to source interval.
+     * 
+     * @param val
+     * @return mapped value
+     */
+    public double getClippedValueFor(double val) {
+        double t = MathUtils.clipNormalized((val - in.min) / interval);
+        if (Double.isNaN(t)) {
+            t = 0;
+        }
+        return mapFunction.interpolate(out.min, out.max, t);
+    }
+
+    /**
+     * @return the middle value of the input range.
+     */
+    public double getInputMedian() {
+        return (in.min + in.max) * 0.5;
+    }
+
+    /**
+     * @return the in
+     */
+    public DoubleRange getInputRange() {
+        return in;
+    }
+
+    /**
+     * @return the mapped middle value of the output range. Depending on the
+     *         mapping function used, this value might be different to the one
+     *         returned by {@link #getOutputMedian()}.
+     */
+    public double getMappedMedian() {
+        return getMappedValueFor(0.5);
+    }
+
+    /**
+     * Computes mapped value in the target interval. Does check if input value
+     * is outside the input range.
+     * 
+     * @param val
+     * @return mapped value
+     */
+    public double getMappedValueFor(double val) {
+        double t = ((val - in.min) / interval);
+        if (Double.isNaN(t)) {
+            t = 0;
+        }
+        return mapFunction.interpolate(out.min, out.max, t);
+    }
+
+    /**
+     * @return the middle value of the output range
+     */
+    public double getOutputMedian() {
+        return (out.min + out.max) * 0.5;
+    }
+
+    /**
+     * @return the output range
+     */
+    public DoubleRange getOutputRange() {
+        return out;
+    }
+
+    /**
+     * Sets new minimum & maximum values for the input range
+     * 
+     * @param min
+     * @param max
+     */
+    public final void setInputRange(double min, double max) {
+        in = new DoubleRange(min, max);
+        interval = max - min;
+    }
+
+    /**
+     * Overrides the mapping function used for the scale conversion. By default
+     * a linear mapping is used: {@link LinearInterpolation}.
+     * 
+     * @param func
+     *            interpolate strategy implementation
+     */
+    public void setMapFunction(InterpolateStrategy func) {
+        mapFunction = func;
+    }
+
+    /**
+     * Sets new minimum & maximum values for the output/target range
+     * 
+     * @param min
+     *            new min output value
+     * @param max
+     *            new max output value
+     */
+    public final void setOutputRange(double min, double max) {
+        out = new DoubleRange(min, max);
+        mapRange = max - min;
+    }
+}

data/src/toxi/math/SigmoidInterpolation.java

@@ -0,0 +1,78 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * Copyright (c) 2006-2011 Karsten Schmidt
+ * 
+ * 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 toxi.math;
+
+/**
+ * Implements the sigmoid interpolation function with adjustable curve sharpness
+ */
+public class SigmoidInterpolation implements InterpolateStrategy {
+
+    private float sharpness;
+
+    private float sharpPremult;
+
+    /**
+     * Initializes the s-curve with default sharpness = 2
+     */
+    public SigmoidInterpolation() {
+        this(2f);
+    }
+
+    /**
+     *
+     * @param s
+     */
+    public SigmoidInterpolation(float s) {
+        setSharpness(s);
+    }
+
+    /**
+     *
+     * @return
+     */
+    public float getSharpness() {
+        return sharpness;
+    }
+
+    @Override
+    public double interpolate(double a, double b, double f) {
+        f = 1.0 + Math.exp(-((f * 2 - 1) * sharpPremult));
+        return a + (b - a) / f;
+    }
+
+    @Override
+    public float interpolate(float a, float b, float f) {
+        f = (float) (1.0 + Math.exp(-((f * 2 - 1) * sharpPremult)));
+        return a + (b - a) / f;
+    }
+
+    private void setSharpness(float s) {
+        sharpness = s;
+        sharpPremult = 5 * s;
+    }
+}

data/src/toxi/math/SinCosLUT.java

@@ -0,0 +1,141 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * Copyright (c) 2006-2011 Karsten Schmidt
+ * 
+ * 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 toxi.math;
+
+/**
+ * Lookup table for fast sine & cosine computations. Tables with varying
+ * precisions can be created to which input angles will be rounded to. The
+ * sin/cos methods can be used with both positive and negative input angles as
+ * with the normal Math.sin()/Math.cos() versions.
+ */
+public final class SinCosLUT {
+
+    /**
+     * default precision
+     */
+    public static final float DEFAULT_PRECISION = 0.25f;
+
+    private static SinCosLUT DEFAULT_INSTANCE;
+
+    /**
+     *
+     * @return
+     */
+    public static final SinCosLUT getDefaultInstance() {
+        if (DEFAULT_INSTANCE == null) {
+            DEFAULT_INSTANCE = new SinCosLUT();
+        }
+        return DEFAULT_INSTANCE;
+    }
+
+    /**
+     * Lookup table for sine values
+     */
+    private final float[] sinLUT;
+
+    private final float precision;
+
+    private final int period;
+    private final int quadrant;
+
+    private final float deg2rad;
+    private final float rad2deg;
+
+    /**
+     *
+     */
+    public SinCosLUT() {
+        this(DEFAULT_PRECISION);
+    }
+
+    /**
+     *
+     * @param precision
+     */
+    public SinCosLUT(float precision) {
+        this.precision = precision;
+        this.period = (int) (360 / precision);
+        this.quadrant = period >> 2;
+        this.deg2rad = (float) (Math.PI / 180.0) * precision;
+        this.rad2deg = (float) (180.0 / Math.PI) / precision;
+        this.sinLUT = new float[period];
+        for (int i = 0; i < period; i++) {
+            sinLUT[i] = (float) Math.sin(i * deg2rad);
+        }
+    }
+
+    /**
+     * Calculate cosine for the passed in angle in radians.
+     * 
+     * @param theta
+     * @return cosine value for theta
+     */
+    public final float cos(float theta) {
+        while (theta < 0) {
+            theta += MathUtils.TWO_PI;
+        }
+        return sinLUT[((int) (theta * rad2deg) + quadrant) % period];
+    }
+
+    /**
+     *
+     * @return
+     */
+    public int getPeriod() {
+        return period;
+    }
+
+    /**
+     *
+     * @return
+     */
+    public float getPrecision() {
+        return precision;
+    }
+
+    /**
+     *
+     * @return
+     */
+    public float[] getSinLUT() {
+        return sinLUT;
+    }
+
+    /**
+     * Calculates sine for the passed angle in radians.
+     * 
+     * @param theta
+     * @return sine value for theta
+     */
+    public final float sin(float theta) {
+        while (theta < 0) {
+            theta += MathUtils.TWO_PI;
+        }
+        return sinLUT[(int) (theta * rad2deg) % period];
+    }
+}