toxiclibs 0.4.0 → 0.8.0

data/src/toxi/sim/dla/RadialDistanceOrder.java

@@ -0,0 +1,92 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.dla;
+
+import java.util.Comparator;
+
+import toxi.geom.Line3D;
+import toxi.geom.Vec3D;
+
+/**
+ * This comparator sorts segments based on their mid-point's distance to a given
+ * origin point. This creates a circular growth. The order can be reversed via a
+ * constructor flag and then causes the DLA system to grow from the outside
+ * towards the given origin point.
+ */
+public class RadialDistanceOrder implements Comparator<Line3D> {
+
+    /**
+     *
+     */
+    public Vec3D origin;
+
+    /**
+     *
+     */
+    public boolean isFlipped;
+
+    /**
+     *
+     */
+    public RadialDistanceOrder() {
+        this(new Vec3D(), false);
+    }
+
+    /**
+     *
+     * @param origin
+     * @param isFlipped
+     */
+    public RadialDistanceOrder(Vec3D origin, boolean isFlipped) {
+        this.origin = origin;
+        this.isFlipped = isFlipped;
+    }
+
+    /**
+     *
+     * @param a
+     * @param b
+     * @return
+     */
+    @Override
+    public int compare(Line3D a, Line3D b) {
+        float da = origin.sub(a.getMidPoint()).magSquared();
+        float db = origin.sub(b.getMidPoint()).magSquared();
+        if (isFlipped) {
+            da *= -1;
+            db *= -1;
+        }
+        if (da < db) {
+            return -1;
+        }
+        if (da > db) {
+            return 1;
+        }
+        return 0;
+    }
+}

data/src/toxi/sim/erosion/ErosionFunction.java

@@ -0,0 +1,122 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.erosion;
+
+import toxi.geom.Polygon2D;
+import toxi.geom.Rect;
+import toxi.geom.Vec2D;
+
+/**
+ * Abstract parent class for various 2D erosion simulations, implemented as
+ * sub-classes.
+ */
+public abstract class ErosionFunction {
+
+    /**
+     *
+     */
+    protected float[] elevation;
+
+    /**
+     *
+     */
+    protected int width;
+
+    /**
+     *
+     */
+    protected int height;
+
+    /**
+     *
+     */
+    protected float[] d = new float[9];
+
+    /**
+     *
+     */
+    protected float[] h = new float[9];
+
+    /**
+     *
+     */
+    protected int[] off;
+
+    /**
+     * Destructively erodes the given array.
+     * 
+     */
+    public void erodeAll() {
+        for (int y = 1, w1 = width - 1, h1 = height - 1; y < h1; y++) {
+            for (int x = 1; x < w1; x++) {
+                erodeAt(x, y);
+            }
+        }
+    }
+
+    /**
+     *
+     * @param x
+     * @param y
+     */
+    public abstract void erodeAt(int x, int y);
+
+    /**
+     *
+     * @param poly
+     */
+    public void erodeWithinPolygon(Polygon2D poly) {
+        Rect bounds = poly.getBounds().intersectionRectWith(
+                new Rect(1, 1, width - 2, height - 2));
+        Vec2D pos = new Vec2D();
+        for (int y = (int) bounds.getTop(), y2 = (int) bounds.getBottom(); y < y2; y++) {
+            for (int x = (int) bounds.getLeft(), x2 = (int) bounds.getRight(); x < x2; x++) {
+                if (poly.containsPoint(pos.set(x, y))) {
+                    erodeAt(x, y);
+                }
+            }
+        }
+    }
+
+    /**
+     *
+     * @param elevation
+     * @param width
+     * @param height
+     */
+    public void setElevation(float[] elevation, final int width,
+            final int height) {
+        this.elevation = elevation;
+        this.width = width;
+        this.height = height;
+        off = new int[] {
+                -width - 1, -width, -width + 1, -1, 0, 1, width - 1, width,
+                width + 1
+        };
+    }
+}

