toxiclibs 0.2-java → 0.5.0-java

data/src/toxi/image/util/TiledFrameExporter.java

@@ -0,0 +1,162 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.image.util;
+
+import processing.core.PApplet;
+import processing.core.PImage;
+import toxi.geom.Vec3D;
+
+/**
+ *
+ * @author tux
+ */
+public class TiledFrameExporter {
+
+    private final PApplet parent;
+
+    private final PImage buffer;
+
+    private final Vec3D[] offsets;
+
+    private final double normTileSize;
+
+    private final double aspect;
+
+    private final int numTiles;
+
+    private int tileID;
+
+    private float subTileID;
+
+    private boolean isTiling;
+
+    private String fileName;
+
+    TiledFrameExporter(PApplet p, int n) {
+        parent = p;
+        numTiles = n;
+        buffer = new PImage(p.width * n, p.height * n);
+        offsets = new Vec3D[numTiles * numTiles];
+        normTileSize = 2.0 / numTiles;
+        aspect = (double) p.height / p.width;
+        int idx = 0;
+        double y = 1 - normTileSize;
+        while (idx < offsets.length) {
+            double x = -1;
+            for (int xi = 0; xi < numTiles; xi++) {
+                offsets[idx++] = new Vec3D((float) x, (float) y, 0);
+                x += normTileSize;
+            }
+            y -= normTileSize;
+        }
+    }
+
+    /**
+     *
+     * @return
+     */
+    public PImage getBuffer() {
+        return buffer;
+    }
+
+    /**
+     *
+     * @return
+     */
+    public int getCurrentTileID() {
+        return tileID;
+    }
+
+    /**
+     *
+     * @return
+     */
+    public float getProgress() {
+        return (float) tileID / offsets.length;
+    }
+
+    /**
+     *
+     * @return
+     */
+    public boolean isTiling() {
+        return isTiling;
+    }
+
+    /**
+     *
+     */
+    public void post() {
+        if (isTiling) {
+            subTileID += 0.5;
+            if (subTileID > 1) {
+                int x = tileID % numTiles;
+                int y = tileID / numTiles;
+                parent.loadPixels();
+                // TODO add optional callback hook for post-processing tile
+                buffer.set(x * parent.width, y * parent.height, parent.g);
+                if (tileID == offsets.length - 1) {
+                    buffer.save(parent.sketchPath(fileName + "_" + buffer.width
+                            + "x" + buffer.height + ".png"));
+                }
+                subTileID = 0;
+                isTiling = (++tileID < offsets.length);
+            }
+        }
+    }
+
+    /**
+     *
+     */
+    public void pre() {
+        if (isTiling) {
+            setupTile(tileID);
+        }
+    }
+
+    /**
+     *
+     * @param fn
+     */
+    public void save(String fn) {
+        fileName = fn;
+        tileID = 0;
+        subTileID = 0;
+        isTiling = true;
+    }
+
+    /**
+     *
+     * @param id
+     */
+    protected void setupTile(int id) {
+        Vec3D o = offsets[id];
+        parent.frustum(o.x, o.x + (float) normTileSize, (float) (o.y * aspect),
+                (float) (aspect * (o.y + normTileSize)), 0.01f, 10000.f);
+    }
+}

data/src/toxi/math/BezierInterpolation.java

@@ -0,0 +1,102 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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;
+
+/**
+ * Bezier curve interpolation with configurable coefficients. The curve
+ * parameters need to be normalized offsets relative to the start and end values
+ * passed to the {@link #interpolate(float, float, float)} method, but can
+ * exceed the normal 0 .. 1.0 interval. Use symmetrical offsets to create a
+ * symmetrical curve, e.g. this will create a curve with 2 dips reaching the
+ * minimum and maximum values at 25% and 75% of the interval...
+ * 
+ * <p>
+ * <code>BezierInterpolation b=new BezierInterpolation(3,-3);</code>
+ * </p>
+ * 
+ * The curve will be a straight line with this configuration:
+ * 
+ * <p>
+ * <code>BezierInterpolation b=new BezierInterpolation(1f/3,-1f/3);</code>
+ * </p>
+ */
+public class BezierInterpolation implements InterpolateStrategy {
+
+    /**
+     *
+     */
+    public float c1;
+
+    /**
+     *
+     */
+    public float c2;
+
+    /**
+     *
+     * @param h1
+     * @param h2
+     */
+    public BezierInterpolation(float h1, float h2) {
+        this.c1 = h1;
+        this.c2 = h2;
+    }
+
+    @Override
+    public double interpolate(double a, double b, double t) {
+        double tSquared = t * t;
+        double invT = 1.0f - t;
+        double invTSquared = invT * invT;
+        return (a * invTSquared * invT)
+                + (3 * (c1 * (b - a) + a) * t * invTSquared)
+                + (3 * (c2 * (b - a) + b) * tSquared * invT)
+                + (b * tSquared * t);
+    }
+
+    @Override
+    public float interpolate(float a, float b, float t) {
+        float tSquared = t * t;
+        float invT = 1.0f - t;
+        float invTSquared = invT * invT;
+        return (a * invTSquared * invT)
+                + (3 * (c1 * (b - a) + a) * t * invTSquared)
+                + (3 * (c2 * (b - a) + b) * tSquared * invT)
+                + (b * tSquared * t);
+    }
+
+    /**
+     *
+     * @param a
+     * @param b
+     */
+    public void setCoefficients(float a, float b) {
+        c1 = a;
+        c2 = b;
+    }
+
+}

