rubyvis 0.1.0 → 0.1.1

data/vendor/src/geo/LatLng.js

@@ -0,0 +1,23 @@
+/**
+ * Abstract; not implemented. There is no explicit constructor; this class
+ * merely serves to document the representation used by {@link pv.Geo.scale}.
+ *
+ * @class Represents a pair of geographic coordinates.
+ *
+ * @name pv.Geo.LatLng
+ * @see pv.Geo.scale
+ */
+
+/**
+ * The <i>latitude</i> coordinate in degrees; positive is North.
+ *
+ * @type number
+ * @name pv.Geo.LatLng.prototype.lat
+ */
+
+/**
+ * The <i>longitude</i> coordinate in degrees; positive is East.
+ *
+ * @type number
+ * @name pv.Geo.LatLng.prototype.lng
+ */

data/vendor/src/geo/Projection.js

@@ -0,0 +1,43 @@
+/**
+ * Abstract; not implemented. There is no explicit constructor; this class
+ * merely serves to document the representation used by {@link pv.Geo.scale}.
+ *
+ * @class Represents a geographic projection. This class provides the core
+ * implementation for {@link pv.Geo.scale}s, mapping between geographic
+ * coordinates (latitude and longitude) and normalized screen space in the range
+ * [-1,1]. The remaining mapping between normalized screen space and actual
+ * pixels is performed by <tt>pv.Geo.scale</tt>.
+ *
+ * <p>Many geographic projections have a point around which the projection is
+ * centered. Rather than have each implementation add support for a
+ * user-specified center point, the <tt>pv.Geo.scale</tt> translates the
+ * geographic coordinates relative to the center point for both the forward and
+ * inverse projection.
+ *
+ * <p>In general, this class should not be used directly, unless the desire is
+ * to implement a new geographic projection. Instead, use <tt>pv.Geo.scale</tt>.
+ * Implementations are not required to implement inverse projections, but are
+ * needed for some forms of interactivity. Also note that some inverse
+ * projections are ambiguous, such as the connecting points in Dymaxian maps.
+ *
+ * @name pv.Geo.Projection
+ * @see pv.Geo.scale
+ */
+
+/**
+ * The <i>forward</i> projection.
+ *
+ * @function
+ * @name pv.Geo.Projection.prototype.project
+ * @param {pv.Geo.LatLng} latlng the latitude and longitude to project.
+ * @returns {pv.Vector} the xy-coordinates of the given point.
+ */
+
+/**
+ * The <i>inverse</i> projection; optional.
+ *
+ * @function
+ * @name pv.Geo.Projection.prototype.invert
+ * @param {pv.Vector} xy the x- and y-coordinates to invert.
+ * @returns {pv.Geo.LatLng} the latitude and longitude of the given point.
+ */

data/vendor/src/geo/Projections.js