data/src/toxi/sim/erosion/TalusAngleErosion.java

@@ -0,0 +1,145 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.erosion;
+
+/**
+ * For each neighbour it's computed the difference between the processed cell
+ * and the neighbour:
+ * 
+ * <pre>
+ * d[i] = h - h[i];
+ * </pre>
+ * 
+ * the maximum positive difference is stored in d_max, and the sum of all the
+ * positive differences that are bigger than T (this numer is n), the talus
+ * angle, is stored in d_tot.
+ * 
+ * Now it's possible to update all the n cells (where d[i] is bigger than T)
+ * using this formula:
+ * 
+ * <pre>
+ * h[i] = h[i] + c * (d_max - T) * (d[i] / d_tot);
+ * </pre>
+ * 
+ * and the main cell with this other formula:
+ * 
+ * <pre>
+ * h = h - (d_max - (n * d_max * T / d_tot));
+ * </pre>
+ * 
+ * The Talus angle T is a threshold that determines which slopes are affected by
+ * the erosion, instead the c constant determines how much material is eroded.
+ */
+public class TalusAngleErosion extends ErosionFunction {
+
+    private float theta;
+    private float amount;
+
+    /**
+     * @param theta
+     *            talus angle
+     * @param amount
+     *            material transport amount
+     */
+    public TalusAngleErosion(float theta, float amount) {
+        this.theta = theta;
+        this.amount = amount;
+    }
+
+    /**
+     *
+     * @param x
+     * @param y
+     */
+    @Override
+    public void erodeAt(int x, int y) {
+        int idx = y * width + x;
+        float maxD = 0;
+        float sumD = 0;
+        int n = 0;
+        for (int i = 0; i < 9; i++) {
+            h[i] = elevation[idx + off[i]];
+            d[i] = elevation[idx] - h[i];
+            if (d[i] > theta) {
+                sumD += d[i];
+                n++;
+                if (d[i] > maxD) {
+                    maxD = d[i];
+                }
+            }
+        }
+        if (sumD > 0) {
+            elevation[idx] -= (maxD - (n * maxD * theta / sumD));
+            for (int i = 0; i < 9; i++) {
+                if (d[i] > theta) {
+                    elevation[idx + off[i]] = h[i] + amount * (maxD - theta)
+                            * (d[i] / sumD);
+                }
+            }
+        }
+    }
+
+    /**
+     * @return the amount
+     */
+    public float getAmount() {
+        return amount;
+    }
+
+    /**
+     * @return the theta
+     */
+    public float getTheta() {
+        return theta;
+    }
+
+    /**
+     * @param amount
+     *            the amount to set
+     */
+    public void setAmount(float amount) {
+        this.amount = amount;
+    }
+
+    /**
+     * @param theta
+     *            the theta to set
+     */
+    public void setTheta(float theta) {
+        this.theta = theta;
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public String toString() {
+        return getClass().getName() + ": theta=" + theta + " amount=" + amount;
+    }
+}

data/src/toxi/sim/erosion/ThermalErosion.java

@@ -0,0 +1,75 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.erosion;
+
+/**
+ * Applies thermal erosion to the given elevation data. Based on the description
+ * here: http://www.m3xbox.com/GPU_blog/?p=37
+ */
+public class ThermalErosion extends ErosionFunction {
+
+    /**
+     *
+     * @param x
+     * @param y
+     */
+    @Override
+    public void erodeAt(int x, int y) {
+        int idx = y * width + x;
+        float minD = Float.MAX_VALUE;
+        float sumD = 0;
+        int n = 0;
+        for (int i = 0; i < 9; i++) {
+            h[i] = elevation[idx + off[i]];
+            d[i] = elevation[idx] - h[i];
+            if (d[i] > 0) {
+                if (d[i] < minD) {
+                    minD = d[i];
+                }
+                sumD += d[i];
+                n++;
+            }
+        }
+        float hOut = n * minD / (n + 1.0f);
+        elevation[idx] = elevation[idx] - hOut;
+        for (int i = 0; i < 9; i++) {
+            if (d[i] > 0) {
+                elevation[idx + off[i]] = h[i] + hOut * (d[i] / sumD);
+            }
+        }
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public String toString() {
+        return getClass().getName();
+    }
+}

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

@@ -0,0 +1,762 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.fluids;
+
+/**
+ * Optimized Jos Stam style fluid solver with vorticity confinement and buoyancy
+ * force.
+ * 
+ * @author Alexander McKenzie
+ * @author Karsten Schmidt
+ * 
+ *         <p>
+ *         optimized by toxi 2006-02-09
+ *         <ul>
+ *         <li>reduced nesting level of loops</li>
+ *         <li>removed need for I() util method by unrolling all index
+ *         calculations</li>
+ *         <li>renamed variables for better legibility</li>
+ *         </ul>
+ *         </p>
+ **/
+public class FluidSolver2D {
+
+    /**
+     *
+     */
+    protected int numIterations = 10;
+
+    protected int width,
+
+    /**
+     *
+     */
+
+    /**
+     *
+     */
+    totalWidth,
+
+    /**
+     *
+     */
+
+    /**
+     *
+     */
+    height,
+
+    /**
+     *
+     */
+
+    /**
+     *
+     */
+    totalHeight;
+
+    /**
+     *
+     */
+    protected int size;
+
+    /**
+     *
+     */
+    protected float timeStep;
+
+    /**
+     *
+     */
+    protected float viscosity = 0;
+
+    /**
+     *
+     */
+    protected float diffusion = 0.000001f;
+
+    /**
+     *
+     */
+    protected float buoyancyA = 0.000625f;
+
+    /**
+     *
+     */
+    protected float buoyancyB = 0.025f;
+
+    /**
+     *
+     */
+    // protected float[] tmp;
+    protected float[] d,
+
+    /**
+     *
+     */
+
+    /**
+     *
+     */
+    dOld;
+    protected float[] u,
+
+    /**
+     *
+     */
+
+    /**
+     *
+     */
+    uOld;
+    protected float[] v,
+
+    /**
+     *
+     */
+
+    /**
+     *
+     */
+    vOld;
+
+    /**
+     *
+     */
+    protected float[] curl;
+
+    /**
+     * Creates a new instance of the given dimension uses the specified time
+     * step.
+     * 
+     * @param w
+     *            matrix width
+     * @param h
+     *            matrix height
+     * @param timeStep
+     */
+    public FluidSolver2D(int w, int h, float timeStep) {
+        this.width = w;
+        this.height = h;
+        this.totalWidth = w + 2;
+        this.totalHeight = h + 2;
+        this.timeStep = timeStep;
+        size = totalWidth * totalHeight;
+        d = new float[size];
+        dOld = new float[size];
+        u = new float[size];
+        uOld = new float[size];
+        v = new float[size];
+        vOld = new float[size];
+        curl = new float[size];
+        reset();
+    }
+
+    /**
+     *
+     * @param buffer
+     * @param prev
+     */
+    protected void addSource(float[] buffer, float[] prev) {
+        for (int i = 0; i < size; i++) {
+            buffer[i] += timeStep * prev[i];
+        }
+    }
+
+    /**
+     * Calculate the input array after advection. We start with an input array
+     * from the previous timestep and an and output array. For all grid cells we
+     * need to calculate for the next timestep, we trace the cell's center
+     * position backwards through the velocity field. Then we interpolate from
+     * the grid of the previous timestep and assign this value to the current
+     * grid cell.
+     * 
+     * @param b
+     *            Flag specifying how to handle boundries.
+     * @param d
+     *            Array to store the advected field.
+     * @param d0
+     *            The array to advect.
+     * @param du
+     *            The x component of the velocity field.
+     * @param dv
+     *            The y component of the velocity field.
+     **/
+
+    protected void advect(int b, float[] d, float[] d0, float[] du, float[] dv) {
+        int i0, j0;
+        float x, y, s0, t0, s1, t1, scaledTime;
+        float wmax = width + 0.5f;
+        float hmax = height + 0.5f;
+
+        scaledTime = timeStep * width;
+
+        for (int i = 1, j = 1, idx = i + totalWidth; j <= height;) {
+            // go backwards through velocity field
+            x = i - scaledTime * du[idx];
+            y = j - scaledTime * dv[idx];
+
+            // interpolate results
+            if (x > wmax) {
+                x = wmax;
+            }
+            if (x < 0.5f) {
+                x = 0.5f;
+            }
+
+            i0 = (int) x;
+
+            if (y > hmax) {
+                y = hmax;
+            }
+            if (y < 0.5f) {
+                y = 0.5f;
+            }
+
+            j0 = (int) y;
+
+            s1 = x - i0;
+            s0 = 1 - s1;
+            t1 = y - j0;
+            t0 = 1 - t1;
+
+            int idx0 = i0 + j0 * totalWidth;
+            d[idx] = s0 * (t0 * d0[idx0] + t1 * d0[idx0 + totalWidth]) + s1
+                    * (t0 * d0[idx0 + 1] + t1 * d0[idx0 + totalWidth + 1]);
+
+            if (i < width) {
+                i++;
+                idx++;
+            } else {
+                i = 1;
+                j++;
+                idx += 3;
+            }
+        }
+        setBoundary(b, d);
+    }
+
+    /**
+     * Calculate the buoyancy force as part of the velocity solver. Fbuoy =
+     * -a*d*Y + b*(T-Tamb)*Y where Y = (0,1). The constants a and b are positive
+     * with appropriate (physically meaningful) units. T is the temperature at
+     * the current cell, Tamb is the average temperature of the fluid grid. The
+     * density d provides a mass that counteracts the buoyancy force.
+     * 
+     * In this simplified implementation, we say that the temperature is
+     * synonymous with density (since smoke is *hot*) and because there are no
+     * other heat sources we can just use the density field instead of a new,
+     * seperate temperature field.
+     * 
+     * @param buoy
+     *            Array to store buoyancy force for each cell.
+     **/
+
+    protected void buoyancy(float[] buoy) {
+        float avgTemperature = 0;
+
+        // sum all temperatures
+        for (int i = 1, idx = 1 + totalWidth, j = 1; j <= height;) {
+            avgTemperature += d[idx];
+            if (i < width) {
+                i++;
+                idx++;
+            } else {
+                i = 1;
+                j++;
+                idx += 3;
+            }
+        }
+
+        // get average temperature
+        avgTemperature /= (width * height);
+
+        // for each cell compute buoyancy force
+        for (int i = 1, idx = 1 + totalWidth, j = 1; j <= height;) {
+            float currD = d[idx];
+            buoy[idx] = buoyancyA * currD - buoyancyB
+                    * (currD - avgTemperature);
+            if (i < width) {
+                i++;
+                idx++;
+            } else {
+                i = 1;
+                j++;
+                idx += 3;
+            }
+        }
+    }
+
+    /**
+     * Calculate the curl 
+     * 
+     * @param idx
+     * @return 
+     **/
+
+    protected final float curl(int idx) {
+        float du_dy = (u[idx + totalWidth] - u[idx - totalWidth]) * 0.5f;
+        float dv_dx = (v[idx + 1] - v[idx - 1]) * 0.5f;
+        return du_dy - dv_dx;
+    }
+
+    /**
+     *
+     * @param decay
+     */
+    public final void decay(float decay) {
+        for (int i = 0; i < size; i++) {
+            u[i] *= decay;
+            v[i] *= decay;
+            d[i] *= decay;
+        }
+    }
+
+    /**
+     * The basic density solving routine.
+     **/
+    public void densitySolver() {
+        // add density input by mouse
+        addSource(d, dOld);
+        float[] temp = d;
+        d = dOld;
+        dOld = temp;
+        diffusion(0, d, dOld, diffusion);
+        temp = d;
+        d = dOld;
+        dOld = temp;
+        advect(0, d, dOld, u, v);
+
+        // clear input density array for next frame
+        for (int i = 0; i < size; i++) {
+            dOld[i] = 0;
+        }
+    }
+
+    /**
+     * Recalculate the input array with diffusion effects. Here we consider a
+     * stable method of diffusion by finding the densities, which when diffusion
+     * used backward in time yield the same densities we started with. This is
+     * achieved through use of a linear solver to solve the sparse matrix built
+     * from this linear system.
+     * 
+     * @param b
+     *            Flag to specify how boundaries should be handled.
+     * @param c
+     *            The array to store the results of the diffusion computation.
+     * @param c0
+     *            The input array on which we should compute diffusion.
+     * @param diffusion
+     *            The factor of diffusion.
+     **/
+
+    protected void diffusion(int b, float[] c, float[] c0, float diffusion) {
+        float a = timeStep * diffusion * width * height;
+        linearSolver(b, c, c0, a, 1 + 4 * a);
+    }
+
+    /**
+     * @return the buoyancyA
+     */
+    public float getBuoyancyA() {
+        return buoyancyA;
+    }
+
+    /**
+     * @return the buoyancyB
+     */
+    public float getBuoyancyB() {
+        return buoyancyB;
+    }
+
+    /**
+     * @return the curl
+     */
+    public float[] getCurl() {
+        return curl;
+    }
+
+    /**
+     * @return the d
+     */
+    public float[] getDensityField() {
+        return d;
+    }
+
+    /**
+     * @return the diffusion
+     */
+    public float getDiffusion() {
+        return diffusion;
+    }
+
+    /**
+     * @return the numIterations
+     */
+    public int getNumIterations() {
+        return numIterations;
+    }
+
+    /**
+     * @return the timeStep
+     */
+    public float getTimeStep() {
+        return timeStep;
+    }
+
+    /**
+     * @return the totalHeight
+     */
+    public int getTotalHeight() {
+        return totalHeight;
+    }
+
+    /**
+     * @return the totalWidth
+     */
+    public int getTotalWidth() {
+        return totalWidth;
+    }
+
+    /**
+     * @return the u
+     */
+    public float[] getVelocityFieldU() {
+        return u;
+    }
+
+    /**
+     * @return the v
+     */
+    public float[] getVelocityFieldV() {
+        return v;
+    }
+
+    /**
+     * @return the viscosity
+     */
+    public float getViscosity() {
+        return viscosity;
+    }
+
+    /**
+     * Iterative linear system solver using the Gauss-Seidel relaxation
+     * technique. Room for much improvement here...
+     * 
+     * @param b
+     * @param x
+     * @param x0
+     * @param a
+     * @param c
+     **/
+
+    protected void linearSolver(int b, float[] x, float[] x0, float a, float c) {
+        c = 1f / c;
+        for (int k = 0; k < numIterations; k++) {
+            for (int i = 1, idx = 1 + totalWidth, j = 1; j <= height;) {
+                x[idx] = (a
+                        * (x[idx - 1] + x[idx + 1] + x[idx - totalWidth] + x[idx
+                                + totalWidth]) + x0[idx])
+                        * c;
+                if (i < width) {
+                    i++;
+                    idx++;
+                } else {
+                    i = 1;
+                    j++;
+                    idx = j * totalWidth + 1;
+                }
+            }
+            setBoundary(b, x);
+        }
+    }
+
+    /**
+     * Use project() to make the velocity a mass conserving, incompressible
+     * field. Achieved through a Hodge decomposition. First we calculate the
+     * divergence field of our velocity using the mean finite diffusionernce
+     * approach, and apply the linear solver to compute the Poisson equation and
+     * obtain a "height" field. Now we subtract the gradient of this field to
+     * obtain our mass conserving velocity field.
+     * 
+     * @param x
+     *            The array in which the x component of our final velocity field
+     *            is stored.
+     * @param y
+     *            The array in which the y component of our final velocity field
+     *            is stored.
+     * @param p
+     *            A temporary array we can use in the computation.
+     * @param div
+     *            Another temporary array we use to hold the velocity divergence
+     *            field.
+     * 
+     **/
+
+    protected void project(float[] x, float[] y, float[] p, float[] div) {
+        float fact = -0.5f / width;
+        for (int i = 1, idx = 1 + totalWidth, j = 1; j <= height;) {
+            div[idx] = (x[idx + 1] - x[idx - 1] + y[idx + totalWidth] - y[idx
+                    - totalWidth])
+                    * fact;
+            p[idx] = 0;
+            if (i < width) {
+                i++;
+                idx++;
+            } else {
+                i = 1;
+                j++;
+                idx += 3;
+            }
+        }
+
+        setBoundary(0, div);
+        setBoundary(0, p);
+
+        linearSolver(0, p, div, 1, 4);
+
+        fact = -0.5f * width;
+        for (int i = 1, idx = 1 + totalWidth, j = 1; j <= height;) {
+            x[idx] += fact * (p[idx + 1] - p[idx - 1]);
+            y[idx] += fact * (p[idx + totalWidth] - p[idx - totalWidth]);
+            if (i < width) {
+                i++;
+                idx++;
+            } else {
+                i = 1;
+                idx += 3;
+                j++;
+            }
+        }
+
+        setBoundary(1, x);
+        setBoundary(2, y);
+    }
+
+    /**
+     * Reset the datastructures. We use 1d arrays for speed.
+     **/
+    public final void reset() {
+        for (int i = 0; i < size; i++) {
+            u[i] = uOld[i] = v[i] = vOld[i] = 0.0f;
+            d[i] = dOld[i] = curl[i] = 0.0f;
+        }
+    }
+
+    /**
+     * specifies simple boundary conditions.
+     * 
+     * @param b
+     * @param x
+     */
+    protected void setBoundary(int b, float[] x) {
+        int idn = height * totalWidth;
+        for (int i = 1, idi = totalWidth; i <= width; i++) {
+            x[idi] = b == 1 ? -x[idi + 1] : x[idi + 1];
+            x[width + 1 + idi] = b == 1 ? -x[idi + width] : x[idi + width];
+            x[i] = b == 2 ? -x[totalWidth + i] : x[totalWidth + i];
+            x[i + idn + totalWidth] = b == 2 ? -x[idn + i] : x[idn + i];
+            idi += totalWidth;
+        }
+        x[0] = 0.5f * (x[1] + x[totalWidth]);
+        x[idn + totalWidth] = 0.5f * (x[1 + totalWidth + idn] + x[idn]);
+        x[width + 1] = 0.5f * (x[width] + x[width + 1 + totalWidth]);
+        x[width + 1 + totalWidth + idn] = 0.5f * (x[width + totalWidth + idn] + x[width
+                + 1 + idn]);
+    }
+
+    /**
+     * @param buoyancyA
+     *            the buoyancyA to set
+     */
+    public void setBuoyancyA(float buoyancyA) {
+        this.buoyancyA = buoyancyA;
+    }
+
+    /**
+     * @param buoyancyB
+     *            the buoyancyB to set
+     */
+    public void setBuoyancyB(float buoyancyB) {
+        this.buoyancyB = buoyancyB;
+    }
+
+    /**
+     * @param curl
+     *            the curl to set
+     */
+    public void setCurl(float[] curl) {
+        this.curl = curl;
+    }
+
+    /**
+     * @param diffusion
+     *            the diffusion to set
+     */
+    public void setDiffusion(float diffusion) {
+        this.diffusion = diffusion;
+    }
+
+    /**
+     * @param numIterations
+     *            the numIterations to set
+     */
+    public void setNumIterations(int numIterations) {
+        this.numIterations = numIterations;
+    }
+
+    /**
+     * @param timeStep
+     *            the timeStep to set
+     */
+    public void setTimeStep(float timeStep) {
+        this.timeStep = timeStep;
+    }
+
+    /**
+     * @param viscosity
+     *            the viscosity to set
+     */
+    public void setViscosity(float viscosity) {
+        this.viscosity = viscosity;
+    }
+
+    /**
+     * The basic velocity solving routine as described by Stam.
+     **/
+
+    public void velocitySolver() {
+
+        // add velocity that was input by mouse
+        addSource(u, uOld);
+        addSource(v, vOld);
+
+        // add in vorticity confinement force
+        vorticityConfinement(uOld, vOld);
+        addSource(u, uOld);
+        addSource(v, vOld);
+
+        // add in buoyancy force
+        buoyancy(vOld);
+        addSource(v, vOld);
+
+        float [] temp = u;
+        u = uOld;
+        uOld = temp;
+        diffusion(0, u, uOld, viscosity);
+        temp = v;
+        v = vOld;
+        vOld = temp;        
+        diffusion(0, v, vOld, viscosity);
+
+        // we create an incompressible field
+        // for more effective advection.
+        project(u, v, uOld, vOld);
+        temp = u;
+        u = uOld;
+        uOld = temp;
+        temp = v;
+        v = vOld;
+        vOld = temp; 
+
+        // self advect velocities
+        advect(1, u, uOld, uOld, vOld);
+        advect(2, v, vOld, uOld, vOld);
+
+        // make an incompressible field
+        project(u, v, uOld, vOld);
+
+        // clear all input velocities for next frame
+        for (int i = 0; i < size; i++) {
+            uOld[i] = vOld[i] = 0;
+        }
+    }
+
+    /**
+     * Calculate the vorticity confinement force for each cell in the fluid
+     * grid. At a point (i,j), Fvc = N x width where width is the curl at (i,j)
+     * and N = del |width| / |del |width||. N is the vector pointing to the
+     * vortex center, hence we add force perpendicular to N.
+     * 
+     * @param Fvc_x
+     *            The array to store the x component of the vorticity
+     *            confinement force for each cell.
+     * @param Fvc_y
+     *            The array to store the y component of the vorticity
+     *            confinement force for each cell.
+     **/
+
+    public void vorticityConfinement(float[] Fvc_x, float[] Fvc_y) {
+        float dw_dx, dw_dy;
+        float length;
+        float vort;
+
+        // Calculate magnitude of curl(u,v) for each cell. (|width|)
+        for (int i = 1, j = 1, idx = i + totalWidth; j <= height;) {
+            float c = curl(idx);
+            curl[idx] = c > 0 ? c : -c;
+            if (i < width) {
+                i++;
+                idx++;
+            } else {
+                i = 1;
+                j++;
+                idx += 3; // j*totalWidth+1;
+            }
+        }
+
+        for (int i = 2, j = 2, idx = i + totalWidth * j; j < height;) {
+            // Find derivative of the magnitude (n = del |width|)
+            dw_dx = (curl[idx + 1] - curl[idx - 1]) * 0.5f;
+            dw_dy = (curl[idx + totalWidth] - curl[idx - totalWidth]) * 0.5f;
+
+            // Calculate vector length. (|n|)
+            // Add small factor to prevent divide by zeros.
+            length = 1f / ((float) Math.sqrt(dw_dx * dw_dx + dw_dy * dw_dy) + 0.000001f);
+
+            // N = ( n/|n| )
+            dw_dx *= length;
+            dw_dy *= length;
+
+            vort = curl[idx];
+
+            // N x width
+            Fvc_x[idx] = dw_dy * -vort;
+            Fvc_y[idx] = dw_dx * vort;
+
+            if (i < width - 1) {
+                i++;
+                idx++;
+            } else {
+                i = 2;
+                j++;
+                idx += 5; // j*totalWidth+2;
+            }
+        }
+    }
+}