Initial import of heatmap code

Gradient.java

@@ -0,0 +1,167 @@
+import java.awt.Color;
+
+/**
+ *
+ * <p>There are a number of defined gradient types (look at the static fields),
+ * but you can create any gradient you like by using either of the following functions:
+ * <ul>
+ *   <li>public static Color[] createMultiGradient(Color[] colors, int numSteps)</li>
+ *   <li>public static Color[] createGradient(Color one, Color two, int numSteps)</li>
+ * </ul>
+ * You can then assign an arbitrary Color[] object to the HeatMap as follows:
+ * <pre>myHeatMap.updateGradient(Gradient.createMultiGradient(new Color[] {Color.red, Color.white, Color.blue}, 256));</pre>
+ * </p>
+ *
+ * <hr />
+ * <p><strong>Copyright:</strong> Copyright (c) 2007, 2008</p>
+ *
+ * <p>HeatMap is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.</p>
+ *
+ * <p>HeatMap 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 General Public License for more details.</p>
+ *
+ * <p>You should have received a copy of the GNU General Public License
+ * along with HeatMap; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA</p>
+ *
+ * @author Matthew Beckler (matthew@mbeckler.org)
+ * @author Josh Hayes-Sheen (grey@grevian.org), Converted to use BufferedImage.
+ * @author J. Keller (jpaulkeller@gmail.com), Added transparency (alpha) support, data ordering bug fix.
+ * @version 1.6
+ */
+
+public class Gradient
+{
+    /**
+     * Produces a gradient using the University of Minnesota's school colors, from maroon (low) to gold (high)
+     */
+    public final static Color[] GRADIENT_MAROON_TO_GOLD = createGradient(new Color(0xA0, 0x00, 0x00), new Color(0xFF, 0xFF, 0x00), 500);
+
+    /**
+     * Produces a gradient from blue (low) to red (high)
+     */
+    public final static Color[] GRADIENT_BLUE_TO_RED = createGradient(Color.BLUE, Color.RED, 500);
+
+    /**
+     * Produces a gradient from black (low) to white (high)
+     */
+    public final static Color[] GRADIENT_BLACK_TO_WHITE = createGradient(Color.BLACK, Color.WHITE, 500);
+
+    /**
+     *Produces a gradient from red (low) to green (high)
+     */
+    public final static Color[] GRADIENT_RED_TO_GREEN = createGradient(Color.RED, Color.GREEN, 500);
+
+    /**
+     *Produces a gradient through green, yellow, orange, red
+     */
+    public final static Color[] GRADIENT_GREEN_YELLOW_ORANGE_RED = createMultiGradient(new Color[]{Color.green, Color.yellow, Color.orange, Color.red}, 500);
+
+    /**
+     *Produces a gradient through the rainbow: violet, blue, green, yellow, orange, red
+     */
+    public final static Color[] GRADIENT_RAINBOW = createMultiGradient(new Color[]{new Color(181, 32, 255), Color.blue, Color.green, Color.yellow, Color.orange, Color.red}, 500);
+
+    /**
+     *Produces a gradient for hot things (black, red, orange, yellow, white)
+     */
+    public final static Color[] GRADIENT_HOT = createMultiGradient(new Color[]{Color.black, new Color(87, 0, 0), Color.red, Color.orange, Color.yellow, Color.white}, 500);
+
+    /**
+     *Produces a different gradient for hot things (black, brown, orange, white)
+     */
+    public final static Color[] GRADIENT_HEAT = createMultiGradient(new Color[]{Color.black, new Color(105, 0, 0), new Color(192, 23, 0), new Color(255, 150, 38), Color.white}, 500);
+
+    /**
+     *Produces a gradient through red, orange, yellow
+     */
+    public final static Color[] GRADIENT_ROY = createMultiGradient(new Color[]{Color.red, Color.orange, Color.yellow}, 500);
+
+    /**
+     * Creates an array of Color objects for use as a gradient, using a linear 
+     * interpolation between the two specified colors.
+     * @param one Color used for the bottom of the gradient
+     * @param two Color used for the top of the gradient
+     * @param numSteps The number of steps in the gradient. 250 is a good number.
+     */
+    public static Color[] createGradient(final Color one, final Color two, final int numSteps)
+    {
+        int r1 = one.getRed();
+        int g1 = one.getGreen();
+        int b1 = one.getBlue();
+        int a1 = one.getAlpha();
+
+        int r2 = two.getRed();
+        int g2 = two.getGreen();
+        int b2 = two.getBlue();
+        int a2 = two.getAlpha();
+
+        int newR = 0;
+        int newG = 0;
+        int newB = 0;
+        int newA = 0;
+
+        Color[] gradient = new Color[numSteps];
+        double iNorm;
+        for (int i = 0; i < numSteps; i++)
+        {
+            iNorm = i / (double)numSteps; //a normalized [0:1] variable
+            newR = (int) (r1 + iNorm * (r2 - r1));
+            newG = (int) (g1 + iNorm * (g2 - g1));
+            newB = (int) (b1 + iNorm * (b2 - b1));
+            newA = (int) (a1 + iNorm * (a2 - a1));
+            gradient[i] = new Color(newR, newG, newB, newA);
+        }
+
+        return gradient;
+    }
+
+    /**
+     * Creates an array of Color objects for use as a gradient, using an array of Color objects. It uses a linear interpolation between each pair of points. The parameter numSteps defines the total number of colors in the returned array, not the number of colors per segment.
+     * @param colors An array of Color objects used for the gradient. The Color at index 0 will be the lowest color.
+     * @param numSteps The number of steps in the gradient. 250 is a good number.
+     */
+    public static Color[] createMultiGradient(Color[] colors, int numSteps)
+    {
+        //we assume a linear gradient, with equal spacing between colors
+        //The final gradient will be made up of n 'sections', where n = colors.length - 1
+        int numSections = colors.length - 1;
+        int gradientIndex = 0; //points to the next open spot in the final gradient
+        Color[] gradient = new Color[numSteps];
+        Color[] temp;
+
+        if (numSections <= 0)
+        {
+            throw new IllegalArgumentException("You must pass in at least 2 colors in the array!");
+        }
+
+        for (int section = 0; section < numSections; section++)
+        {
+            //we divide the gradient into (n - 1) sections, and do a regular gradient for each
+            temp = createGradient(colors[section], colors[section+1], numSteps / numSections);
+            for (int i = 0; i < temp.length; i++)
+            {
+                //copy the sub-gradient into the overall gradient
+                gradient[gradientIndex++] = temp[i];
+            }
+        }
+
+        if (gradientIndex < numSteps)
+        {
+            //The rounding didn't work out in our favor, and there is at least
+            // one unfilled slot in the gradient[] array.
+            //We can just copy the final color there
+            for (/* nothing to initialize */; gradientIndex < numSteps; gradientIndex++)
+            {
+                gradient[gradientIndex] = colors[colors.length - 1];
+            }
+        }
+
+        return gradient;
+    }
+}