Rails Against The Machine

redirect posts using javascript

2009-01-21T06:40:00.001-08:00

Lets say need authentication on a form submit.
We want the post to go through as normal if the user is logged on. If the user is not logged on the authentication system should intercept the request and show the login form. If they successfully login they should be redirected to the origional request.

Naively you would suppose this would be easy. You simply store the origional request in the session (session[:stored_location] = request.env['REQUEST_URI']) then redirect to that location if the login action is successfull. The problem with this is you can't redirect to a non-GET request.

You can however do any request you like with javascript. So we steal the following function from

    postwith: function(to,p) {
       var myForm = document.createElement("form");
       myForm.method="post" ;
       myForm.action = to ;
       for (var k in p) {
           var myInput = document.createElement("input") ;
           myInput.setAttribute("name", k) ;
           myInput.setAttribute("value", p[k]);
           myForm.appendChild(myInput) ;
       }
       document.body.appendChild(myForm) ;
       myForm.submit() ;
       document.body.removeChild(myForm) ;
   }

http://mentaljetsam.wordpress.com/2008/06/02/using-javascript-to-post-data-between-pages/

which can be called by an rjs template in response to an ajax request by the login form.

<div id="login_div">
 <%= error_messages_for :user, :header_message => "Custom message one", :message => "Custom message two" %>
 <% remote_form_for :user, :url =>  session_path do |f| -%>
   <div>
     <p><label for="email">Email</label><br/>
     <%= f.text_field :email, :required => true  %></p>

     <p><label for="password">Password</label><br/>
     <%= f.password_field :password, :required => true  %></p>
     <%= submit_tag 'Submit' %>
   </div>

 <% end -%>
</div>

so if login fails we use rjs to replace the div

page.replace_html 'login_div',{:partial=>'login', :object=>@user}
page.visual_effect :highlight, "login_div", :duration=>2

if it succeeds we call the post function

page<<"Global.postwith('#{page_url}',#{params.to_json})"

Complex active record associations

2008-11-26T07:06:00.000-08:00

First up custom finders/counters

has_many :photos,:class_name => 'Picture',
:finder_sql => '
SELECT pictures.*,
FROM pictures
WHERE pictures.code = \'#{code}\'
ORDER BY pictures.order,
:counter_sql => 'SELECT COUNT(*)
FROM pictures
WHERE pictures.code = \'#{code}\'

Three things which might trip you up
(1) counter_sql may need to be specified if your select is complex since by default it replaces the select caluse of the finder_sql with a simple count.
(2)use single quotes
(3)#{code} are active record attributes corresponding to column names you cannot use method names here

Now adding methods to the association

in your class where you declare has_many :pictures

class User < ActiveRecord::Base

has_many :pictures do

def custom_function
foo
end

private
def foo
self << 'foo'
end
end
end

so now you can do something like

p=User.new
p.pictures.custom_function

Google maps directions without markers

2008-10-07T09:49:00.000-07:00

Ok, suppose you want to display a route on the map generated by google's route planning algorithm. But you don't want the way points to appear you just want to draw the polyline. Also you want to do some processing server side first. For example if you are just interested in getting the distance between two points rather than actual directions for use in some crazy as program you are writing.

In your controller do something like this.

require "json"
require 'net/http'
class MapController < ApplicationController

  def index
    def get_response v
      Net::HTTP.get_response(URI.parse(v))
    end
    data=get_response 'http://maps.google.com/maps/nav?q=from:%20berlin%20to:%20london&output=js&hl=es'
    @result = data.body
  end
  

  
end

btw: if you had do JSON.parse(data.body) you can extract parameters from the returned json object as a hash to use however you want.

In your view you do something like this.
1)Set the javascript variable 'route' equal to the @results instance variable.
2)Create a new polyline from the polyline subobject.

<head>
  <script type="text/javascript" src="http://www.google.com/jsapi?key=ABQIAAAABigEsKG95vfiiA8xoEc_lRTSLFpLV9kZAti9u7YqBb88417uPxSs1hcTAggwKX8F0qh_mSZL8Y-_Rw"></script>
  <%= javascript_tag "var route = #{@result}" %>
  <script type="text/javascript">
    google.load("maps", "2.x");
    
    // Call this function when the page has been loaded
    function initialize() {
      if (GBrowserIsCompatible()) {
        var myCopyright = new GCopyrightCollection("© ");
        myCopyright.addCopyright(new GCopyright('Demo', new GLatLngBounds(new GLatLng(-90,-180), new GLatLng(90,180)),0,'©2007 Google'));
        
        var map = new GMap2(document.getElementById("map"));
        map.addControl(new GSmallMapControl());
        map.setCenter(new GLatLng(51.53608560178475, -0.06591796875), 6);//
        
        var polyline = new GPolyline.fromEncoded(route.Directions.Polyline);
        map.addOverlay(polyline);
        
      }
    }
    google.setOnLoadCallback(initialize);
  </script>
</head>

<div id="map" style="width: 500px; height: 300px"></div>

You can be a bit more sophisticated if you like and play with the polygons attributes individualy

var thing_to_draw=route.Directions.Polyline
        var polyline = new GPolyline.fromEncoded({
          color: "#df2518",
          weight: 4,
          opacity: 0.8,
          points:  thing_to_draw.points,
          levels: thing_to_draw.levels,
          zoomFactor:thing_to_draw.zoomFactor,
          numLevels: thing_to_draw.numLevels
        });

Does anyone actually use the social graph?

2008-08-28T06:38:00.000-07:00

As the hype about social networks dies down. I'm left with a nagging question: Does anyone actually (other than advertisers) use the social graph?

What I mean by this is what additional value does the graph structure provide to end users over say an straight forward address book or user authorization list?.

Lets look at facebook.
1)Finding contacts.
I am likely to know my friends friends. Thus browsing/searching a 2 level social graph helps me find contacts more easily than say a straight search over all users.
2)News feed.
If I know Alice and Bob but not Joe then it makes sense for me to be able to see stories concerning Alice and Bob (Alice superpoked Bob) but not see stories concerning Alice and Joe.

But thats it!! That is the extent to which facebook has found a use for the social graph as far as end users are concerned. (hardly revolutionary)

Notice also that the whole graph is not used. Only two levels "my friends" and "my friends friends" are used. There is loads of funky maths you can do to extract information from graphs and it is clear that advertisers can derive utility from data mining the entire social graph but I have yet to see a single end user example which requires more than 2 levels of connectivity or where information of substantial value to end users is extracted from the graph. That is not to say that there are no uses just than no one has found one yet.

Google heatmaps again

2008-08-27T08:39:00.000-07:00

In this entry I'm going to show you how to easily create beautiful heatmaps for google maps using the technique of The definitive heat map and borrowing code from Johan Liesén The definitive heat map – with Java

So without further ado here is the sourcecode:

I'm using Bear Bibeault's Front Man™ as a lightweight server for my map tiles.

The command:

package commands;

import java.io.IOException;
import java.io.OutputStream;
import javax.imageio.ImageIO;
import javax.servlet.ServletException;
import model.DensityMap;
import org.bibeault.frontman.Command;
import org.bibeault.frontman.CommandContext;
public class GetTileCommand implements Command {

    public void execute(CommandContext context) throws ServletException, IOException {
        int xCoord=Integer.parseInt(context.getRequest().getParameter("x"));
        int yCoord=Integer.parseInt(context.getRequest().getParameter("y"));
        int zoom=Integer.parseInt(context.getRequest().getParameter("zoom"));
        
        context.getResponse().setContentType("image/png");
        OutputStream output = context.getResponse().getOutputStream();
        DensityMap h=DensityMap.getInstance();
        ImageIO.write(h.getTile(xCoord,yCoord,zoom), "png", output);
    }

}

Loading the data and plotting it

package model;
import DensityHeatMap.HeatmapImage;
import Jama.Matrix;
import java.awt.image.BufferedImage;
import database.FileHandling;
import java.awt.Point;
import services.sharedfunctions.Conversions;

public class DensityMap {

    private static DensityMap instance = null;
    private Matrix coordinates; //Training data points
    private Matrix values; //Training data values

