toxiclibs 0.4.0 → 0.8.0

data/src/toxi/sim/fluids/FluidSolver3D.java

@@ -0,0 +1,326 @@
+package toxi.sim.fluids;
+
+import toxi.geom.ReadonlyVec3D;
+import toxi.geom.Vec3D;
+
+/**
+ *
+ * @author tux
+ */
+public class FluidSolver3D {
+
+    private final int size, size2, size3, sm1, sm2;
+    private final float dt;
+
+    /**
+     *
+     */
+    public float diff;
+
+    /**
+     *
+     */
+    public float visc;
+
+    private final float[] s;
+    private final float[] density;
+
+    private final float[] velX, velY, velZ;
+    private final float[] velX0, velY0, velZ0;
+    private final int numIterations = 10;
+
+    /**
+     *
+     * @param size
+     * @param diffusion
+     * @param viscosity
+     * @param dt
+     */
+    public FluidSolver3D(int size, float diffusion, float viscosity, float dt) {
+        this.size = size;
+        this.size2 = size * size;
+        this.size3 = size2 * size;
+        this.sm1 = size - 1;
+        this.sm2 = size - 2;
+        this.diff = diffusion;
+        this.visc = viscosity;
+        this.dt = dt;
+        this.s = new float[size3];
+        this.density = new float[size3];
+        this.velX = new float[size3];
+        this.velY = new float[size3];
+        this.velZ = new float[size3];
+        this.velX0 = new float[size3];
+        this.velY0 = new float[size3];
+        this.velZ0 = new float[size3];
+    }
+
+    /**
+     *
+     * @param x
+     * @param y
+     * @param z
+     * @param amount
+     */
+    public void addDensity(int x, int y, int z, float amount) {
+        density[IX(x, y, z)] += amount;
+    }
+
+    /**
+     *
+     * @param x
+     * @param y
+     * @param z
+     * @param amount
+     */
+    public void addVelocity(int x, int y, int z, Vec3D amount) {
+        int idx = IX(x, y, z);
+        velX[idx] += amount.x;
+        velY[idx] += amount.y;
+        velZ[idx] += amount.z;
+    }
+
+    private void advect(final int b, final float[] d, final float[] d0,
+            final float[] velocX, final float[] velocY, final float[] velocZ) {
+        int i0, j0, k0;
+
+        final float scaledTime = dt * sm2;
+
+        float s0, s1, t0, t1, u0, u1;
+        float x, y, z;
+
+        float maxSize = sm2 + 0.5f;
+        float ifloat, jfloat, kfloat;
+        int i, j, k;
+
+        for (k = 1, kfloat = 1; k < sm1; k++, kfloat++) {
+            for (j = 1, jfloat = 1; j < sm1; j++, jfloat++) {
+                for (i = 1, ifloat = 1; i < sm1; i++, ifloat++) {
+                    final int idx = IX(i, j, k);
+                    x = i - scaledTime * velocX[idx];
+                    y = j - scaledTime * velocY[idx];
+                    z = k - scaledTime * velocZ[idx];
+
+                    if (x < 0.5f) {
+                        x = 0.5f;
+                    }
+                    if (x > maxSize) {
+                        x = maxSize;
+                    }
+                    i0 = (int) x;
+                    if (y < 0.5f) {
+                        y = 0.5f;
+                    }
+                    if (y > maxSize) {
+                        y = maxSize;
+                    }
+                    j0 = (int) y;
+                    if (z < 0.5f) {
+                        z = 0.5f;
+                    }
+                    if (z > maxSize) {
+                        z = maxSize;
+                    }
+                    k0 = (int) z;
+
+                    s1 = x - i0;
+                    s0 = 1.0f - s1;
+                    t1 = y - j0;
+                    t0 = 1.0f - t1;
+                    u1 = z - k0;
+                    u0 = 1.0f - u1;
+
+                    final int ix = IX(i0, j0, k0);
+                    d[idx] =
+
+                    s0
+                            * (t0 * (u0 * d0[ix] + u1 * d0[ix + size2]) + (t1 * (u0
+                                    * d0[ix + size] + u1
+                                    * d0[ix + size + size2])))
+                            + s1
+                            * (t0 * (u0 * d0[ix + 1] + u1 * d0[ix + 1 + size2]) + (t1 * (u0
+                                    * d0[ix + 1 + size] + u1
+                                    * d0[ix + 1 + size + size2])));
+                }
+            }
+        }
+        set_bnd(b, d);
+    }
+
+    /**
+     *
+     * @param x
+     * @param y
+     * @param z
+     */
+    public void clearAt(int x, int y, int z) {
+        final int idx = IX(x, y, z);
+        if (idx >= 0 && idx < density.length) {
+            density[idx] = 0;
+            velX[idx] = velY[idx] = velZ[idx] = 0;
+        }
+    }
+
+    /**
+     *
+     * @param decay
+     */
+    public final void decay(float decay) {
+        for (int i = 0; i < density.length; i++) {
+            density[i] *= decay;
+        }
+    }
+
+    private void diffuse(final int b, final float[] x, final float[] x0,
+            final float diff) {
+        float a = dt * diff * sm2 * sm2;
+        lin_solve(b, x, x0, a, 1 + 6 * a);
+    }
+
+    /**
+     * @return the density
+     */
+    public float[] getDensity() {
+        return density;
+    }
+
+    private int IX(int x, int y, int z) {
+        return x + y * size + z * size2;
+    }
+
+    void lin_solve(final int b, final float[] x, final float[] x0,
+            final float a, final float c) {
+        float cRecip = 1.0f / c;
+        for (int k = 0; k < numIterations; k++) {
+            for (int m = 1; m < sm1; m++) {
+                for (int j = 1, idx = m * size2 + size + 1; j < sm1; j++) {
+                    for (int i = 1; i < sm1; i++) {
+                        x[idx] = (x0[idx] + a
+                                * (x[idx + 1] + x[idx - 1] + x[idx + size]
+                                        + x[idx - size] + x[idx + size2] + x[idx
+                                        - size2]))
+                                * cRecip;
+                        idx++;
+                    }
+                }
+            }
+            set_bnd(b, x);
+        }
+    }
+
+    private void project(final float[] velocX, final float[] velocY,
+            final float[] velocZ, final float[] p, final float[] div) {
+        final float invSize = -0.5f * 1f / size;
+        for (int k = 1; k < sm1; k++) {
+            for (int j = 1; j < sm1; j++) {
+                for (int i = 1; i < sm1; i++) {
+                    final int idx = IX(i, j, k);
+                    div[idx] = (velocX[idx + 1] - velocX[idx - 1]
+                            + velocY[idx + size] - velocY[idx - size]
+                            + velocZ[idx + size2] - velocZ[idx - size2])
+                            * invSize;
+                    p[idx] = 0;
+                }
+            }
+        }
+        set_bnd(0, div);
+        set_bnd(0, p);
+        lin_solve(0, p, div, 1, 6);
+
+        float hs = 0.5f * size;
+        for (int k = 1; k < sm1; k++) {
+            for (int j = 1; j < sm1; j++) {
+                for (int i = 1; i < sm1; i++) {
+                    final int idx = IX(i, j, k);
+                    velocX[idx] -= hs * (p[idx + 1] - p[idx - 1]);
+                    velocY[idx] -= hs * (p[idx + size] - p[idx - size]);
+                    velocZ[idx] -= hs * (p[idx + size2] - p[idx - size2]);
+                }
+            }
+        }
+        set_bnd(1, velocX);
+        set_bnd(2, velocY);
+        set_bnd(3, velocZ);
+    }
+
+    private void set_bnd(int b, float[] x) {
+        for (int j = 1; j < sm1; j++) {
+            for (int i = 1; i < sm1; i++) {
+                final int idx = IX(i, j, 0);
+                x[idx] = b == 3 ? -x[idx + size2] : x[idx + size2];
+                x[idx + sm1 * size2] = b == 3 ? -x[idx + sm2 * size2] : x[idx
+                        + sm2 * size2];
+            }
+        }
+        for (int k = 1; k < sm1; k++) {
+            for (int i = 1; i < sm1; i++) {
+                final int idx = IX(i, 0, k);
+                x[idx] = b == 2 ? -x[idx + size] : x[idx + size];
+                x[idx + sm1 * size] = b == 2 ? -x[idx + size * sm2] : x[idx
+                        + size * sm2];
+            }
+        }
+        for (int k = 1; k < sm1; k++) {
+            for (int j = 1; j < sm1; j++) {
+                final int idx = IX(0, j, k);
+                x[idx] = b == 1 ? -x[idx + 1] : x[idx + 1];
+                x[idx + sm1] = b == 1 ? -x[idx + sm2] : x[idx + sm2];
+            }
+        }
+
+        x[0] = 0.33f * (x[IX(1, 0, 0)] + x[IX(0, 1, 0)] + x[IX(0, 0, 1)]);
+        x[IX(0, sm1, 0)] = 0.33f * (x[IX(1, sm1, 0)] + x[IX(0, sm2, 0)] + x[IX(
+                0, sm1, 1)]);
+        x[IX(0, 0, sm1)] = 0.33f * (x[IX(1, 0, sm1)] + x[IX(0, 1, sm1)] + x[IX(
+                0, 0, sm1)]);
+        x[IX(0, sm1, sm1)] = 0.33f * (x[IX(1, sm1, sm1)] + x[IX(0, sm2, sm1)] + x[IX(
+                0, sm1, sm2)]);
+        x[IX(sm1, 0, 0)] = 0.33f * (x[IX(sm2, 0, 0)] + x[IX(sm1, 1, 0)] + x[IX(
+                sm1, 0, 1)]);
+        x[IX(sm1, sm1, 0)] = 0.33f * (x[IX(sm2, sm1, 0)] + x[IX(sm1, sm2, 0)] + x[IX(
+                sm1, sm1, 1)]);
+        x[IX(sm1, 0, sm1)] = 0.33f * (x[IX(sm2, 0, sm1)] + x[IX(sm1, 1, sm1)] + x[IX(
+                sm1, 0, sm2)]);
+        x[IX(sm1, sm1, sm1)] = 0.33f * (x[IX(sm2, sm1, sm1)]
+                + x[IX(sm1, sm2, sm1)] + x[IX(sm1, sm1, sm2)]);
+    }
+
+    /**
+     *
+     * @param x
+     * @param y
+     * @param z
+     * @param dens
+     * @param vel
+     */
+    public void setAt(int x, int y, int z, float dens, ReadonlyVec3D vel) {
+        final int idx = IX(x, y, z);
+        if (idx >= 0 && idx < density.length) {
+            density[idx] = dens;
+            velX[idx] = vel.x();
+            velY[idx] = vel.y();
+            velZ[idx] = vel.z();
+        }
+    }
+
+    /**
+     *
+     */
+    public void update() {
+        diffuse(1, velX0, velX, visc);
+        diffuse(2, velY0, velY, visc);
+        diffuse(3, velZ0, velZ, visc);
+
+        project(velX0, velY0, velZ0, velX, velY);
+
+        advect(1, velX, velX0, velX0, velY0, velZ0);
+        advect(2, velY, velY0, velX0, velY0, velZ0);
+        advect(3, velZ, velZ0, velX0, velY0, velZ0);
+
+        project(velX, velY, velZ, velX0, velY0);
+
+        diffuse(0, s, density, diff);
+        advect(0, density, s, velX, velY, velZ);
+    }
+
+}

