toxiclibs 0.4.0 → 0.8.0

data/src/toxi/color/TColorAdapter.java

@@ -0,0 +1,68 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.color;
+
+import javax.xml.bind.annotation.adapters.XmlAdapter;
+
+/**
+ *
+ * @author tux
+ */
+public class TColorAdapter extends XmlAdapter<String, TColor> {
+
+    /**
+     *
+     * @param col
+     * @return
+     * @throws Exception
+     */
+    @Override
+    public String marshal(TColor col) throws Exception {
+        if (col != null) {
+            return col.toHex();
+        } else {
+            return "";
+        }
+    }
+
+    /**
+     *
+     * @param hex
+     * @return
+     * @throws Exception
+     */
+    @Override
+    public TColor unmarshal(String hex) throws Exception {
+        int len = hex.length();
+        if (len > 0 && len <= 8) {
+            return TColor.newHex(hex);
+        } else {
+            return null;
+        }
+    }
+}

data/src/toxi/color/ToneMap.java

@@ -0,0 +1,218 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.color;
+
+import toxi.math.InterpolateStrategy;
+import toxi.math.ScaleMap;
+
+/**
+ *
+ * @author tux
+ */
+public class ToneMap {
+
+    /**
+     *
+     */
+    public ScaleMap map;
+
+    /**
+     *
+     */
+    public ColorList colors;
+
+    /**
+     *
+     * @param min
+     * @param max
+     * @param gradient
+     */
+    public ToneMap(float min, float max, ColorGradient gradient) {
+        this(min, max, gradient.calcGradient());
+    }
+
+    /**
+     *
+     * @param min
+     * @param max
+     * @param c
+     */
+    public ToneMap(float min, float max, ColorList c) {
+        map = new ScaleMap(min, max, 0, c.size() - 1);
+        colors = c;
+    }
+
+    /**
+     *
+     * @param a
+     * @param b
+     * @param colA
+     * @param colB
+     */
+    public ToneMap(float a, float b, ReadonlyTColor colA, ReadonlyTColor colB) {
+        this(a, b, new ColorList(colA, colB));
+    }
+
+    /**
+     *
+     * @param min
+     * @param max
+     * @param colA
+     * @param colB
+     * @param res
+     */
+    public ToneMap(float min, float max, ReadonlyTColor colA,
+            ReadonlyTColor colB, int res) {
+        ColorGradient g = new ColorGradient();
+        g.addColorAt(0, colA);
+        g.addColorAt(res - 1, colB);
+        colors = g.calcGradient(0, res);
+        map = new ScaleMap(min, max, 0, colors.size() - 1);
+    }
+
+    /**
+     *
+     * @param t
+     * @return
+     */
+    public final int getARGBToneFor(float t) {
+        return getToneFor(t).toARGB();
+    }
+
+    /**
+     *
+     * @param t
+     * @return
+     */
+    public final ReadonlyTColor getToneFor(float t) {
+        int idx;
+        if (colors.size() > 2) {
+            idx = (int) (map.getClippedValueFor(t) + 0.5);
+        } else {
+            idx = (t >= map.getInputMedian() ? 1 : 0);
+        }
+        return colors.get(idx);
+    }
+
+    /**
+     * Applies the tonemap to all elements in the given source array of single
+     * precision values and places the resulting ARGB color in the corresponding
+     * index of the target pixel buffer. If the target buffer is null, a new one
+     * will be created automatically.
+     * 
+     * @param src
+     *            source array of values to be tone mapped
+     * @param pixels
+     *            target pixel buffer
+     * @return pixel array
+     */
+    public int[] getToneMappedArray(float[] src, int[] pixels) {
+        if (pixels == null) {
+            pixels = new int[src.length];
+        } else if (src.length != pixels.length) {
+            throw new IllegalArgumentException(
+                    "pixel array need to be the same size as source array");
+        }
+        for (int i = 0; i < src.length; i++) {
+            pixels[i] = getToneFor(src[i]).toARGB();
+        }
+        return pixels;
+    }
+
+    /**
+     *
+     * @param src
+     * @param pixels
+     * @param offset
+     * @return
+     */
+    public int[] getToneMappedArray(float[] src, int[] pixels, int offset) {
+        if (offset < 0 || offset + src.length > pixels.length) {
+            throw new IllegalArgumentException(
+                    "offset into target pixel buffer is negative or too large");
+        }
+        for (int i = 0; i < src.length; i++) {
+            pixels[offset++] = getToneFor(src[i]).toARGB();
+        }
+        return pixels;
+    }
+
+    /**
+     * Applies the tonemap to all elements in the given source array of integers
+     * and places the resulting ARGB color in the corresponding index of the
+     * target pixel buffer. If the target buffer is null, a new one will be
+     * created automatically.
+     * 
+     * @param src
+     *            source array of values to be tone mapped
+     * @param pixels
+     *            target pixel buffer
+     * @return pixel array
+     */
+    public int[] getToneMappedArray(int[] src, int[] pixels) {
+        if (pixels == null) {
+            pixels = new int[src.length];
+        } else if (src.length != pixels.length) {
+            throw new IllegalArgumentException(
+                    "pixel array need to be the same size as source array");
+        }
+        for (int i = 0; i < src.length; i++) {
+            pixels[i] = getToneFor(src[i]).toARGB();
+        }
+        return pixels;
+    }
+
+    /**
+     *
+     * @param src
+     * @param pixels
+     * @param offset
+     * @return
+     */
+    public int[] getToneMappedArray(int[] src, int[] pixels, int offset) {
+        if (offset < 0 || offset + src.length > pixels.length) {
+            throw new IllegalArgumentException(
+                    "offset into target pixel buffer is negative or too large");
+        }
+        for (int i = 0; i < src.length; i++) {
+            pixels[offset++] = getToneFor(src[i]).toARGB();
+        }
+        return pixels;
+    }
+
+    /**
+     * Sets the interpolation function for the underlying {@link ScaleMap}
+     * instance of this {@link ToneMap}.
+     * 
+     * @param func
+     * @see ScaleMap#setMapFunction(InterpolateStrategy)
+     */
+    public void setMapFunction(InterpolateStrategy func) {
+        map.setMapFunction(func);
+    }
+}