    protected DensityMap() {
        Matrix[] test_data = FileHandling.readTrainingData("data.csv");
        coordinates = test_data[0];
        values = test_data[1];
    }

    public static DensityMap getInstance() {
        if (instance == null) {
            instance = new DensityMap();
        }
        return instance;
    }
    
    public BufferedImage getTile(int x_tile, int y_tile, int zoom) {
        HeatmapImage h=new HeatmapImage(255,255,zoom);
        for (int i = 0; i < coordinates.getColumnDimension(); i++) {
            double lng=coordinates.get(0,i);
            double lat=coordinates.get(1,i);
            int[] x=Conversions.lng_to_pixel(lng, zoom);
            int[] y=Conversions.lat_to_pixel(lat, zoom);
            
            //relative to coordinate frame of tile i.e. 0,0 is top left hand corner.
            int x_pixels=x[1]+(x[0]-x_tile)*255;
            int y_pixels=y[1]+(y[0]-y_tile)*255;

            //we need to plot points which are just off the tile for continuity.
            //idealy the cut off should depend on zoom level and basis function size
            if((Math.abs(x[0]-x_tile)<=1)&&(Math.abs(y[0]-y_tile)<=1))
            {
                //x_Pixel               
                Point p=new Point(x_pixels, y_pixels);
                //CAUTION
                //use for densities only dont try to use for interpolation of valued functions
                h.addDotImage(p, 0.25f);
            }
            
        }
        return h.getImage();
    }
}

LatLong mercator conversions

package services.sharedfunctions;

public class Conversions {

    static int width = 256;
    static int height = 256;
    private static double earthRadius = 6367500.0;

    public static double pixel_to_lat(int pixel, int tile, int zoom) {
        double percent_down = (pixel + (height * tile)) / (height * Math.pow(2, zoom));//work out what % of the way down we are

        double from_equator = 1f - 2f * percent_down;//but in standard mercator projection the equator is zero 

        double y_mercator = from_equator * Math.PI;//and units run from + PI to -PI       

        double latitude = 2 * Math.atan(Math.exp(y_mercator)) - Math.PI / 2;
        return 180 * latitude / Math.PI;//convert to degrees
    }

    //returns tile, pixels
    public static int[] lat_to_pixel(double lat, int zoom) {
        //convert from degrees to radians
        double latitude = lat * Math.PI / 180;
        //convert to percator units that run from + PI to -PI   
        double y_mercator = Math.log(Math.tan(latitude / 2 + Math.PI / 4));
        //Now to percent up or down from equator
        double percent_down = (1f - (y_mercator / Math.PI)) / 2;
        //pixels
        double pixels = percent_down * (height * Math.pow(2, zoom));
        int tile = (int) Math.floor(pixels / height);
        int pixel = (int) (pixels - tile * height);
        int[] tmp = {tile, pixel};
        return tmp;
    }

    public static double pixel_to_lng(int pixel, int tile, int zoom) {
        double circumference = width * Math.pow(2, zoom); //Number of tiles forming x axis

        double radius = circumference / (2 * Math.PI);
        double longitude = (pixel + width * tile) / radius;//in radians its just the ratio

        longitude = 180 * longitude / Math.PI;//convert to degrees

        return longitude - 180;//change center from date line to grenich

    }

    public static int[] lng_to_pixel(double lng, int zoom) {
        //convert from degrees to radians
        double longitude = Math.PI * (lng + 180) / 180;
        double circumference = width * Math.pow(2, zoom); //Number of tiles forming x axis
        double radius = circumference / (2 * Math.PI);
        double pixels = longitude * radius;
        int tile = (int) Math.floor(pixels / width);
        int pixel = (int) (pixels - tile * width);
        int[] tmp = {tile, pixel};
        return tmp;
    }

    public static double lat_lon_to_x_meters(double lat, double lon, double lon_origin) {
        return (Math.PI * earthRadius / 180.0) * (lon - lon_origin) * Math.cos(lat * (Math.PI / 180.0));
    }

    public static double lat_lon_to_y_meters(double lat, double lat_origin) {
        return (Math.PI * earthRadius / 180.0) * (lat - lat_origin);
    }
}

Generating the heat map
just taken from Johan Liesén and refactored except that we now scale the size of the dotImage with zoom level.


package DensityHeatMap;

import java.awt.*;
import java.awt.image.*;
import services.sharedfunctions.Conversions;


public class HeatmapImage {

    private BufferedImage dotImage;
    private BufferedImage monochromeImage;
    private BufferedImage heatmapImage;
    private BufferedImage colorImage;
    private LookupTable colorTable;
    private LookupOp colorOp;

    public HeatmapImage(int width, int height,int zoom) {
        //create the image used to represent the basis functions
        double delta_lng=Conversions.pixel_to_lng(1,0,zoom)-Conversions.pixel_to_lng(0,0,zoom);
        int size=(int) (0.01 / delta_lng);
        dotImage = createFadedCircleImage(size);
        
        //Create a 1 pixel by 64 reference image to define the colours
        //we could load this instead of generating it.
        colorImage = createEvenlyDistributedGradientImage(new Dimension(
                64, 1), Color.WHITE, Color.RED, Color.YELLOW, Color.GREEN.darker(), Color.CYAN, Color.BLUE, new Color(0, 0, 0x33));
        //create a colour lookup table from the reference image
        colorTable = createColorLookupTable(colorImage, .5f);
        colorOp = new LookupOp(colorTable, null);

        //Create a monochrome image to hold our density plot
        monochromeImage = createCompatibleTranslucentImage(width, height);

        Graphics g = monochromeImage.getGraphics();
        g.setColor(Color.WHITE);
        g.fillRect(0, 0, width, height);
    }

    public void addDotImage(Point p, float alpha) {
        int circleRadius = dotImage.getWidth() / 2;

        Graphics2D g = (Graphics2D) monochromeImage.getGraphics();

        g.setComposite(BlendComposite.Multiply.derive(alpha));
        g.drawImage(dotImage, null, p.x - circleRadius, p.y - circleRadius);
    }

    public BufferedImage getImage() {
        return heatmapImage = colorize(colorOp);
    }
    //--------------------------------------------------------------------------

    private BufferedImage colorize(LookupOp colorOp) {
        return colorOp.filter(monochromeImage, null);
    }

    private BufferedImage colorize(LookupTable colorTable) {
        return colorize(new LookupOp(colorTable, null));
    }

    private static BufferedImage createFadedCircleImage(int size) {
        BufferedImage im = createCompatibleTranslucentImage(size, size);
        float radius = size / 2f;

        RadialGradientPaint gradient = new RadialGradientPaint(
                radius, radius, radius, new float[]{0f, 1f}, new Color[]{
                    Color.BLACK, new Color(0xffffffff, true)
                });

        Graphics2D g = (Graphics2D) im.getGraphics();

        g.setPaint(gradient);
        g.fillRect(0, 0, size, size);

        g.dispose();

        return im;
    }

    private static BufferedImage createCompatibleTranslucentImage(int width,
            int height) {
        GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
        GraphicsDevice gd = ge.getDefaultScreenDevice();
        GraphicsConfiguration gc = gd.getDefaultConfiguration();

        return gc.createCompatibleImage(
                width, height, Transparency.TRANSLUCENT);
    }

    /**
     * Creates the color lookup table from an image
     * 
     * @param im
     * @return
     */
    public static LookupTable createColorLookupTable(BufferedImage im,
            float alpha) {
        int tableSize = 256;
        Raster imageRaster = im.getData();
        double sampleStep = 1D * im.getWidth() / tableSize; // Sample pixels
        // evenly
        byte[][] colorTable = new byte[4][tableSize];
        int[] pixel = new int[1]; // Sample pixel
        Color c;

        for (int i = 0; i < tableSize; ++i) {
            imageRaster.getDataElements((int) (i * sampleStep), 0, pixel);

            c = new Color(pixel[0]);

            colorTable[0][i] = (byte) c.getRed();
            colorTable[1][i] = (byte) c.getGreen();
            colorTable[2][i] = (byte) c.getBlue();
            colorTable[3][i] = (byte) (alpha * 0xff);
        }

        LookupTable lookupTable = new ByteLookupTable(0, colorTable);

        return lookupTable;
    }