@@ -0,0 +1,117 @@
+/**
+ * The built-in projections.
+ *
+ * @see pv.Geo.Projection
+ * @namespace
+ */
+pv.Geo.projections = {
+
+  /** @see http://en.wikipedia.org/wiki/Mercator_projection */
+  mercator: {
+    project: function(latlng) {
+      return {
+          x: latlng.lng / 180,
+          y: latlng.lat > 85 ? 1 : latlng.lat < -85 ? -1
+              : Math.log(Math.tan(Math.PI / 4
+              + pv.radians(latlng.lat) / 2)) / Math.PI
+        };
+    },
+    invert: function(xy) {
+      return {
+          lng: xy.x * 180,
+          lat: pv.degrees(2 * Math.atan(Math.exp(xy.y * Math.PI)) - Math.PI / 2)
+        };
+    }
+  },
+
+  /** @see http://en.wikipedia.org/wiki/Gall-Peters_projection */
+  "gall-peters": {
+    project: function(latlng) {
+      return {
+          x: latlng.lng / 180,
+          y: Math.sin(pv.radians(latlng.lat))
+        };
+    },
+    invert: function(xy) {
+      return {
+          lng: xy.x * 180,
+          lat: pv.degrees(Math.asin(xy.y))
+        };
+    }
+  },
+
+  /** @see http://en.wikipedia.org/wiki/Sinusoidal_projection */
+  sinusoidal: {
+    project: function(latlng) {
+      return {
+          x: pv.radians(latlng.lng) * Math.cos(pv.radians(latlng.lat)) / Math.PI,
+          y: latlng.lat / 90
+        };
+    },
+    invert: function(xy) {
+      return {
+          lng: pv.degrees((xy.x * Math.PI) / Math.cos(xy.y * Math.PI / 2)),
+          lat: xy.y * 90
+        };
+    }
+  },
+
+  /** @see http://en.wikipedia.org/wiki/Aitoff_projection */
+  aitoff: {
+    project: function(latlng) {
+      var l = pv.radians(latlng.lng),
+          f = pv.radians(latlng.lat),
+          a = Math.acos(Math.cos(f) * Math.cos(l / 2));
+      return {
+          x: 2 * (a ? (Math.cos(f) * Math.sin(l / 2) * a / Math.sin(a)) : 0) / Math.PI,
+          y: 2 * (a ? (Math.sin(f) * a / Math.sin(a)) : 0) / Math.PI
+        };
+    },
+    invert: function(xy) {
+      var x = xy.x * Math.PI / 2,
+          y = xy.y * Math.PI / 2;
+      return {
+          lng: pv.degrees(x / Math.cos(y)),
+          lat: pv.degrees(y)
+        };
+    }
+  },
+
+  /** @see http://en.wikipedia.org/wiki/Hammer_projection */
+  hammer: {
+    project: function(latlng) {
+      var l = pv.radians(latlng.lng),
+          f = pv.radians(latlng.lat),
+          c = Math.sqrt(1 + Math.cos(f) * Math.cos(l / 2));
+      return {
+          x: 2 * Math.SQRT2 * Math.cos(f) * Math.sin(l / 2) / c / 3,
+          y: Math.SQRT2 * Math.sin(f) / c / 1.5
+        };
+    },
+    invert: function(xy) {
+      var x = xy.x * 3,
+          y = xy.y * 1.5,
+          z = Math.sqrt(1 - x * x / 16 - y * y / 4);
+      return {
+          lng: pv.degrees(2 * Math.atan2(z * x, 2 * (2 * z * z - 1))),
+          lat: pv.degrees(Math.asin(z * y))
+        };
+    }
+  },
+
+  /** The identity or "none" projection. */
+  identity: {
+    project: function(latlng) {
+      return {
+          x: latlng.lng / 180,
+          y: latlng.lat / 90
+        };
+    },
+    invert: function(xy) {
+      return {
+          lng: xy.x * 180,
+          lat: xy.y * 90
+        };
+    }
+  }
+};

data/vendor/src/lang/Array.js

@@ -0,0 +1,112 @@
+/**
+ * @class The built-in Array class.
+ * @name Array
+ */
+
+/**
+ * Creates a new array with the results of calling a provided function on every
+ * element in this array. Implemented in Javascript 1.6.
+ *
+ * @function
+ * @name Array.prototype.map
+ * @see <a
+ * href="https://developer.mozilla.org/En/Core_JavaScript_1.5_Reference/Objects/Array/Map">map</a>
+ * documentation.
+ * @param {function} f function that produces an element of the new Array from
+ * an element of the current one.
+ * @param [o] object to use as <tt>this</tt> when executing <tt>f</tt>.
+ */
+if (!Array.prototype.map) Array.prototype.map = function(f, o) {
+  var n = this.length;
+  var result = new Array(n);
+  for (var i = 0; i < n; i++) {
+    if (i in this) {
+      result[i] = f.call(o, this[i], i, this);
+    }
+  }
+  return result;
+};
+
+/**
+ * Creates a new array with all elements that pass the test implemented by the
+ * provided function. Implemented in Javascript 1.6.
+ *
+ * @function
+ * @name Array.prototype.filter
+ * @see <a
+ * href="https://developer.mozilla.org/En/Core_JavaScript_1.5_Reference/Objects/Array/filter">filter</a>
+ * documentation.
+ * @param {function} f function to test each element of the array.
+ * @param [o] object to use as <tt>this</tt> when executing <tt>f</tt>.
+ */
+if (!Array.prototype.filter) Array.prototype.filter = function(f, o) {
+  var n = this.length;
+  var result = new Array();
+  for (var i = 0; i < n; i++) {
+    if (i in this) {
+      var v = this[i];
+      if (f.call(o, v, i, this)) result.push(v);
+    }
+  }
+  return result;
+};
+
+/**
+ * Executes a provided function once per array element. Implemented in
+ * Javascript 1.6.
+ *
+ * @function
+ * @name Array.prototype.forEach
+ * @see <a
+ * href="https://developer.mozilla.org/En/Core_JavaScript_1.5_Reference/Objects/Array/ForEach">forEach</a>
+ * documentation.
+ * @param {function} f function to execute for each element.
+ * @param [o] object to use as <tt>this</tt> when executing <tt>f</tt>.
+ */
+if (!Array.prototype.forEach) Array.prototype.forEach = function(f, o) {
+  var n = this.length >>> 0;
+  for (var i = 0; i < n; i++) {
+    if (i in this) f.call(o, this[i], i, this);
+  }
+};
+
+/**
+ * Apply a function against an accumulator and each value of the array (from
+ * left-to-right) as to reduce it to a single value. Implemented in Javascript
+ * 1.8.
+ *
+ * @function
+ * @name Array.prototype.reduce
+ * @see <a
+ * href="https://developer.mozilla.org/En/Core_JavaScript_1.5_Reference/Objects/Array/Reduce">reduce</a>
+ * documentation.
+ * @param {function} f function to execute on each value in the array.
+ * @param [v] object to use as the first argument to the first call of
+ * <tt>t</tt>.
+ */
+if (!Array.prototype.reduce) Array.prototype.reduce = function(f, v) {
+  var len = this.length;
+  if (!len && (arguments.length == 1)) {
+    throw new Error("reduce: empty array, no initial value");
+  }
+
+  var i = 0;
+  if (arguments.length < 2) {
+    while (true) {
+      if (i in this) {
+        v = this[i++];
+        break;
+      }
+      if (++i >= len) {
+        throw new Error("reduce: no values, no initial value");
+      }
+    }
+  }
+
+  for (; i < len; i++) {
+    if (i in this) {
+      v = f(v, this[i], i, this);
+    }
+  }
+  return v;
+};