data/src/toxi/color/theory/AnalogousStrategy.java

@@ -0,0 +1,140 @@
+/*
+ * Some classes in this package have been partly inspired by & bits ported from
+ * Python code written by Tom De Smedt & Frederik De Bleser for the "colors" library
+ * of Nodebox.net.
+ * 
+ * http://nodebox.net/code/index.php/Colors
+ *
+ * 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.color.theory;
+
+import toxi.color.ColorList;
+import toxi.color.ReadonlyTColor;
+import toxi.color.TColor;
+import toxi.geom.Vec2D;
+import toxi.math.MathUtils;
+
+/**
+ * Creates a new palette of 4 similar (slightly paler) colors in addition to the
+ * given start color. The hue variance and contrast can be adjusted.
+ */
+public class AnalogousStrategy implements ColorTheoryStrategy {
+
+    /**
+     *
+     */
+    public static final String NAME = "analogous";
+
+    /**
+     *
+     */
+    protected static final Vec2D[] tones = new Vec2D[] {
+            new Vec2D(1, 2.2f), new Vec2D(2, 1), new Vec2D(-1, -0.5f),
+            new Vec2D(-2, 1)
+    };
+
+    /**
+     *
+     */
+    protected float contrast = 0.25f;
+
+    /**
+     *
+     */
+    protected float theta = 10 * MathUtils.DEG2RAD;
+
+    /**
+     * Creates a new instance with default contrast (25%) and 10
+     */
+    public AnalogousStrategy() {
+    }
+
+    /**
+     * @param theta
+     *            variance angle in radians
+     * @param contrast
+     */
+    public AnalogousStrategy(float theta, float contrast) {
+        this.contrast = contrast;
+        this.theta = theta;
+    }
+
+    /**
+     * @param theta
+     *            variance angle in degrees
+     * @param contrast
+     */
+    public AnalogousStrategy(int theta, float contrast) {
+        this.contrast = contrast;
+        this.theta = MathUtils.radians(theta);
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * toxi.color.ColorTheoryStrategy#createListFromcolor(toxi.color.TColor)
+     */
+    @Override
+    public ColorList createListFromColor(ReadonlyTColor src) {
+        contrast = MathUtils.clipNormalized(contrast);
+        ColorList colors = new ColorList(src);
+        for (Vec2D currTone : tones) {
+            TColor c = src.getRotatedRYB(theta * currTone.x);
+            float t = 0.44f - currTone.y * 0.1f;
+            if (src.brightness() - contrast * currTone.y < t) {
+                c.setBrightness(t);
+            } else {
+                c.setBrightness(src.brightness() - contrast * currTone.y);
+            }
+            c.desaturate(0.05f);
+            colors.add(c);
+        }
+        return colors;
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see toxi.color.ColorTheoryStrategy#getName()
+     */
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see java.lang.Object#toString()
+     */
+
+    /**
+     *
+     * @return
+     */
+    
+    @Override
+    public String toString() {
+        return NAME + " contrast: " + contrast + " theta: "
+                + MathUtils.degrees(theta);
+    }
+}

data/src/toxi/color/theory/ColorTheoryRegistry.java

@@ -0,0 +1,139 @@
+/*
+ * Some classes in this package have been partly inspired by & bits ported from
+ * Python code written by Tom De Smedt & Frederik De Bleser for the "colors" library
+ * of Nodebox.net.
+ * 
+ * http://nodebox.net/code/index.php/Colors
+ *
+ * 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.color.theory;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+/**
+ * Registry & object factory for default {@link ColorTheoryStrategy}
+ * implementations as well as custom ones.
+ */
+public class ColorTheoryRegistry {
+
+    private static final HashMap<String, ColorTheoryStrategy> implementations = new HashMap<>();
+
+    /**
+     *
+     */
+    public static final ColorTheoryStrategy SINGLE_COMPLEMENT = new SingleComplementStrategy();
+
+    /**
+     *
+     */
+    public static final ColorTheoryStrategy COMPLEMENTARY = new ComplementaryStrategy();
+
+    /**
+     *
+     */
+    public static final ColorTheoryStrategy SPLIT_COMPLEMENTARY = new SplitComplementaryStrategy();
+
+    /**
+     *
+     */
+    public static final ColorTheoryStrategy LEFT_SPLIT_COMPLEMENTARY = new LeftSplitComplementaryStrategy();
+
+    /**
+     *
+     */
+    public static final ColorTheoryStrategy RIGHT_SPLIT_COMPLEMENTARY = new RightSplitComplementaryStrategy();
+
+    /**
+     *
+     */
+    public static final ColorTheoryStrategy ANALOGOUS = new AnalogousStrategy();
+
+    /**
+     *
+     */
+    public static final ColorTheoryStrategy MONOCHROME = new MonochromeTheoryStrategy();
+
+    /**
+     *
+     */
+    public static final ColorTheoryStrategy TRIAD = new TriadTheoryStrategy();
+
+    /**
+     *
+     */
+    public static final ColorTheoryStrategy TETRAD = new TetradTheoryStrategy();
+
+    /**
+     *
+     */
+    public static final ColorTheoryStrategy COMPOUND = new CompoundTheoryStrategy();
+
+    static {
+        Field[] fields = ColorTheoryRegistry.class.getDeclaredFields();
+            for (Field f : fields) {
+                if (f.getType() == ColorTheoryStrategy.class) {
+                    String id = f.getName();
+                    try {
+                        implementations.put(id, (ColorTheoryStrategy) f.get(null));
+                    } catch (IllegalArgumentException | IllegalAccessException ex) {
+                        Logger.getLogger(ColorTheoryRegistry.class.getName()).log(Level.SEVERE, null, ex);
+                    }
+                }
+            }
+    }
+
+    /**
+     *
+     * @return
+     */
+    public static ArrayList<String> getRegisteredNames() {
+        return new ArrayList<>(implementations.keySet());
+    }
+
+    /**
+     *
+     * @return
+     */
+    public static ArrayList<ColorTheoryStrategy> getRegisteredStrategies() {
+        return new ArrayList<>(implementations.values());
+    }
+
+    /**
+     *
+     * @param id
+     * @return
+     */
+    public static ColorTheoryStrategy getStrategyForName(String id) {
+        return implementations.get(id);
+    }
+
+    /**
+     *
+     * @param impl
+     */
+    public static void registerImplementation(ColorTheoryStrategy impl) {
+        implementations.put(impl.getName().toUpperCase(), impl);
+    }
+}