data/src/toxi/math/CircularInterpolation.java

@@ -0,0 +1,88 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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;
+
+/**
+ * Implementation of the circular interpolation function.
+ * 
+ * i = a-(b-a) * (sqrt(1 - (1 - f) * (1 - f) ))
+ */
+public class CircularInterpolation implements InterpolateStrategy {
+
+    /**
+     *
+     */
+    protected boolean isFlipped;
+
+    /**
+     *
+     */
+    public CircularInterpolation() {
+        this(false);
+    }
+
+    /**
+     * The interpolation slope can be flipped to have its steepest ascent
+     * towards the end value, rather than at the beginning in the default
+     * configuration.
+     * 
+     * @param isFlipped
+     *            true, if slope is inverted
+     */
+    public CircularInterpolation(boolean isFlipped) {
+        this.isFlipped = isFlipped;
+    }
+
+    @Override
+    public double interpolate(double a, double b, double f) {
+        if (isFlipped) {
+            return a - (b - a) * (Math.sqrt(1 - f * f) - 1);
+        } else {
+            f = 1 - f;
+            return a + (b - a) * (Math.sqrt(1 - f * f));
+        }
+    }
+
+    @Override
+    public float interpolate(float a, float b, float f) {
+        if (isFlipped) {
+            return a - (b - a) * ((float) Math.sqrt(1 - f * f) - 1);
+        } else {
+            f = 1 - f;
+            return a + (b - a) * ((float) Math.sqrt(1 - f * f));
+        }
+    }
+
+    /**
+     *
+     * @param isFlipped
+     */
+    public void setFlipped(boolean isFlipped) {
+        this.isFlipped = isFlipped;
+    }
+}

data/src/toxi/math/CosineInterpolation.java

@@ -0,0 +1,51 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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;
+
+/**
+ * Implementation of the cosine interpolation function:
+ * 
+ * i = b+(a-b)*(0.5+0.5*cos(f*PI))
+ */
+public class CosineInterpolation implements InterpolateStrategy {
+
+    @Override
+    public double interpolate(double a, double b, double f) {
+        return b + (a - b) * (0.5 + 0.5 * Math.cos(f * Math.PI));
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see toxi.math.InterpolateStrategy#interpolate(float, float, float)
+     */
+    @Override
+    public final float interpolate(float a, float b, float f) {
+        return b + (a - b) * (float) (0.5 + 0.5 * Math.cos(f * MathUtils.PI));
+    }
+}

data/src/toxi/math/DecimatedInterpolation.java

@@ -0,0 +1,77 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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;
+
+/**
+ * Delivers a number of decimated/stepped values for a given interval. E.g. by
+ * using 5 steps the interpolation factor is decimated to: 0, 20, 40, 60, 80 and
+ * 100%. By default {@link LinearInterpolation} is used, however any other
+ * {@link InterpolateStrategy} can be specified via the constructor.
+ */
+public class DecimatedInterpolation implements InterpolateStrategy {
+
+    /**
+     *
+     */
+    public int numSteps;
+
+    /**
+     *
+     */
+    public InterpolateStrategy strategy;
+
+    /**
+     *
+     * @param steps
+     */
+    public DecimatedInterpolation(int steps) {
+        this(steps, new LinearInterpolation());
+    }
+
+    /**
+     *
+     * @param steps
+     * @param strategy
+     */
+    public DecimatedInterpolation(int steps, InterpolateStrategy strategy) {
+        this.numSteps = steps;
+        this.strategy = strategy;
+    }
+
+    @Override
+    public double interpolate(double a, double b, double f) {
+        double fd = (int) (f * numSteps) / (double) numSteps;
+        return strategy.interpolate(a, b, fd);
+    }
+
+    @Override
+    public float interpolate(float a, float b, float f) {
+        float fd = (int) (f * numSteps) / (float) numSteps;
+        return strategy.interpolate(a, b, fd);
+    }
+}