    public static BufferedImage createEvenlyDistributedGradientImage(
            Dimension size, Color... colors) {
        BufferedImage im = createCompatibleTranslucentImage(
                size.width, size.height);
        Graphics2D g = im.createGraphics();

        float[] fractions = new float[colors.length];
        float step = 1f / colors.length;

        for (int i = 0; i < colors.length; ++i) {
            fractions[i] = i * step;
        }

        LinearGradientPaint gradient = new LinearGradientPaint(
                0, 0, size.width, 1, fractions, colors,
                MultipleGradientPaint.CycleMethod.REPEAT);

        g.setPaint(gradient);
        g.fillRect(0, 0, size.width, size.height);

        g.dispose();

        return im;
    }
}

BlendComposite by Romain Guy

package DensityHeatMap;



import java.awt.Composite;
import java.awt.CompositeContext;
import java.awt.RenderingHints;
import java.awt.image.ColorModel;
import java.awt.image.DataBuffer;
import java.awt.image.Raster;
import java.awt.image.WritableRaster;

public final class BlendComposite implements Composite {
    public enum BlendingMode {
        NORMAL,
        AVERAGE,
        MULTIPLY,
        SCREEN,
        DARKEN,
        LIGHTEN,
        OVERLAY,
        HARD_LIGHT,
        SOFT_LIGHT,
        DIFFERENCE,
        NEGATION,
        EXCLUSION,
        COLOR_DODGE,
        INVERSE_COLOR_DODGE,
        SOFT_DODGE,
        COLOR_BURN,
        INVERSE_COLOR_BURN,
        SOFT_BURN,
        REFLECT,
        GLOW,
        FREEZE,
        HEAT,
        ADD,
        SUBTRACT,
        STAMP,
        RED,
        GREEN,
        BLUE,
        HUE,
        SATURATION,
        COLOR,
        LUMINOSITY
    }

    public static final BlendComposite Normal = new BlendComposite(BlendingMode.NORMAL);
    public static final BlendComposite Average = new BlendComposite(BlendingMode.AVERAGE);
    public static final BlendComposite Multiply = new BlendComposite(BlendingMode.MULTIPLY);
    public static final BlendComposite Screen = new BlendComposite(BlendingMode.SCREEN);
    public static final BlendComposite Darken = new BlendComposite(BlendingMode.DARKEN);
    public static final BlendComposite Lighten = new BlendComposite(BlendingMode.LIGHTEN);
    public static final BlendComposite Overlay = new BlendComposite(BlendingMode.OVERLAY);
    public static final BlendComposite HardLight = new BlendComposite(BlendingMode.HARD_LIGHT);
    public static final BlendComposite SoftLight = new BlendComposite(BlendingMode.SOFT_LIGHT);
    public static final BlendComposite Difference = new BlendComposite(BlendingMode.DIFFERENCE);
    public static final BlendComposite Negation = new BlendComposite(BlendingMode.NEGATION);
    public static final BlendComposite Exclusion = new BlendComposite(BlendingMode.EXCLUSION);
    public static final BlendComposite ColorDodge = new BlendComposite(BlendingMode.COLOR_DODGE);
    public static final BlendComposite InverseColorDodge = new BlendComposite(BlendingMode.INVERSE_COLOR_DODGE);
    public static final BlendComposite SoftDodge = new BlendComposite(BlendingMode.SOFT_DODGE);
    public static final BlendComposite ColorBurn = new BlendComposite(BlendingMode.COLOR_BURN);
    public static final BlendComposite InverseColorBurn = new BlendComposite(BlendingMode.INVERSE_COLOR_BURN);
    public static final BlendComposite SoftBurn = new BlendComposite(BlendingMode.SOFT_BURN);
    public static final BlendComposite Reflect = new BlendComposite(BlendingMode.REFLECT);
    public static final BlendComposite Glow = new BlendComposite(BlendingMode.GLOW);
    public static final BlendComposite Freeze = new BlendComposite(BlendingMode.FREEZE);
    public static final BlendComposite Heat = new BlendComposite(BlendingMode.HEAT);
    public static final BlendComposite Add = new BlendComposite(BlendingMode.ADD);
    public static final BlendComposite Subtract = new BlendComposite(BlendingMode.SUBTRACT);
    public static final BlendComposite Stamp = new BlendComposite(BlendingMode.STAMP);
    public static final BlendComposite Red = new BlendComposite(BlendingMode.RED);
    public static final BlendComposite Green = new BlendComposite(BlendingMode.GREEN);
    public static final BlendComposite Blue = new BlendComposite(BlendingMode.BLUE);
    public static final BlendComposite Hue = new BlendComposite(BlendingMode.HUE);
    public static final BlendComposite Saturation = new BlendComposite(BlendingMode.SATURATION);
    public static final BlendComposite Color = new BlendComposite(BlendingMode.COLOR);
    public static final BlendComposite Luminosity = new BlendComposite(BlendingMode.LUMINOSITY);

    private float alpha;
    private BlendingMode mode;

    private BlendComposite(BlendingMode mode) {
        this(mode, 1.0f);
    }

    private BlendComposite(BlendingMode mode, float alpha) {
        this.mode = mode;
        setAlpha(alpha);
    }

    public static BlendComposite getInstance(BlendingMode mode) {
        return new BlendComposite(mode);
    }

    public static BlendComposite getInstance(BlendingMode mode, float alpha) {
        return new BlendComposite(mode, alpha);
    }

    public BlendComposite derive(BlendingMode mode) {
        return this.mode == mode ? this : new BlendComposite(mode, getAlpha());
    }

    public BlendComposite derive(float alpha) {
        return this.alpha == alpha ? this : new BlendComposite(getMode(), alpha);
    }

    public float getAlpha() {
        return alpha;
    }

    public BlendingMode getMode() {
        return mode;
    }

    private void setAlpha(float alpha) {
        if (alpha < 0.0f || alpha > 1.0f) {
            throw new IllegalArgumentException(
                    "alpha must be comprised between 0.0f and 1.0f");
        }

        this.alpha = alpha;
    }

