toxiclibs 0.2-java → 0.5.0-java

data/src/toxi/processing/Tracing.java

@@ -0,0 +1,25 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package toxi.processing;
+
+/**
+ *
+ * @author sid
+ */
+public enum Tracing {
+    /**
+     *
+     */
+    INIT,
+    /**
+     *
+     */
+    EXPORTING,
+    /**
+     *
+     */
+    EXPORTED
+    
+}

data/src/toxi/processing/XYZNormalMapper.java

@@ -0,0 +1,30 @@
+package toxi.processing;
+
+import toxi.color.ReadonlyTColor;
+import toxi.color.TColor;
+import toxi.geom.Matrix4x4;
+import toxi.geom.Vec3D;
+
+/**
+ *
+ * @author tux
+ */
+public class XYZNormalMapper implements NormalMapper {
+
+    /**
+     *
+     */
+    public static final Matrix4x4 normalMap = new Matrix4x4().translateSelf(
+            0.5, 0.5, 0.5).scaleSelf(0.4999);
+
+    /**
+     *
+     * @param normal
+     * @return
+     */
+    @Override
+    public ReadonlyTColor getRGBForNormal(Vec3D normal) {
+        normal = normalMap.applyTo(normal);
+        return TColor.newRGB(normal.x, normal.y, normal.z);
+    }
+}

data/src/toxi/sim/automata/CAMatrix.java