data/vendor/src/lang/init.js

@@ -0,0 +1,26 @@
+/*
+ * Parses the Protovis specifications on load, allowing the use of JavaScript
+ * 1.8 function expressions on browsers that only support JavaScript 1.6.
+ *
+ * @see pv.parse
+ */
+pv.listen(window, "load", function() {
+   /*
+    * Note: in Firefox any variables declared here are visible to the eval'd
+    * script below. Even worse, any global variables declared by the script
+    * could overwrite local variables here (such as the index, `i`)!  To protect
+    * against this, all variables are explicitly scoped on a pv.$ object.
+    */
+    pv.$ = {i:0, x:document.getElementsByTagName("script")};
+    for (; pv.$.i < pv.$.x.length; pv.$.i++) {
+      pv.$.s = pv.$.x[pv.$.i];
+      if (pv.$.s.type == "text/javascript+protovis") {
+        try {
+          window.eval(pv.parse(pv.$.s.text));
+        } catch (e) {
+          pv.error(e);
+        }
+      }
+    }
+    delete pv.$;
+  });

data/vendor/src/layout/Arc.js

@@ -0,0 +1,178 @@
+/**
+ * Constructs a new, empty arc layout. Layouts are not typically constructed
+ * directly; instead, they are added to an existing panel via
+ * {@link pv.Mark#add}.
+ *
+ * @class Implements a layout for arc diagrams. An arc diagram is a network
+ * visualization with a one-dimensional layout of nodes, using circular arcs to
+ * render links between nodes. For undirected networks, arcs are rendering on a
+ * single side; this makes arc diagrams useful as annotations to other
+ * two-dimensional network layouts, such as rollup, matrix or table layouts. For
+ * directed networks, links in opposite directions can be rendered on opposite
+ * sides using <tt>directed(true)</tt>.
+ *
+ * <p>Arc layouts are particularly sensitive to node ordering; for best results,
+ * order the nodes such that related nodes are close to each other. A poor
+ * (e.g., random) order may result in large arcs with crossovers that impede
+ * visual processing. A future improvement to this layout may include automatic
+ * reordering using, e.g., spectral graph layout or simulated annealing.
+ *
+ * <p>This visualization technique is related to that developed by
+ * M. Wattenberg, <a
+ * href="http://www.research.ibm.com/visual/papers/arc-diagrams.pdf">"Arc
+ * Diagrams: Visualizing Structure in Strings"</a> in <i>IEEE InfoVis</i>, 2002.
+ * However, this implementation is limited to simple node-link networks, as
+ * opposed to structures with hierarchical self-similarity (such as strings).
+ *
+ * <p>As with other network layouts, three mark prototypes are provided:<ul>
+ *
+ * <li><tt>node</tt> - for rendering nodes; typically a {@link pv.Dot}.
+ * <li><tt>link</tt> - for rendering links; typically a {@link pv.Line}.
+ * <li><tt>label</tt> - for rendering node labels; typically a {@link pv.Label}.
+ *
+ * </ul>For more details on how this layout is structured and can be customized,
+ * see {@link pv.Layout.Network}.
+ *
+ * @extends pv.Layout.Network
+ **/
+pv.Layout.Arc = function() {
+  pv.Layout.Network.call(this);
+  var interpolate, // cached interpolate
+      directed, // cached directed
+      reverse, // cached reverse
+      buildImplied = this.buildImplied;
+
+  /** @private Cache layout state to optimize properties. */
+  this.buildImplied = function(s) {
+    buildImplied.call(this, s);
+    directed = s.directed;
+    interpolate = s.orient == "radial" ? "linear" : "polar";
+    reverse = s.orient == "right" || s.orient == "top";
+  };
+
+  /* Override link properties to handle directedness and orientation. */
+  this.link
+      .data(function(p) {
+          var s = p.sourceNode, t = p.targetNode;
+          return reverse != (directed || (s.breadth < t.breadth)) ? [s, t] : [t, s];
+        })
+      .interpolate(function() { return interpolate; });
+};
+
+pv.Layout.Arc.prototype = pv.extend(pv.Layout.Network)
+    .property("orient", String)
+    .property("directed", Boolean);
+
+/**
+ * Default properties for arc layouts. By default, the orientation is "bottom".
+ *
+ * @type pv.Layout.Arc
+ */
+pv.Layout.Arc.prototype.defaults = new pv.Layout.Arc()
+    .extend(pv.Layout.Network.prototype.defaults)
+    .orient("bottom");
+
+/**
+ * Specifies an optional sort function. The sort function follows the same
+ * comparator contract required by {@link pv.Dom.Node#sort}. Specifying a sort
+ * function provides an alternative to sort the nodes as they are specified by
+ * the <tt>nodes</tt> property; the main advantage of doing this is that the
+ * comparator function can access implicit fields populated by the network
+ * layout, such as the <tt>linkDegree</tt>.
+ *
+ * <p>Note that arc diagrams are particularly sensitive to order. This is
+ * referred to as the seriation problem, and many different techniques exist to
+ * find good node orders that emphasize clusters, such as spectral layout and
+ * simulated annealing.
+ *
+ * @param {function} f comparator function for nodes.
+ * @returns {pv.Layout.Arc} this.
+ */
+pv.Layout.Arc.prototype.sort = function(f) {
+  this.$sort = f;
+  return this;
+};
+
+/** @private Populates the x, y and angle attributes on the nodes. */
+pv.Layout.Arc.prototype.buildImplied = function(s) {
+  if (pv.Layout.Network.prototype.buildImplied.call(this, s)) return;
+
+  var nodes = s.nodes,
+      orient = s.orient,
+      sort = this.$sort,
+      index = pv.range(nodes.length),
+      w = s.width,
+      h = s.height,
+      r = Math.min(w, h) / 2;
+
+  /* Sort the nodes. */
+  if (sort) index.sort(function(a, b) { return sort(nodes[a], nodes[b]); });
+
+  /** @private Returns the mid-angle, given the breadth. */
+  function midAngle(b) {
+    switch (orient) {
+      case "top": return -Math.PI / 2;
+      case "bottom": return Math.PI / 2;
+      case "left": return Math.PI;
+      case "right": return 0;
+      case "radial": return (b - .25) * 2 * Math.PI;
+    }
+  }
+
+  /** @private Returns the x-position, given the breadth. */
+  function x(b) {
+    switch (orient) {
+      case "top":
+      case "bottom": return b * w;
+      case "left": return 0;
+      case "right": return w;
+      case "radial": return w / 2 + r * Math.cos(midAngle(b));
+    }
+  }
+
+  /** @private Returns the y-position, given the breadth. */
+  function y(b) {
+    switch (orient) {
+      case "top": return 0;
+      case "bottom": return h;
+      case "left":
+      case "right": return b * h;
+      case "radial": return h / 2 + r * Math.sin(midAngle(b));
+    }
+  }
+
+  /* Populate the x, y and mid-angle attributes. */
+  for (var i = 0; i < nodes.length; i++) {
+    var n = nodes[index[i]], b = n.breadth = (i + .5) / nodes.length;
+    n.x = x(b);
+    n.y = y(b);
+    n.midAngle = midAngle(b);
+  }
+};
+
+/**
+ * The orientation. The default orientation is "left", which means that nodes
+ * will be positioned from left-to-right in the order they are specified in the
+ * <tt>nodes</tt> property. The following orientations are supported:<ul>
+ *
+ * <li>left - left-to-right.
+ * <li>right - right-to-left.
+ * <li>top - top-to-bottom.
+ * <li>bottom - bottom-to-top.
+ * <li>radial - radially, starting at 12 o'clock and proceeding clockwise.</ul>
+ *
+ * @type string
+ * @name pv.Layout.Arc.prototype.orient
+ */
+
+/**
+ * Whether this arc digram is directed (bidirectional); only applies to
+ * non-radial orientations. By default, arc digrams are undirected, such that
+ * all arcs appear on one side. If the arc digram is directed, then forward
+ * links are drawn on the conventional side (the same as as undirected
+ * links--right, left, bottom and top for left, right, top and bottom,
+ * respectively), while reverse links are drawn on the opposite side.
+ *
+ * @type boolean
+ * @name pv.Layout.Arc.prototype.directed
+ */