    @Override
    public int hashCode() {
        return Float.floatToIntBits(alpha) * 31 + mode.ordinal();
    }

    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof BlendComposite)) {
            return false;
        }

        BlendComposite bc = (BlendComposite) obj;

        if (mode != bc.mode) {
            return false;
        }

        return alpha == bc.alpha;
    }

    public CompositeContext createContext(ColorModel srcColorModel,
                                          ColorModel dstColorModel,
                                          RenderingHints hints) {
        return new BlendingContext(this);
    }

    private static final class BlendingContext implements CompositeContext {
        private final Blender blender;
        private final BlendComposite composite;

        private BlendingContext(BlendComposite composite) {
            this.composite = composite;
            this.blender = Blender.getBlenderFor(composite);
        }

        public void dispose() {
        }

        public void compose(Raster src, Raster dstIn, WritableRaster dstOut) {
            if (src.getSampleModel().getDataType() != DataBuffer.TYPE_INT ||
                dstIn.getSampleModel().getDataType() != DataBuffer.TYPE_INT ||
                dstOut.getSampleModel().getDataType() != DataBuffer.TYPE_INT) {
                throw new IllegalStateException(
                        "Source and destination must store pixels as INT.");
            }

            int width = Math.min(src.getWidth(), dstIn.getWidth());
            int height = Math.min(src.getHeight(), dstIn.getHeight());

            float alpha = composite.getAlpha();

            int[] srcPixel = new int[4];
            int[] dstPixel = new int[4];
            int[] srcPixels = new int[width];
            int[] dstPixels = new int[width];

            for (int y = 0; y < height; y++) {
                src.getDataElements(0, y, width, 1, srcPixels);
                dstIn.getDataElements(0, y, width, 1, dstPixels);
                for (int x = 0; x < width; x++) {
                    // pixels are stored as INT_ARGB
                    // our arrays are [R, G, B, A]
                    int pixel = srcPixels[x];
                    srcPixel[0] = (pixel >> 16) & 0xFF;
                    srcPixel[1] = (pixel >>  8) & 0xFF;
                    srcPixel[2] = (pixel      ) & 0xFF;
                    srcPixel[3] = (pixel >> 24) & 0xFF;

                    pixel = dstPixels[x];
                    dstPixel[0] = (pixel >> 16) & 0xFF;
                    dstPixel[1] = (pixel >>  8) & 0xFF;
                    dstPixel[2] = (pixel      ) & 0xFF;
                    dstPixel[3] = (pixel >> 24) & 0xFF;

                    int[] result = blender.blend(srcPixel, dstPixel);

                    // mixes the result with the opacity
                    dstPixels[x] = ((int) (dstPixel[3] + (result[3] - dstPixel[3]) * alpha) & 0xFF) << 24 |
                                   ((int) (dstPixel[0] + (result[0] - dstPixel[0]) * alpha) & 0xFF) << 16 |
                                   ((int) (dstPixel[1] + (result[1] - dstPixel[1]) * alpha) & 0xFF) <<  8 |
                                    (int) (dstPixel[2] + (result[2] - dstPixel[2]) * alpha) & 0xFF;
                }
                dstOut.setDataElements(0, y, width, 1, dstPixels);
            }
        }
    }

    private static abstract class Blender {
        public abstract int[] blend(int[] src, int[] dst);

        private static void RGBtoHSL(int r, int g, int b, float[] hsl) {
            float var_R = (r / 255f);
            float var_G = (g / 255f);
            float var_B = (b / 255f);

            float var_Min;
            float var_Max;
            float del_Max;

            if (var_R > var_G) {
                var_Min = var_G;
                var_Max = var_R;
            } else {
                var_Min = var_R;
                var_Max = var_G;
            }
            if (var_B > var_Max) {
                var_Max = var_B;
            }
            if (var_B < var_Min) {
                var_Min = var_B;
            }

            del_Max = var_Max - var_Min;

            float H, S, L;
            L = (var_Max + var_Min) / 2f;

            if (del_Max - 0.01f <= 0.0f) {
                H = 0;
                S = 0;
            } else {
                if (L < 0.5f) {
                    S = del_Max / (var_Max + var_Min);
                } else {
                    S = del_Max / (2 - var_Max - var_Min);
                }

                float del_R = (((var_Max - var_R) / 6f) + (del_Max / 2f)) / del_Max;
                float del_G = (((var_Max - var_G) / 6f) + (del_Max / 2f)) / del_Max;
                float del_B = (((var_Max - var_B) / 6f) + (del_Max / 2f)) / del_Max;

                if (var_R == var_Max) {
                    H = del_B - del_G;
                } else if (var_G == var_Max) {
                    H = (1 / 3f) + del_R - del_B;
                } else {
                    H = (2 / 3f) + del_G - del_R;
                }
                if (H < 0) {
                    H += 1;
                }
                if (H > 1) {
                    H -= 1;
                }
            }

            hsl[0] = H;
            hsl[1] = S;
            hsl[2] = L;
        }

        private static void HSLtoRGB(float h, float s, float l, int[] rgb) {
            int R, G, B;

            if (s - 0.01f <= 0.0f) {
                R = (int) (l * 255.0f);
                G = (int) (l * 255.0f);
                B = (int) (l * 255.0f);
            } else {
                float var_1, var_2;
                if (l < 0.5f) {
                    var_2 = l * (1 + s);
                } else {
                    var_2 = (l + s) - (s * l);
                }
                var_1 = 2 * l - var_2;

                R = (int) (255.0f * hue2RGB(var_1, var_2, h + (1.0f / 3.0f)));
                G = (int) (255.0f * hue2RGB(var_1, var_2, h));
                B = (int) (255.0f * hue2RGB(var_1, var_2, h - (1.0f / 3.0f)));
            }

            rgb[0] = R;
            rgb[1] = G;
            rgb[2] = B;
        }

        private static float hue2RGB(float v1, float v2, float vH) {
            if (vH < 0.0f) {
                vH += 1.0f;
            }
            if (vH > 1.0f) {
                vH -= 1.0f;
            }
            if ((6.0f * vH) < 1.0f) {
                return (v1 + (v2 - v1) * 6.0f * vH);
            }
            if ((2.0f * vH) < 1.0f) {
                return (v2);
            }
            if ((3.0f * vH) < 2.0f) {
                return (v1 + (v2 - v1) * ((2.0f / 3.0f) - vH) * 6.0f);
            }
            return (v1);
        }

        public static Blender getBlenderFor(BlendComposite composite) {
            switch (composite.getMode()) {
                case NORMAL:
                    return new Blender() {
                        @Override
                        public int[] blend(int[] src, int[] dst) {
                            return src;
                        }
                    };
                case ADD:
                    return new Blender() {
                        @Override
                        public int[] blend(int[] src, int[] dst) {
                            return new int[] {
                                Math.min(255, src[0] + dst[0]),
                                Math.min(255, src[1] + dst[1]),
                                Math.min(255, src[2] + dst[2]),
                                Math.min(255, src[3] + dst[3])
                            };
                        }
                    };
                case AVERAGE:
                    return new Blender() {
                        @Override
                        public int[] blend(int[] src, int[] dst) {
                            return new int[] {
                                (src[0] + dst[0]) >> 1,
                                (src[1] + dst[1]) >> 1,
                                (src[2] + dst[2]) >> 1,
                                Math.min(255, src[3] + dst[3])
                            };
                        }
                    };
                case BLUE:
                    return new Blender() {
                        @Override
                        public int[] blend(int[] src, int[] dst) {
                            return new int[] {
                                dst[0],
                                src[1],
                                dst[2],
                                Math.min(255, src[3] + dst[3])
                            };
                        }
                    };
                case COLOR:
                    return new Blender() {
                        @Override
                        public int[] blend(int[] src, int[] dst) {
                            float[] srcHSL = new float[3];
                            RGBtoHSL(src[0], src[1], src[2], srcHSL);
                            float[] dstHSL = new float[3];
                            RGBtoHSL(dst[0], dst[1], dst[2], dstHSL);

                            int[] result = new int[4];
                            HSLtoRGB(srcHSL[0], srcHSL[1], dstHSL[2], result);
                            result[3] = Math.min(255, src[3] + dst[3]);

                            return result;
                        }
                    };
                case COLOR_BURN:
                    return new Blender() {
                        @Override
                        public int[] blend(int[] src, int[] dst) {
                            return new int[] {
                                src[0] == 0 ? 0 :
                                    Math.max(0, 255 - (((255 - dst[0]) << 8) / src[0])),
                                src[1] == 0 ? 0 :
                                    Math.max(0, 255 - (((255 - dst[1]) << 8) / src[1])),
                                src[2] == 0 ? 0 :
                                    Math.max(0, 255 - (((255 - dst[2]) << 8) / src[2])),
                                Math.min(255, src[3] + dst[3])
                            };
                        }
                    };
                case COLOR_DODGE:
                    return new Blender() {
                        @Override
                        public int[] blend(int[] src, int[] dst) {
                            return new int[] {
                                src[0] == 255 ? 255 :
                                    Math.min((dst[0] << 8) / (255 - src[0]), 255),
                                src[1] == 255 ? 255 :
                                    Math.min((dst[1] << 8) / (255 - src[1]), 255),
                                src[2] == 255 ? 255 :
                                    Math.min((dst[2] << 8) / (255 - src[2]), 255),
                                Math.min(255, src[3] + dst[3])
                            };
                        }
                    };
                case DARKEN:
                    return new Blender() {
                        @Override
                        public int[] blend(int[] src, int[] dst) {
                            return new int[] {
                                Math.min(src[0], dst[0]),
                                Math.min(src[1], dst[1]),
                                Math.min(src[2], dst[2]),
                                Math.min(255, src[3] + dst[3])
                            };
                        }
                    };
                case DIFFERENCE:
                    return new Blender() {
                        @Override
                        public int[] blend(int[] src, int[] dst) {
                            return new int[] {
                                Math.abs(dst[0] - src[0]),
                                Math.abs(dst[1] - src[1]),
                                Math.abs(dst[2] - src[2]),
                                Math.min(255, src[3] + dst[3])
                            };
                        }
                    };
                case EXCLUSION:
                    return new Blender() {
                        @Override
                        public int[] blend(int[] src, int[] dst) {
                            return new int[] {
                                dst[0] + src[0] - (dst[0] * src[0] >> 7),
                                dst[1] + src[1] - (dst[1] * src[1] >> 7),
                                dst[2] + src[2] - (dst[2] * src[2] >> 7),
                                Math.min(255, src[3] + dst[3])
                            };
                        }
                    };
                case FREEZE:
                    return new Blender() {
                        @Override
                        public int[] blend(int[] src, int[] dst) {
                            return new int[] {
                                src[0] == 0 ? 0 : Math.max(0, 255 - (255 - dst[0]) * (255 - dst[0]) / src[0]),
                                src[1] == 0 ? 0 : Math.max(0, 255 - (255 - dst[1]) * (255 - dst[1]) / src[1]),
                                src[2] == 0 ? 0 : Math.max(0, 255 - (255 - dst[2]) * (255 - dst[2]) / src[2]),
                                Math.min(255, src[3] + dst[3])
                            };
                        }
                    };
                case GLOW:
                    return new Blender() {
                        @Override
                        public int[] blend(int[] src, int[] dst) {
                            return new int[] {
                                dst[0] == 255 ? 255 : Math.min(255, src[0] * src[0] / (255 - dst[0])),
                                dst[1] == 255 ? 255 : Math.min(255, src[1] * src[1] / (255 - dst[1])),
                                dst[2] == 255 ? 255 : Math.min(255, src[2] * src[2] / (255 - dst[2])),
                                Math.min(255, src[3] + dst[3])
                            };
                        }
                    };
                case GREEN:
                    return new Blender() {
                        @Override
                        public int[] blend(int[] src, int[] dst) {
                            return new int[] {
                                dst[0],
                                dst[1],
                                src[2],
                                Math.min(255, src[3] + dst[3])
                            };
                        }
                    };
                case HARD_LIGHT:
                    return new Blender() {
                        @Override
                        public int[] blend(int[] src, int[] dst) {
                            return new int[] {
                                src[0] < 128 ? dst[0] * src[0] >> 7 :
                                    255 - ((255 - src[0]) * (255 - dst[0]) >> 7),
                                src[1] < 128 ? dst[1] * src[1] >> 7 :
                                    255 - ((255 - src[1]) * (255 - dst[1]) >> 7),
                                src[2] < 128 ? dst[2] * src[2] >> 7 :
                                    255 - ((255 - src[2]) * (255 - dst[2]) >> 7),
                                Math.min(255, src[3] + dst[3])
                            };
                        }
                    };
                case HEAT:
                    return new Blender() {
                        @Override
                        public int[] blend(int[] src, int[] dst) {
                            return new int[] {
                                dst[0] == 0 ? 0 : Math.max(0, 255 - (255 - src[0]) * (255 - src[0]) / dst[0]),
                                dst[1] == 0 ? 0 : Math.max(0, 255 - (255 - src[1]) * (255 - src[1]) / dst[1]),
                                dst[2] == 0 ? 0 : Math.max(0, 255 - (255 - src[2]) * (255 - src[2]) / dst[2]),
                                Math.min(255, src[3] + dst[3])
                            };
                        }
                    };
                case HUE:
                    return new Blender() {
                        @Override
                        public int[] blend(int[] src, int[] dst) {
                            float[] srcHSL = new float[3];
                            RGBtoHSL(src[0], src[1], src[2], srcHSL);
                            float[] dstHSL = new float[3];
                            RGBtoHSL(dst[0], dst[1], dst[2], dstHSL);

                            int[] result = new int[4];
                            HSLtoRGB(srcHSL[0], dstHSL[1], dstHSL[2], result);
                            result[3] = Math.min(255, src[3] + dst[3]);

                            return result;
                        }
                    };
                case INVERSE_COLOR_BURN:
                    return new Blender() {
                        @Override
                        public int[] blend(int[] src, int[] dst) {
                            return new int[] {
                                dst[0] == 0 ? 0 :
                                    Math.max(0, 255 - (((255 - src[0]) << 8) / dst[0])),
                                dst[1] == 0 ? 0 :
                                    Math.max(0, 255 - (((255 - src[1]) << 8) / dst[1])),
                                dst[2] == 0 ? 0 :
                                    Math.max(0, 255 - (((255 - src[2]) << 8) / dst[2])),
                                Math.min(255, src[3] + dst[3])
                            };
                        }
                    };
                case INVERSE_COLOR_DODGE:
                    return new Blender() {
                        @Override
                        public int[] blend(int[] src, int[] dst) {
                            return new int[] {
                                dst[0] == 255 ? 255 :
                                    Math.min((src[0] << 8) / (255 - dst[0]), 255),
                                dst[1] == 255 ? 255 :
                                    Math.min((src[1] << 8) / (255 - dst[1]), 255),
                                dst[2] == 255 ? 255 :
                                    Math.min((src[2] << 8) / (255 - dst[2]), 255),
                                Math.min(255, src[3] + dst[3])
                            };
                        }
                    };
                case LIGHTEN:
                    return new Blender() {
                        @Override
                        public int[] blend(int[] src, int[] dst) {
                            return new int[] {
                                Math.max(src[0], dst[0]),
                                Math.max(src[1], dst[1]),
                                Math.max(src[2], dst[2]),
                                Math.min(255, src[3] + dst[3])
                            };
                        }
                    };
                case LUMINOSITY:
                    return new Blender() {
                        @Override
                        public int[] blend(int[] src, int[] dst) {
                            float[] srcHSL = new float[3];
                            RGBtoHSL(src[0], src[1], src[2], srcHSL);
                            float[] dstHSL = new float[3];
                            RGBtoHSL(dst[0], dst[1], dst[2], dstHSL);

                            int[] result = new int[4];
                            HSLtoRGB(dstHSL[0], dstHSL[1], srcHSL[2], result);
                            result[3] = Math.min(255, src[3] + dst[3]);

                            return result;
                        }
                    };
                case MULTIPLY:
                    return new Blender() {
                        @Override
                        public int[] blend(int[] src, int[] dst) {
                            return new int[] {
                                (src[0] * dst[0]) >> 8,
                                (src[1] * dst[1]) >> 8,
                                (src[2] * dst[2]) >> 8,
                                Math.min(255, src[3] + dst[3])
                            };
                        }
                    };
                case NEGATION:
                    return new Blender() {
                        @Override
                        public int[] blend(int[] src, int[] dst) {
                            return new int[] {
                                255 - Math.abs(255 - dst[0] - src[0]),
                                255 - Math.abs(255 - dst[1] - src[1]),
                                255 - Math.abs(255 - dst[2] - src[2]),
                                Math.min(255, src[3] + dst[3])
                            };
                        }
                    };
                case OVERLAY:
                    return new Blender() {
                        @Override
                        public int[] blend(int[] src, int[] dst) {
                            return new int[] {
                                dst[0] < 128 ? dst[0] * src[0] >> 7 :
                                    255 - ((255 - dst[0]) * (255 - src[0]) >> 7),
                                dst[1] < 128 ? dst[1] * src[1] >> 7 :
                                    255 - ((255 - dst[1]) * (255 - src[1]) >> 7),
                                dst[2] < 128 ? dst[2] * src[2] >> 7 :
                                    255 - ((255 - dst[2]) * (255 - src[2]) >> 7),
                                Math.min(255, src[3] + dst[3])
                            };
                        }
                    };
                case RED:
                    return new Blender() {
                        @Override
                        public int[] blend(int[] src, int[] dst) {
                            return new int[] {
                                src[0],
                                dst[1],
                                dst[2],
                                Math.min(255, src[3] + dst[3])
                            };
                        }
                    };
                case REFLECT:
                    return new Blender() {
                        @Override
                        public int[] blend(int[] src, int[] dst) {
                            return new int[] {
                                src[0] == 255 ? 255 : Math.min(255, dst[0] * dst[0] / (255 - src[0])),
                                src[1] == 255 ? 255 : Math.min(255, dst[1] * dst[1] / (255 - src[1])),
                                src[2] == 255 ? 255 : Math.min(255, dst[2] * dst[2] / (255 - src[2])),
                                Math.min(255, src[3] + dst[3])
                            };
                        }
                    };
                case SATURATION:
                    return new Blender() {
                        @Override
                        public int[] blend(int[] src, int[] dst) {
                            float[] srcHSL = new float[3];
                            RGBtoHSL(src[0], src[1], src[2], srcHSL);
                            float[] dstHSL = new float[3];
                            RGBtoHSL(dst[0], dst[1], dst[2], dstHSL);

                            int[] result = new int[4];
                            HSLtoRGB(dstHSL[0], srcHSL[1], dstHSL[2], result);
                            result[3] = Math.min(255, src[3] + dst[3]);

                            return result;
                        }
                    };
                case SCREEN:
                    return new Blender() {
                        @Override
                        public int[] blend(int[] src, int[] dst) {
                            return new int[] {
                                255 - ((255 - src[0]) * (255 - dst[0]) >> 8),
                                255 - ((255 - src[1]) * (255 - dst[1]) >> 8),
                                255 - ((255 - src[2]) * (255 - dst[2]) >> 8),
                                Math.min(255, src[3] + dst[3])
                            };
                        }
                    };
                case SOFT_BURN:
                    return new Blender() {
                        @Override
                        public int[] blend(int[] src, int[] dst) {
                            return new int[] {
                                dst[0] + src[0] < 256 ?
                                        (dst[0] == 255 ? 255 :
                                        Math.min(255, (src[0] << 7) / (255 - dst[0]))) :
                                            Math.max(0, 255 - (((255 - dst[0]) << 7) / src[0])),
                                dst[1] + src[1] < 256 ?
                                        (dst[1] == 255 ? 255 :
                                        Math.min(255, (src[1] << 7) / (255 - dst[1]))) :
                                            Math.max(0, 255 - (((255 - dst[1]) << 7) / src[1])),
                                dst[2] + src[2] < 256 ?
                                        (dst[2] == 255 ? 255 :
                                        Math.min(255, (src[2] << 7) / (255 - dst[2]))) :
                                            Math.max(0, 255 - (((255 - dst[2]) << 7) / src[2])),
                                Math.min(255, src[3] + dst[3])
                            };
                        }
                    };
                case SOFT_DODGE:
                    return new Blender() {
                        @Override
                        public int[] blend(int[] src, int[] dst) {
                            return new int[] {
                                dst[0] + src[0] < 256 ?
                                    (src[0] == 255 ? 255 :
                                        Math.min(255, (dst[0] << 7) / (255 - src[0]))) :
                                            Math.max(0, 255 - (((255 - src[0]) << 7) / dst[0])),
                                dst[1] + src[1] < 256 ?
                                    (src[1] == 255 ? 255 :
                                        Math.min(255, (dst[1] << 7) / (255 - src[1]))) :
                                            Math.max(0, 255 - (((255 - src[1]) << 7) / dst[1])),
                                dst[2] + src[2] < 256 ?
                                    (src[2] == 255 ? 255 :
                                        Math.min(255, (dst[2] << 7) / (255 - src[2]))) :
                                            Math.max(0, 255 - (((255 - src[2]) << 7) / dst[2])),
                                Math.min(255, src[3] + dst[3])
                            };
                        }
                    };
                case SOFT_LIGHT:
                    break;
                case STAMP:
                    return new Blender() {
                        @Override
                        public int[] blend(int[] src, int[] dst) {
                            return new int[] {
                                Math.max(0, Math.min(255, dst[0] + 2 * src[0] - 256)),
                                Math.max(0, Math.min(255, dst[1] + 2 * src[1] - 256)),
                                Math.max(0, Math.min(255, dst[2] + 2 * src[2] - 256)),
                                Math.min(255, src[3] + dst[3])
                            };
                        }
                    };
                case SUBTRACT:
                    return new Blender() {
                        @Override
                        public int[] blend(int[] src, int[] dst) {
                            return new int[] {
                                Math.max(0, src[0] + dst[0] - 256),
                                Math.max(0, src[1] + dst[1] - 256),
                                Math.max(0, src[2] + dst[2] - 256),
                                Math.min(255, src[3] + dst[3])
                            };
                        }
                    };
            }
            throw new IllegalArgumentException("Blender not implement for " +
                                               composite.getMode().name());
        }
    }
}