@@ -0,0 +1,297 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.automata;
+
+import toxi.math.MathUtils;
+
+/**
+ * A 1D/2D Cellular Automata simulation matrix with flexible support of automata
+ * rules. The class provides accessors to the backing matrix arrays and utility
+ * methods to manipulate them.
+ */
+public class CAMatrix implements EvolvableMatrix {
+
+    protected int width,
+
+    /**
+     *
+     */
+
+    /**
+     *
+     */
+    height;
+    protected int[] matrix,
+
+    /**
+     *
+     */
+
+    /**
+     *
+     */
+    swap;
+
+    /**
+     *
+     */
+    protected CARule rule;
+
+    /**
+     *
+     */
+    protected int generation;
+
+    /**
+     * Creates a new 1D instance of the given width. Technically this matrix is
+     * still 2D, only its height = 1.
+     * 
+     * @param width
+     */
+    public CAMatrix(int width) {
+        this(width, 1);
+    }
+
+    /**
+     * Creates a new 2D instance of the given width & height.
+     * 
+     * @param w
+     * @param h
+     */
+    public CAMatrix(int w, int h) {
+        width = w;
+        height = h;
+        matrix = new int[w * h];
+        swap = new int[w * h];
+    }
+
+    /**
+     *
+     * @param probability
+     * @return
+     */
+    public CAMatrix addNoise(float probability) {
+        return addNoise(probability, 0, rule != null ? rule.getStateCount() : 2);
+    }
+
+    /**
+     * Adds noise to the matrix. Cell states are modified with the given
+     * probability and within the given interval of possible target states.
+     * 
+     * @param probability
+     * @param minState
+     * @param maxState
+     * @return itself
+     */
+    public CAMatrix addNoise(float probability, int minState, int maxState) {
+        if (rule != null) {
+            minState = MathUtils.clip(minState, 0, rule.getStateCount());
+            maxState = MathUtils.clip(maxState, 0, rule.getStateCount());
+            for (int x = 0; x < width; x++) {
+                for (int y = 0; y < height; y++) {
+                    if (MathUtils.randomChance(probability)) {
+                        int idx = y * width + x;
+                        swap[idx] = matrix[idx] = MathUtils.random(minState,
+                                maxState);
+                    }
+                }
+            }
+            return this;
+        }
+        throw new IllegalStateException("CA rule not yet initialized");
+    }
+
+    /**
+     * Sets all matrix cells in a square around the given x,y coordinates to the
+     * requested state.
+     * 
+     * @param x
+     *            box center x
+     * @param y
+     *            box center y
+     * @param w
+     *            box width
+     * @param state
+     *            target state
+     * @return itself
+     */
+    public CAMatrix drawBoxAt(int x, int y, int w, int state) {
+        for (int i = y - w / 2; i < y + w / 2; i++) {
+            for (int j = x - w / 2; j < x + w / 2; j++) {
+                if (j >= 0 && j < width && i >= 0 && i < height) {
+                    int idx = j + i * width;
+                    swap[idx] = matrix[idx] = state;
+                }
+            }
+        }
+        return this;
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see toxi.sim.automata.EvolvableMatrix#getGeneration()
+     */
+    @Override
+    public final int getGeneration() {
+        return generation;
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see toxi.sim.automata.EvolvableMatrix#getHeight()
+     */
+    @Override
+    public final int getHeight() {
+        return height;
+    }
+
+    /**
+     * Computes the array index for the cell at x,y.
+     * 
+     * @param x
+     * @param y
+     * @return index
+     */
+    public final int getIndexFor(int x, int y) {
+        return x + y * width;
+    }
+
+    @Override
+    public final int[] getMatrix() {
+        return matrix;
+    }
+
+    /**
+     * @return the rule instance
+     */
+    public final MatrixEvolver getRule() {
+        return rule;
+    }
+
+    @Override
+    public final int[] getSwapBuffer() {
+        return swap;
+    }
+
+    @Override
+    public final int getWidth() {
+        return width;
+    }
+
+    /**
+     * Clears the matrix and resets the generation counter.
+     * 
+     * @return itself
+     */
+    public CAMatrix reset() {
+        for (int i = 0; i < matrix.length; i++) {
+            matrix[i] = 0;
+            swap[i] = 0;
+        }
+        generation = 0;
+        return this;
+    }
+
+    /**
+     * Uses the given ARGB pixel array as seed mask for the matrix. The image is
+     * placed centered and if bigger. Only the blue channel (lowest 8 bit of an
+     * int) is used to determine if a cell is set to be alive or dead.
+     * 
+     * @param pixels
+     * @param imgWidth
+     * @param imgHeight
+     * @return itself
+     */
+    public CAMatrix seedImage(int[] pixels, int imgWidth, int imgHeight) {
+        final int xo = MathUtils.clip((width - imgWidth) / 2, 0, width - 1);
+        final 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++) {
+            final int i = y * imgWidth;
+            final int yoIndex = (yo + y) * width;
+            for (int x = 0; x < imgWidth; x++) {
+                if (0 < (pixels[i + x] & 0xff)) {
+                    int idx = yoIndex + xo + x;
+                    matrix[idx] = 1;
+                }
+            }
+        }
+        return this;
+    }
+
+    /**
+     * Assigns the given rule as evaluator for this matrix.
+     * 
+     * @param r
+     *            rule implementation
+     * @return itself
+     */
+    public CAMatrix setRule(CARule r) {
+        rule = r;
+        return this;
+    }
+
+    /**
+     * Sets the cell state at x,y. If the coordinates are outside the matrix an
+     * {@link ArrayIndexOutOfBoundsException} is thrown.
+     * 
+     * @param x
+     * @param y
+     * @param state
+     * @return itself
+     */
+    public CAMatrix setStateAt(int x, int y, int state) {
+        int idx = x + y * width;
+        if (idx >= 0 && idx < matrix.length) {
+            swap[idx] = matrix[idx] = state;
+        } else {
+            throw new ArrayIndexOutOfBoundsException("given coordinates: " + x
+                    + ";" + y + " are out of bounds");
+        }
+        return this;
+    }
+
+    /**
+     * Evolves the matrix to the next generation by applying one iteration of
+     * the assigned {@link CARule} implementation. If no rule is assigned, the
+     * method does nothing.
+     * 
+     * @return itself
+     */
+    public CAMatrix update() {
+        if (rule != null) {
+            rule.evolve(this);
+            System.arraycopy(swap, 0, matrix, 0, matrix.length);
+            generation++;
+        }
+        return this;
+    }
+}

data/src/toxi/sim/automata/CARule.java

@@ -0,0 +1,76 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.automata;
+
+/**
+ * This interface defines the required API for a {@link CAMatrix} compatible
+ * cellular automata rule implementation.
+ */
+public interface CARule extends MatrixEvolver {
+
+    /**
+     *
+     * @return
+     */
+    public int getStateCount();
+
+    /**
+     *
+     * @return
+     */
+    public boolean isAutoExpire();
+
+    /**
+     *
+     * @return
+     */
+    public boolean isTiling();
+
+    /**
+     *
+     */
+    public void randomize();
+
+    /**
+     *
+     * @param isAutoExpire
+     */
+    public void setAutoExpire(boolean isAutoExpire);
+
+    /**
+     *
+     * @param num
+     */
+    public void setStateCount(int num);
+
+    /**
+     *
+     * @param state
+     */
+    public void setTiling(boolean state);
+}

data/src/toxi/sim/automata/CARule2D.java

@@ -0,0 +1,354 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.automata;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import toxi.math.MathUtils;
+import toxi.util.datatypes.ArrayUtil;
+
+/**
+ *
+ * @author tux
+ */
+public class CARule2D implements CARule {
+
+    /**
+     *
+     * @param kernel
+     * @return
+     */
+    public static final byte[] booleanToByteArray(boolean[] kernel) {
+        List<Byte> buf = new ArrayList<>(kernel.length);
+        for (byte i = 0; i < kernel.length; i++) {
+            if (kernel[i]) {
+                buf.add(i);
+            }
+        }
+        return byteListToArray(buf);
+    }
+
+    /**
+     *
+     * @param rules
+     * @return
+     */
+    public static final byte[] byteListToArray(List<Byte> rules) {
+        byte[] r = new byte[rules.size()];
+        for (int i = rules.size() - 1; i >= 0; i--) {
+            r[i] = rules.get(i);
+        }
+        return r;
+    }
+
+    /**
+     *
+     */
+    protected boolean[] survivalRules;
+
+    /**
+     *
+     */
+    protected boolean[] birthRules;
+
+    /**
+     *
+     */
+    protected int stateCount;
+
+    /**
+     *
+     */
+    protected float randomBirthChance = 0.15f;
+
+    /**
+     *
+     */
+    protected float randomSurvivalChance = 0.25f;
+
+    /**
+     *
+     */
+    protected boolean isTiling;
+
+    /**
+     *
+     */
+    protected boolean isAutoExpire;
+
+    /**
+     *
+     * @param brules
+     * @param srules
+     * @param st
+     * @param tiled
+     */
+    public CARule2D(byte[] brules, byte[] srules, int st, boolean tiled) {
+        birthRules = new boolean[9];
+        setBirthRules(brules);
+        survivalRules = new boolean[9];
+        setSurvivalRules(srules);
+        stateCount = MathUtils.max(1, st);
+        setTiling(tiled);
+    }
+
+    /**
+     *
+     * @param m
+     */
+    @Override
+    public void evolve(EvolvableMatrix m) {
+        int width = m.getWidth();
+        int height = m.getHeight();
+        int[] matrix = m.getMatrix();
+        int[] temp = m.getSwapBuffer();
+        int maxState = stateCount - 1;
+        int x1, x2, y1, y2;
+        if (isTiling) {
+            x1 = 0;
+            x2 = width;
+            y1 = 0;
+            y2 = height;
+        } else {
+            x1 = 1;
+            x2 = width - 1;
+            y1 = 1;
+            y2 = height - 1;
+        }
+        for (int y = y1; y < y2; y++) {
+            // determine up and down cell indices
+            int up = (y > 0 ? y - 1 : height - 1) * width;
+            int down = (y < height - 1 ? y + 1 : 0) * width;
+            int centre = y * width;
+            for (int x = x1; x < x2; x++) {
+                // determine left and right cell offsets
+                int left = x > 0 ? x - 1 : width - 1;
+                int right = x < width - 1 ? x + 1 : 0;
+                int currVal = matrix[centre + x];
+                int newVal = currVal;
+                int sum = 0;
+                if (matrix[up + left] > 0) {
+                    sum++; // top left
+                }
+                if (matrix[up + x] > 0) {
+                    sum++; // top
+                }
+                if (matrix[up + right] > 0) {
+                    sum++; // top right
+                }
+                if (matrix[centre + left] > 0) {
+                    sum++; // left
+                }
+                if (matrix[centre + right] > 0) {
+                    sum++; // right
+                }
+                if (matrix[down + left] > 0) {
+                    sum++; // bottom left
+                }
+                if (matrix[down + x] > 0) {
+                    sum++; // bottom
+                }
+                if (matrix[down + right] > 0) {
+                    sum++; // bottom right
+                }
+                if (currVal > 0) {
+                    // if alive, check survival...
+                    if (survivalRules[sum]) {
+                        if (isAutoExpire) {
+                            newVal = (newVal + 1) % stateCount;
+                        } else {
+                            newVal = MathUtils.min(newVal + 1, maxState);
+                        }
+                    } else {
+                        newVal = 0;
+                    }
+                } else {
+                    // else check birth rules...
+                    if (birthRules[sum]) {
+                        newVal = 1;
+                    }
+                }
+                temp[centre + x] = newVal;
+            }
+        }
+    }
+
+    /**
+     *
+     * @return
+     */
+    public byte[] getBirthRules() {
+        return booleanToByteArray(birthRules);
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public int getStateCount() {
+        return stateCount;
+    }
+
+    /**
+     *
+     * @return
+     */
+    public byte[] getSurvivalRules() {
+        return booleanToByteArray(survivalRules);
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public boolean isAutoExpire() {
+        return isAutoExpire;
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public boolean isTiling() {
+        return isTiling;
+    }
+
+    /**
+     *
+     * @param chance
+     * @return
+     */
+    protected byte[] randomArray(double chance) {
+        List<Byte> rules = new ArrayList<>();
+        for (byte i = 0; i < 9; i++) {
+            if (MathUtils.randomChance(chance)) {
+                rules.add(i);
+            }
+        }
+        if (rules.isEmpty()) {
+            rules.add((byte) MathUtils.random(9));
+        }
+        return byteListToArray(rules);
+    }
+
+    /**
+     *
+     */
+    @Override
+    public void randomize() {
+        setRuleArray(randomArray(randomBirthChance), birthRules);
+        setRuleArray(randomArray(randomSurvivalChance), survivalRules);
+    }
+
+    /**
+     *
+     * @param state
+     */
+    @Override
+    public void setAutoExpire(boolean state) {
+        this.isAutoExpire = state;
+    }
+
+    /**
+     *
+     * @param b
+     */
+    public final void setBirthRules(byte[] b) {
+        setRuleArray(b, birthRules);
+    }
+
+    /**
+     *
+     * @param birth
+     * @param survival
+     */
+    public void setRandomProbabilities(float birth, float survival) {
+        randomBirthChance = birth;
+        randomSurvivalChance = survival;
+    }
+
+    /**
+     *
+     * @param seed
+     * @param kernel
+     */
+    protected void setRuleArray(byte[] seed, boolean[] kernel) {
+        for (int i = 0; i < kernel.length; i++) {
+            kernel[i] = false;
+        }
+        for (int i = 0; i < seed.length; i++) {
+            byte id = seed[i];
+            if (id >= 0 && id < kernel.length) {
+                kernel[id] = true;
+            } else {
+                throw new ArrayIndexOutOfBoundsException("invalid rule index: "
+                        + id + " (needs to be less than 9 for a 3x3 kernel");
+            }
+        }
+    }
+
+    /**
+     *
+     * @param num
+     */
+    @Override
+    public void setStateCount(int num) {
+        stateCount = num;
+    }
+
+    /**
+     *
+     * @param s
+     */
+    public final void setSurvivalRules(byte[] s) {
+        setRuleArray(s, survivalRules);
+    }
+
+    /**
+     *
+     * @param state
+     */
+    @Override
+    public final void setTiling(boolean state) {
+        isTiling = state;
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public String toString() {
+        return "births: " + ArrayUtil.toString(getBirthRules()) + " survivals:"
+                + ArrayUtil.toString(getSurvivalRules());
+    }
+}