data/src/toxi/sim/grayscott/GrayScott.java

@@ -0,0 +1,469 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.sim.grayscott;
+
+import toxi.geom.Rect;
+import toxi.math.MathUtils;
+
+/**
+ * Implementation of the Gray-Scott reaction diffusion model described in detail
+ * on the links below:
+ * <ul>
+ * <li>http://groups.csail.mit.edu/mac/projects/amorphous/GrayScott/</li>
+ * <li>http://ix.cs.uoregon.edu/~jlidbeck/java/rd/</li>
+ * <li>http://www.mrob.com/pub/comp/xmorphia/</li>
+ * </ul>
+ */
+public class GrayScott {
+
+    public float[] u,
+
+    /**
+     *
+     */
+
+    /**
+     *
+     */
+    v;
+    protected float[] uu,
+
+    /**
+     *
+     */
+
+    /**
+     *
+     */
+    vv;
+
+    protected int width,
+
+    /**
+     *
+     */
+
+    /**
+     *
+     */
+    height;
+
+    protected float f,
+
+    /**
+     *
+     */
+
+    /**
+     *
+     */
+    k;
+    protected float dU,
+
+    /**
+     *
+     */
+
+    /**
+     *
+     */
+    dV;
+
+    /**
+     *
+     */
+    protected boolean isTiling;
+
+    /**
+     *
+     * @param width
+     * @param height
+     * @param wrap
+     */
+    public GrayScott(int width, int height, boolean wrap) {
+        this.width = width;
+        this.height = height;
+        this.u = new float[width * height];
+        this.v = new float[u.length];
+        this.uu = new float[u.length];
+        this.vv = new float[u.length];
+        this.isTiling = wrap;
+        reset();
+        // default config
+        setCoefficients(0.023f, 0.077f, 0.16f, 0.08f);
+    }
+
+    /**
+     * Convenience method to access U array using 2D coordinates.
+     * 
+     * @param x
+     * @param y
+     * @return current u value at the given position
+     */
+    public float getCurrentUAt(int x, int y) {
+        if (y >= 0 && y < height && x >= 0 && x < width) {
+            return u[y * width + x];
+        }
+        return 0;
+    }
+
+    /**
+     * Convenience method to access V array using 2D coordinates.
+     * 
+     * @param x
+     * @param y
+     * @return current v value at the given position
+     */
+    public float getCurrentVAt(int x, int y) {
+        if (y >= 0 && y < height && x >= 0 && x < width) {
+            return v[y * width + x];
+        }
+        return 0;
+    }
+
+    /**
+     * @return the diffuse U coefficient
+     */
+    public float getDiffuseU() {
+        return dU;
+    }
+
+    /**
+     * @return the diffuse V coefficient
+     */
+    public float getDiffuseV() {
+        return dV;
+    }
+
+    /**
+     * @return the F coefficient
+     */
+    public float getF() {
+        return f;
+    }
+
+    /**
+     * Extension point for subclasses to modulate the F coefficient of the
+     * reaction diffusion, based on spatial (or other) parameters. This method
+     * is called for every cell/pixel of the simulation space from the main
+     * {@link #update(float)} cycle and can be used to create parameter
+     * gradients, animations and other spatial or temporal modulations.
+     * 
+     * @param x
+     * @param y
+     * @return the active F coefficient at the given position
+     */
+    public float getFCoeffAt(int x, int y) {
+        return f;
+    }
+
+    /**
+     * @return the K coefficient
+     */
+    public float getK() {
+        return k;
+    }
+
+    /**
+     * Extension point for subclasses to modulate the K coefficient of the
+     * reaction diffusion, based on spatial (or other) parameters. This method
+     * is called for every cell/pixel of the simulation space and can be used to
+     * create parameter gradients, animations and other spatial or temporal
+     * modulations.
+     * 
+     * @param x
+     * @param y
+     * @return the active K coefficient at the given position
+     */
+    public float getKCoeffAt(int x, int y) {
+        return k;
+    }
+
+    /**
+     * @return the isTiling
+     */
+    public boolean isTiling() {
+        return isTiling;
+    }
+
+    /**
+     * Resets the simulation matrix to an initial, clean state.
+     */
+    public final void reset() {
+        for (int i = 0; i < uu.length; i++) {
+            uu[i] = 1.0f;
+            vv[i] = 0.0f;
+        }
+    }
+
+    /**
+     *
+     * @param pixels
+     * @param imgWidth
+     * @param imgHeight
+     */
+    public void seedImage(int[] pixels, int imgWidth, int imgHeight) {
+        int xo = MathUtils.clip((width - imgWidth) / 2, 0, width - 1);
+        int yo = MathUtils.clip((height - imgHeight) / 2, 0, height - 1);
+        imgWidth = MathUtils.min(imgWidth, width);
+        imgHeight = MathUtils.min(imgHeight, height);
+        for (int y = 0; y < imgHeight; y++) {
+            int i = y * imgWidth;
+            for (int x = 0; x < imgWidth; x++) {
+                if (0 < (pixels[i + x] & 0xff)) {
+                    int idx = (yo + y) * width + xo + x;
+                    uu[idx] = 0.5f;
+                    vv[idx] = 0.25f;
+                }
+            }
+        }
+    }
+
+    /**
+     *
+     * @param f
+     * @param k
+     * @param dU
+     * @param dV
+     */
+    public final void setCoefficients(float f, float k, float dU, float dV) {
+        this.f = f;
+        this.k = k;
+        this.dU = dU;
+        this.dV = dV;
+    }
+
+    /**
+     * @param dU
+     *            the diffuse U coefficient to set
+     */
+    public void setDiffuseU(float dU) {
+        this.dU = dU;
+    }
+
+    /**
+     * @param dV
+     *            the diffuse V coefficient to set
+     */
+    public void setDiffuseV(float dV) {
+        this.dV = dV;
+    }
+
+    /**
+     * @param f
+     *            the F coefficient to set
+     */
+    public void setF(float f) {
+        this.f = f;
+    }
+
+    /**
+     * @param k
+     *            the K coefficient to set
+     */
+    public void setK(float k) {
+        this.k = k;
+    }
+
+    /**
+     * @param x
+     * @param y
+     * @param w
+     * @param h
+     */
+    public void setRect(int x, int y, int w, int h) {
+        int mix = MathUtils.clip(x - w / 2, 0, width);
+        int max = MathUtils.clip(x + w / 2, 0, width);
+        int miy = MathUtils.clip(y - h / 2, 0, height);
+        int may = MathUtils.clip(y + h / 2, 0, height);
+        for (int yy = miy; yy < may; yy++) {
+            for (int xx = mix; xx < max; xx++) {
+                int idx = yy * width + xx;
+                uu[idx] = 0.5f;
+                vv[idx] = 0.25f;
+            }
+        }
+    }
+
+    /**
+     *
+     * @param r
+     */
+    public void setRect(Rect r) {
+        setRect((int) r.x, (int) r.y, (int) r.width, (int) r.height);
+    }
+
+    /**
+     * @param isTiling
+     *            the isTiling to set
+     */
+    public void setTiling(boolean isTiling) {
+        this.isTiling = isTiling;
+    }
+
+    /**
+     *
+     * @param t
+     */
+    public void update(float t) {
+        t = MathUtils.clip(t, 0, 1f);
+        int w1 = width - 1;
+        int h1 = height - 1;
+        for (int y = 1; y < h1; y++) {
+            for (int x = 1; x < w1; x++) {
+                int idx = y * width + x;
+                int top = idx - width;
+                int bottom = idx + width;
+                int left = idx - 1;
+                int right = idx + 1;
+                float currF = getFCoeffAt(x, y);
+                float currK = getKCoeffAt(x, y);
+                float currU = uu[idx];
+                float currV = vv[idx];
+                float d2 = currU * currV * currV;
+                u[idx] = MathUtils
+                        .max(0,
+                                currU
+                                        + t
+                                        * ((dU
+                                                * ((uu[right] + uu[left]
+                                                        + uu[bottom] + uu[top]) - 4 * currU) - d2) + currF
+                                                * (1.0f - currU)));
+                v[idx] = MathUtils
+                        .max(0,
+                                currV
+                                        + t
+                                        * ((dV
+                                                * ((vv[right] + vv[left]
+                                                        + vv[bottom] + vv[top]) - 4 * currV) + d2) - currK
+                                                * currV));
+            }
+        }
+
+        if (isTiling) {
+            int w2 = w1 - 1;
+            int idxH1 = h1 * width;
+            int idxH2 = (h1 - 1) * width;
+            for (int x = 0; x < width; x++) {
+                int left = (x == 0 ? w1 : x - 1);
+                int right = (x == w1 ? 0 : x + 1);
+                int idx = idxH1 + x;
+                float cu = uu[x];
+                float cv = vv[x];
+                float cui = uu[idx];
+                float cvi = vv[idx];
+                float d = cu * cv * cv;
+                u[x] = MathUtils
+                        .max(0,
+                                cu
+                                        + t
+                                        * ((dU
+                                                * ((uu[right] + uu[left]
+                                                        + uu[width + x] + cui) - 4 * cu) - d) + f
+                                                * (1.0f - cu)));
+                v[x] = MathUtils
+                        .max(0,
+                                cv
+                                        + t
+                                        * ((dV
+                                                * ((vv[right] + vv[left]
+                                                        + vv[width + x] + cvi) - 4 * cv) + d) - k
+                                                * cv));
+                d = cui * cvi * cvi;
+                u[idx] = MathUtils
+                        .max(0,
+                                cui
+                                        + t
+                                        * ((dU
+                                                * ((uu[idxH1 + right]
+                                                        + uu[idxH1 + left] + cu + uu[idxH2
+                                                        + x]) - 4 * cui) - d) + f
+                                                * (1.0f - cui)));
+                v[idx] = MathUtils
+                        .max(0,
+                                cvi
+                                        + t
+                                        * ((dU
+                                                * ((vv[idxH1 + right]
+                                                        + vv[idxH1 + left] + cv + vv[idxH2
+                                                        + x]) - 4 * cvi) + d) - k
+                                                * cvi));
+            }
+
+            for (int y = 0; y < height; y++) {
+                int idx = y * width;
+                int idxW1 = idx + w1;
+                int idxW2 = idx + w2;
+                float cu = uu[idx];
+                float cv = vv[idx];
+                float cui = uu[idxW1];
+                float cvi = vv[idxW1];
+                float d = cu * cv * cv;
+                int up = (y == 0 ? h1 : y - 1) * width;
+                int down = (y == h1 ? 0 : y + 1) * width;
+                u[idx] = MathUtils
+                        .max(0,
+                                cu
+                                        + t
+                                        * ((dU
+                                                * ((uu[idx + 1] + cui
+                                                        + uu[down] + uu[up]) - 4 * cu) - d) + f
+                                                * (1.0f - cu)));
+                v[idx] = MathUtils
+                        .max(0,
+                                cv
+                                        + t
+                                        * ((dV
+                                                * ((vv[idx + 1] + cvi
+                                                        + vv[down] + vv[up]) - 4 * cv) + d) - k
+                                                * cv));
+                d = cui * cvi * cvi;
+                u[idxW1] = MathUtils
+                        .max(0,
+                                cui
+                                        + t
+                                        * ((dU
+                                                * ((cu + uu[idxW2]
+                                                        + uu[down + w1] + uu[up
+                                                        + w1]) - 4 * cui) - d) + f
+                                                * (1.0f - cui)));
+                v[idxW1] = MathUtils
+                        .max(0,
+                                cvi
+                                        + t
+                                        * ((dV
+                                                * ((cv + vv[idxW2]
+                                                        + vv[down + w1] + vv[up
+                                                        + w1]) - 4 * cvi) + d) - k
+                                                * cvi));
+            }
+        }
+        System.arraycopy(u, 0, uu, 0, u.length);
+        System.arraycopy(v, 0, vv, 0, v.length);
+    }
+}