But before I go I have a couple of words of caution about this technique:

1)Intensity values are 'added' they are not averaged or interpolated so this is NOT an alternative to krigging or gausian processes

Only use this technique to generate heat maps of densities!!
e.g. population,clicks,customers,suicides
Do not use this technique to generate heatmaps of values.
e.g. house prices, travel times

try putting a low value next to a high value to see what I mean!

2)There are no error bars or probability estimates.
Furthermore the higher the values of a datapoint or (equivelently the more datapoints) at a specific coordinate the more the blob spreads. This may wrongly imply that nearby areas have a higher density than they do. e.g. in a map of population density a sky scraper in the middle of a park would not appear as a bright white but small dot surrounded by blue but rather the park would appear red.

try putting loads of points in the same place to see what I mean.

publicize private methods for testing

2008-07-23T06:34:00.000-07:00

class Class
  def publicize_methods
    saved_private_instance_methods = self.private_instance_methods
    self.class_eval { public(*saved_private_instance_methods) }
    yield
    self.class_eval { private(*saved_private_instance_methods) }
  end
end

http://blog.jayfields.com/2007/11/ruby-testing-private-methods.html

Open flash chart v2

2008-07-07T03:58:00.000-07:00

ruby class for generating the json maybe roll this into a plug in at some point

[http://teethgrinder.co.uk/open-flash-chart/ Open Flash Chart 1.x] was great and there is an [http://code.google.com/p/rails-open-flash-chart-plugin/ existing rails plugin].
However [http://teethgrinder.co.uk/open-flash-chart-2/ Open Flash Chart 2.x] is better and uses json. so most of the existing rails plugin will not work and indeed most of the code is redundant.

This plugin provides (or will provide)
* Helper method for embedding open chart objects in views
* Object(s) representing the chart which can be serialised to json
* Higher level helper functions to assist people in easily producing good looking charts

*example 1: Simple line graph from array data*

In your view you insert the following

<%=javascript_include_tag('swfobject.js')%>
<%= flash_chart  "target_div",800,600, :controller => 'chart_controller', :action => 'chart_data' %>
<div id="target_div"></div>

The corresponding controller action would be

def chart_data
    chart=FlashChart::Chart.new 
    chart.add_title('Existential Boredom level')
    chart.line_graph(['1','2','3''4','5','6','7','8','9','10'],[1.5,1.69,1.88,2.06,2.21,2.34,nil,2.35,2.23,2.08])
    render :json=>chart.to_json
  end

*example 2: Line graph from monthly scatter data*

include FlashChart

def line_from_xy_scatter

#get your data from somewhere
points=PointList.new(:monthly,  data.map{|e| Point.new( e.date, e.value)})

#make some labels for the x axis
    start_date=3.years.ago
    end_date=Date.today
    labels=make_labels(:monthly,start_date,end_date)

#make the chart
    chart=Chart.new true
    chart.add_title "sunspot data", "{font-size: 12px; color:#736AFF;}"   
    chart.line_graph( labels,points)
    render :json=>chart.to_json
end

OpenFlash.rb

#This module defines libraries to produce the json consumed by open flash chart
module FlashChart
  
  #this is the main class which represents the overall chart 
  # and is serialised to json
  class Chart
    attr_accessor :elements, :title, :x_axis, :y_axis
    
    def initialize(defaults=false)
      if(defaults)
        @bg_colour = '#FFFFFF'
      end
    end
    
    def add_series series
      @elements=[] unless elements
      @elements<< series
      
    end
    
    def add_title(text, style='{color: #7E97A6; font-size: 20; text-align: center}')
      @title= {:text=>text}
      @title.merge! :style=>style
    end

    #first series added using this method defines the x and y axis scales
    def line_graph(x_labels,y_data)
      #accept only pointlists and arrays
      if y_data.is_a?(PointList)
        y_data=y_data.to_line_series(x_labels)
      elsif !y_data.is_a?(Array)
        return
      end
      @x_axis=XAxis.new(x_labels) unless @x_axis
      non_nil_values=y_data.select{|e|e!=nil}
      
      if @y_axis
        add_to_max(non_nil_values.min,non_nil_values.max)
      else
         @y_axis=YAxis.new(non_nil_values.min,non_nil_values.max) 
      end
      add_series LineSeries.new(y_data)
    end
    
    def to_json(options = {})
      json_string= super
      options.merge! :replace=>{:dot_size=>'dot-size',:grid_colour=>'grid-colour',:font_size=>'font-size', :tick_length=>'tick-length', :tick_height=>'tick-height'}
      options[:replace].each_pair {|key, value|  json_string.gsub!(/#{key.to_s}/, value.to_s) } 
      json_string
    end
    
    def add_to_max(min,max)
      if(min&&max)
        @y_axis.max=[@y_axis.max,max].max  
        @y_axis.min=[@y_axis.min,min].min 
      end
    end
    
  end
  
  #represents a x axis label
  class Labels
    attr_accessor :labels, :steps
    def initialize labels=nil
      if(labels)
        @labels=labels
        #Number of steps should be calculated so that there is a lable width's space between each label
        #thus it should depend on the number of labels, size of chart the font size and the width of each label
        max_labels=8
        @steps=(labels.length/max_labels).ceil if(labels.length>max_labels)
      end
    end
  end
  
  #Axis definitions
  class XAxis
    attr_accessor  :stroke, :tick_height, :colour, :grid_colour, :steps
    def initialize labels=nil
      @labels= Labels.new(labels)
      @steps=(@labels.steps/2).floor  if @labels.steps && @labels.steps>1
      @colour='#818D9D'
      @grid_colour='#F0F0F0' 
    end
    
    def labels
      @labels.labels
    end
    
    def labels= val
      @labels.labels= val
    end
    
  end
  

  class YAxis
    attr_accessor :stroke, :tick_length, :colour, :grid_colour, :offset,:min, :max, :steps
    def initialize(min,max)
      #defaults
      auto_set_range(min,max)
      @colour='#818D9D'
      @grid_colour='#F0F0F0' 
    end
    #modulo % is not the same as remainder for negative numbers
    def auto_set_range(min,max)
      #  work out the approximate tick size
      @steps=  reduce_significant_figures((max-min)/5,1)
      #max and min should be nearest step above and below max
      @max=max+(@steps-max.remainder(@steps))
      @min=min-min.remainder(@steps)
    end
    
    private
    #round to form xxy0000 where xx is of length equal to 
    #the number of significant figures and y is 0 or 5
    def reduce_significant_figures(num,sf)
      n=BigDecimal( num.to_s)
      scale=10**n.exponent
      mantisa=(n/scale).round(sf+1) # 2dp initialy but ..
      mantisa=(mantisa/0.5).round(sf)*0.5#round to nearest 0.5
      mantisa*scale
    end
  end
  #-----------------------------------------------------------------------------------------------------------------------------------------------
  #series and chart type definitions
  
  class LineSeries
    attr_accessor :type, :colour, :dot_size,:width,:values, :text, :font_size
    
    def initialize data
      @type= "line_dot"
      @colour='#EE0000'
      @width=  4
      @values= data
      @dot_size= 4
    end
    

  end
  
  class BarChart
    attr_accessor :type, :alpha, :colour,:width,:values, :text, :font_size
    def initialize values
      @type="bar"
      @values=values
    end

  end

  #-----------------------------------------------------------------------------------------------------------------------------------------------
  
  #holds x ,y scatter points and adds an x_label
  #which should correspond to the labels on the x axis allowing us
  #to look up the value at each point on the x axis 
  class Point
    attr_accessor :x, :y, :x_label 
    def initialize x,y
      @x=x
      @y=y
    end

    def make_label(frequency)
      @x_label=date_label(@x, frequency)
    end
    
    
    private
    
    def date_label x_value, frequency
      case frequency
        #      when 'day'
        #      when 'week'
      when :monthly
        return x_value.strftime("%m/%Y")
        #      when 'quarter'
        #      when 'year'
      end
    end
    
  end
  
  #data values container to allow transforming between between
  # x y scatter and line series  
  class PointList <Array
    
    def initialize frequency, points=[]
      @frequency=frequency
      points.each { |item|   add_point item}
    end
    
    def add_point point
      self << point
      self.last.make_label(@frequency)
    end
    

    def to_line_series labels 
      labels.collect{|label| at(label)} 
    end
    
    def at label
      value=self.select {|p|  p.x_label==label}
      return nil  if  value.blank?
      return value[0].y
    end
      
  end
  
  #ugly ugly ugly need to do better and make more general
  def make_labels(frequency,start_val,end_val)
    case frequency
    when :monthly
      delta_months=(end_val.month-start_val.month)+12* (end_val.year-start_val.year)
      labels=["#{"%02d" %start_val.month}/#{start_val.year}"]
      month=start_val.month
      year=start_val.year;
    
      delta_months.times do |i|
        if month <12
          month=month+1
        else
          month=1
          year=year+1
        end
        labels<<"#{"%02d" %month}/#{year}"
      end
      labels
    end
  end
  
  
end

the tests

require 'rubygems'
require 'test/unit'
gem 'activerecord', '>= 1.15.4.7794'
require 'active_record'

require File.dirname(__FILE__) + '/../lib/flash_chart'

class FlashChartTest < Test::Unit::TestCase
  include FlashChart
  
  #so we don't fail for stupid white space issues
  def  assert_json_equal a, b, message=''
    assert_equal ActiveSupport::JSON.decode(a),ActiveSupport::JSON.decode(b), message
  end
  
  def setup
    @c=Chart.new
  end
  
  
  # Begin Json y methods-------------------------------------------------------------------------------------------------------------------------
  # The most primative functionality of the library
  #The chart should be serialisable to the json defined in openflash chart
  # http://teethgrinder.co.uk/open-flash-chart-2/json-format.php but watch out the definitions are slightly wrong!  

  def test_should_json_title
    expected_json=%&{"title": {"text": "Many data lines", "style": "{font-size: 20px; color:#0000ff; font-family: Verdana; text-align: center;}"}}&
    text="Many data lines"
    style="{font-size: 20px; color:#0000ff; font-family: Verdana; text-align: center;}"
    @c.add_title(text,style)
    assert_json_equal expected_json, @c.to_json
  end
  
  def test_should_json_x_axis
    expected_json=%&{"x_axis": {"stroke": 1, "tick-height": 10, "colour": "#d000d0", "grid-colour": "#00ff00", "labels": { "labels": ["January","February"]}}}&
    x_axis=XAxis.new(["January","February"])
    x_axis.stroke=1
    x_axis.tick_height=10
    x_axis.colour="#d000d0"
    x_axis.grid_colour="#00ff00"

    @c.x_axis=x_axis
    assert_json_equal expected_json, @c.to_json
  end
  
  def test_should_json_y_axis
    expected_json=%&{"y_axis":{"stroke":      4,   "tick-length": 3,  "steps": 5,   "colour":      "#d000d0",    "grid-colour": "#00ff00",    "offset":      0,  "min":         0 ,   "max":         20  }}&
    y_axis=YAxis.new(0,20)
    y_axis.stroke=4
    y_axis.min=0
    y_axis.max=20
    y_axis.steps=5
    y_axis.tick_length=3
    y_axis.colour="#d000d0"
    y_axis.grid_colour="#00ff00"
    y_axis.offset=0

    @c.y_axis=y_axis
    assert_json_equal expected_json, @c.to_json
  end
  
  def test_should_json_line_series
    line_series=LineSeries.new  [1.5,1.69,1.88,2.06,2.21,2.34,nil,2.35,2.23,2.08]
    expected_json=%&
       {
        "elements":[
          {
            "type":      "line_dot",
            "colour":    "#736AFF",
            "text":      "Avg. wave height (cm)",
            "font-size": 10,
            "width":     2,
            "dot-size":  4,
            "values" :   [1.5,1.69,1.88,2.06,2.21,2.34,null,2.35,2.23,2.08]
          }
        ]
      }
    &
    line_series.type="line_dot"
    line_series.colour="#736AFF"
    line_series.text="Avg. wave height (cm)"
    line_series.font_size=10
    line_series.dot_size=4
    line_series.width=2

    @c. add_series line_series
    assert_json_equal expected_json, @c.to_json
  end
  
  def test_should_json_bar_chart
    bar=BarChart.new [9,6,7,9,5,7,6,9,7]
    expected_json=%&
      {
        "elements":[
          {
            "type":      "bar",
            "alpha":     0.5,
            "colour":    "#9933CC",
            "text":      "Page views",
            "font-size": 10,
            "values" :   [9,6,7,9,5,7,6,9,7]
           }
         ]
      }
    &
    bar.alpha=0.5
    bar.colour="#9933CC"
    bar.text= "Page views"
    bar.font_size= 10
    @c. add_series bar
    assert_json_equal expected_json, @c.to_json
    
  end
  
  #----------------end json methods------------------------------------------------------------------------------------------------------------------
  
  #---------------------------Methods to convert x y scatter data into line series and generate x labels-----------------------------
  def test_point
    b=Point.new(Date.parse('Thu, 01 Jun 2000'),3)
    b.make_label(:monthly)
    assert_equal '06/2000', b.x_label
  end
  
  def test_monthly_point_list
    p=PointList.new(:monthly,[Point.new(Date.parse('Thu, 01 Jun 2000'),1),Point.new(Date.parse('Thu, 01 Jun 2005'),3)])
    p.add_point Point.new(Date.parse('Thu, 01 Jun 2008'),9)
    assert_equal 3, p.at('06/2005')
    assert_equal nil, p.at('06/2004')
  end  

  def test_make_labels
    labels=make_labels(:monthly,Date.parse('Thu, 01 Jun 2000'),Date.parse('Fri, 22 Apr 2005'))
    assert_equal '06/2000',labels[0]
    assert_equal '07/2000',labels[1]
    assert_equal '08/2000',labels[2]
    assert_equal 59,labels.size 
    assert_equal '04/2005', labels[labels.size-1] 
  end
  
  def test_point_list_to_line_series
    labels=make_labels(:monthly,Date.parse('Thu, 01 Jun 2000'),Date.parse('Fri, 22 Apr 2005'))
    points=PointList.new(:monthly,[Point.new(Date.parse('Thu, 01 July 2000'),1.1),Point.new(Date.parse('Thu, 01 aug 2000'),1.3),Point.new(Date.parse('Thu, 01 july 2006'),1.4)])
    
    values=points.to_line_series(labels)
    assert_equal labels.size,values.size
    assert_equal nil, values[0] 
    assert_equal 1.1, values[1] 
    assert_equal 1.3, values[2]
    assert_equal nil, values[3] 
    #all the rest should be nil
  end
  
  #---------------------------Methods to auto scale the y axis-----------------------------
  def test_auto_set_range_large_integers
    #ok a bit more vague than usual we want reasonable values for x y and ticks
    #but its a bit of an open question what that means!
    1000.times do
      r=[rand(100000000)/1000.0,rand(100000000)/1000.0]
      max=r.max
      min=r.min
      y_axis=YAxis.new(min,max)
      assertions_for_y_axis y_axis, max,min
    end
  end
  
  def assertions_for_y_axis y_axis, max, min
    assert y_axis.max>y_axis.min,  "max(#{y_axis.max}) should be greater than min#{y_axis.min}"
    assert y_axis.max>=max, "y max should be greater than the maximum value"
    assert y_axis.min<=min, "y min should be less than the minimum value"
    distance=(y_axis.max-y_axis.min) 
    #god this is retarded! ruby seems to think 0.1*10^-9 >0.0001 ! 
    assert_stupid_ruby_doesnt_do_maths(y_axis.max,y_axis.steps)
    assert_stupid_ruby_doesnt_do_maths(y_axis.min,y_axis.steps)
    assert_stupid_ruby_doesnt_do_maths(distance,y_axis.steps)
    assert (distance/y_axis.steps)<=10,"too many steps on y axis should be less than 10 but was#{distance/y_axis.steps}"
  end
  
  #ooh floading point errors isn't it nice that with duck typing you don't know whether you are going to encounter these or not
  def assert_stupid_ruby_doesnt_do_maths(a,b)
    tmpA=BigDecimal.new(a.to_s)
    tmpB=BigDecimal.new(b.to_s)
    rem=tmpA.remainder(tmpB)
    assert rem==0, "ruby is stupid #{tmpA}%#{tmpB} apparently gives #{rem}"
  end

  
  #------------------------------------------------------------------------------------------------
  #higher level functions to easily build charts with defaults

  def test_line_graph
    vals=[1.5,1.69,1.88,2.06,2.21,2.34,nil,2.35,2.23,2.08]
    @c.line_graph(['1','2','3''4','5','6','7','8','9','10'],vals)
    expected= %&{"y_axis": {"steps": 0.15, "max": 2.4, "colour": "#818D9D", "min": 1.5, "grid-colour": "#F0F0F0"}, "elements": [{"type": "line_dot", "colour": "#EE0000", "dot-size": 4, "values": [1.5, 1.69, 1.88, 2.06, 2.21, 2.34, null, 2.35, 2.23, 2.08], "width": 4}], "x_axis": {"colour": "#818D9D", "grid-colour": "#F0F0F0", "labels": {"steps":1, "labels": ["1", "2", "34", "5", "6", "7", "8", "9", "10"]}}}&
    assert_json_equal expected, @c.to_json
  end
    
end

the helper

module OpenFlashChartHelper
  def flash_chart  div_name,width,height,options={}
    url= url_for options 
    flash_url= "#{request[:host_with_port]}/swf/open-flash-chart-2.swf"
    %&
  <script type="text/javascript">
    swfobject.embedSWF("#{flash_url}", "#{div_name}", "#{width}", "#{height}", "9.0.0", "expressInstall.swf", {"data-file":"#{url}"} );
  </script>
    &
  end
  
end

init

ActionView::Base.send :include, OpenFlashChartHelper

install

# Install hook code here
require 'fileutils'

def copy_asset(source, destination)
  unless File.exists?(destination)
  FileUtils.cp source, destination 
else
  puts destination +'exists keeping existing file'
end
end

#copy the resources to the public directory
swfobject_source= File.dirname(__FILE__) + '/public/javascripts/' + 'swfobject.js'
swfobject_destination= File.dirname(__FILE__) + '/../../../public/javascripts/' + 'swfobject.js'
copy_asset(swfobject_source, swfobject_destination)


open_flash_source = File.dirname(__FILE__) + '/public/swf/' + 'open-flash-chart-2.swf'
open_flash_destination = File.dirname(__FILE__) + '/../../../public/swf/' + 'open-flash-chart-2.swf'
copy_asset(open_flash_source, open_flash_destination )

Cleaner pixel level drawing with java

2008-06-19T10:03:00.001-07:00

Need to change alpha transparency independently of colour so changing from index color to direct.
More bitmask fun

package services;

import java.awt.Point;
import java.awt.image.BufferedImage;
import java.awt.image.DataBufferInt;
import java.awt.image.DirectColorModel;
import java.awt.image.SampleModel;
import java.awt.image.WritableRaster;

public class ImageFactory
{

    private static int width = 255;
    private static int height = 255;

    public static BufferedImage Image()
    {
        // This creates an RGBA colormodel... I think.
        DirectColorModel colormodel = new DirectColorModel(32, 0xff000000, 0xff0000, 0xff00, 0xff);
        int[] pixels = generatePixels(width, height);
        SampleModel sample = colormodel.createCompatibleSampleModel(width, height);
        DataBufferInt data = new DataBufferInt(pixels, width * height);
        WritableRaster raster = WritableRaster.createWritableRaster(sample, data, new Point(0, 0));
        return new BufferedImage(colormodel, raster, false, null);
    }

    private static int[] generatePixels(int w, int h)
    {
        int[] pixData = new int[width * height];
        int i = 0;
        for (int y = 0; y < height; y++) {
            int red = (y * 255) / (height - 1);
            for (int x = 0; x < width; x++) {
                int green = (x * 255) / (width - 1);
                int blue = 128;
                int alpha = Math.max(0,x-y);
                pixData[i++] = (alpha << 32) | (red << 24) |
                        (green << 16) | (blue << 8);
            }
        }
        return pixData;
    }
}