rubyvis 0.6.0 → 0.6.1

data/vendor/protovis/src/pv.js

@@ -1,95 +0,0 @@
-/**
- * The top-level Protovis namespace. All public methods and fields should be
- * registered on this object. Note that core Protovis source is surrounded by an
- * anonymous function, so any other declared globals will not be visible outside
- * of core methods. This also allows multiple versions of Protovis to coexist,
- * since each version will see their own <tt>pv</tt> namespace.
- *
- * @namespace The top-level Protovis namespace, <tt>pv</tt>.
- */
-var pv = {};
-
-/**
- * Protovis major and minor version numbers.
- *
- * @namespace Protovis major and minor version numbers.
- */
-pv.version = {
-  /**
-   * The major version number.
-   *
-   * @type number
-   * @constant
-   */
-  major: 3,
-
-  /**
-   * The minor version number.
-   *
-   * @type number
-   * @constant
-   */
-  minor: 3
-};
-
-/**
- * Returns the passed-in argument, <tt>x</tt>; the identity function. This method
- * is provided for convenience since it is used as the default behavior for a
- * number of property functions.
- *
- * @param x a value.
- * @returns the value <tt>x</tt>.
- */
-pv.identity = function(x) { return x; };
-
-/**
- * Returns <tt>this.index</tt>. This method is provided for convenience for use
- * with scales. For example, to color bars by their index, say:
- *
- * <pre>.fillStyle(pv.Colors.category10().by(pv.index))</pre>
- *
- * This method is equivalent to <tt>function() this.index</tt>, but more
- * succinct. Note that the <tt>index</tt> property is also supported for
- * accessor functions with {@link pv.max}, {@link pv.min} and other array
- * utility methods.
- *
- * @see pv.Scale
- * @see pv.Mark#index
- */
-pv.index = function() { return this.index; };
-
-/**
- * Returns <tt>this.childIndex</tt>. This method is provided for convenience for
- * use with scales. For example, to color bars by their child index, say:
- *
- * <pre>.fillStyle(pv.Colors.category10().by(pv.child))</pre>
- *
- * This method is equivalent to <tt>function() this.childIndex</tt>, but more
- * succinct.
- *
- * @see pv.Scale
- * @see pv.Mark#childIndex
- */
-pv.child = function() { return this.childIndex; };
-
-/**
- * Returns <tt>this.parent.index</tt>. This method is provided for convenience
- * for use with scales. This method is provided for convenience for use with
- * scales. For example, to color bars by their parent index, say:
- *
- * <pre>.fillStyle(pv.Colors.category10().by(pv.parent))</pre>
- *
- * Tthis method is equivalent to <tt>function() this.parent.index</tt>, but more
- * succinct.
- *
- * @see pv.Scale
- * @see pv.Mark#index
- */
-pv.parent = function() { return this.parent.index; };
-
-/**
- * Stores the current event. This field is only set within event handlers.
- *
- * @type Event
- * @name pv.event
- */

data/vendor/protovis/src/scene/SvgArea.js

@@ -1,172 +0,0 @@
-pv.SvgScene.area = function(scenes) {
-  var e = scenes.$g.firstChild;
-  if (!scenes.length) return e;
-  var s = scenes[0];
-
-  /* segmented */
-  if (s.segmented) return this.areaSegment(scenes);
-
-  /* visible */
-  if (!s.visible) return e;
-  var fill = s.fillStyle, stroke = s.strokeStyle;
-  if (!fill.opacity && !stroke.opacity) return e;
-
-  /** @private Computes the straight path for the range [i, j]. */
-  function path(i, j) {
-    var p1 = [], p2 = [];
-    for (var k = j; i <= k; i++, j--) {
-      var si = scenes[i],
-          sj = scenes[j],
-          pi = si.left + "," + si.top,
-          pj = (sj.left + sj.width) + "," + (sj.top + sj.height);
-
-      /* interpolate */
-      if (i < k) {
-        var sk = scenes[i + 1], sl = scenes[j - 1];
-        switch (s.interpolate) {
-          case "step-before": {
-            pi += "V" + sk.top;
-            pj += "H" + (sl.left + sl.width);
-            break;
-          }
-          case "step-after": {
-            pi += "H" + sk.left;
-            pj += "V" + (sl.top + sl.height);
-            break;
-          }
-        }
-      }
-
-      p1.push(pi);
-      p2.push(pj);
-    }
-    return p1.concat(p2).join("L");
-  }
-
-  /** @private Computes the curved path for the range [i, j]. */
-  function pathCurve(i, j) {
-    var pointsT = [], pointsB = [], pathT, pathB;
-
-    for (var k = j; i <= k; i++, j--) {
-      var sj = scenes[j];
-      pointsT.push(scenes[i]);
-      pointsB.push({left: sj.left + sj.width, top: sj.top + sj.height});
-    }
-
-    if (s.interpolate == "basis") {
-      pathT = pv.SvgScene.curveBasis(pointsT);
-      pathB = pv.SvgScene.curveBasis(pointsB);
-    } else if (s.interpolate == "cardinal") {
-      pathT = pv.SvgScene.curveCardinal(pointsT, s.tension);
-      pathB = pv.SvgScene.curveCardinal(pointsB, s.tension);
-    } else { // monotone
-      pathT = pv.SvgScene.curveMonotone(pointsT);
-      pathB = pv.SvgScene.curveMonotone(pointsB);
-    }
-
-    return pointsT[0].left + "," + pointsT[0].top + pathT
-         + "L" + pointsB[0].left + "," + pointsB[0].top + pathB;
-  }
-
-  /* points */
-  var d = [], si, sj;
-  for (var i = 0; i < scenes.length; i++) {
-    si = scenes[i]; if (!si.width && !si.height) continue;
-    for (var j = i + 1; j < scenes.length; j++) {
-      sj = scenes[j]; if (!sj.width && !sj.height) break;
-    }
-    if (i && (s.interpolate != "step-after")) i--;
-    if ((j < scenes.length) && (s.interpolate != "step-before")) j++;
-    d.push(((j - i > 2
-        && (s.interpolate == "basis"
-        || s.interpolate == "cardinal"
-        || s.interpolate == "monotone"))
-        ? pathCurve : path)(i, j - 1));
-    i = j - 1;
-  }
-  if (!d.length) return e;
-
-  e = this.expect(e, "path", {
-      "shape-rendering": s.antialias ? null : "crispEdges",
-      "pointer-events": s.events,
-      "cursor": s.cursor,
-      "d": "M" + d.join("ZM") + "Z",
-      "fill": fill.color,
-      "fill-opacity": fill.opacity || null,
-      "stroke": stroke.color,
-      "stroke-opacity": stroke.opacity || null,
-      "stroke-width": stroke.opacity ? s.lineWidth / this.scale : null
-    });
-  return this.append(e, scenes, 0);
-};
-
-pv.SvgScene.areaSegment = function(scenes) {
-  var e = scenes.$g.firstChild, s = scenes[0], pathsT, pathsB;
-  if (s.interpolate == "basis"
-      || s.interpolate == "cardinal"
-      || s.interpolate == "monotone") {
-    var pointsT = [], pointsB = [];
-
-    for (var i = 0, n = scenes.length; i < n; i++) {
-      var sj = scenes[n - i - 1];
-      pointsT.push(scenes[i]);
-      pointsB.push({left: sj.left + sj.width, top: sj.top + sj.height});
-    }
-
-    if (s.interpolate == "basis") {
-      pathsT = this.curveBasisSegments(pointsT);
-      pathsB = this.curveBasisSegments(pointsB);
-    } else if (s.interpolate == "cardinal") {
-      pathsT = this.curveCardinalSegments(pointsT, s.tension);
-      pathsB = this.curveCardinalSegments(pointsB, s.tension);
-    } else { // monotone
-      pathsT = this.curveMonotoneSegments(pointsT);
-      pathsB = this.curveMonotoneSegments(pointsB);
-    }
-  }
-
-  for (var i = 0, n = scenes.length - 1; i < n; i++) {
-    var s1 = scenes[i], s2 = scenes[i + 1];
-
-    /* visible */
-    if (!s1.visible || !s2.visible) continue;
-    var fill = s1.fillStyle, stroke = s1.strokeStyle;
-    if (!fill.opacity && !stroke.opacity) continue;
-
-    var d;
-    if (pathsT) {
-      var pathT = pathsT[i],
-          pathB = "L" + pathsB[n - i - 1].substr(1);
-
-      d = pathT + pathB + "Z";
-    } else {
-      /* interpolate */
-      var si = s1, sj = s2;
-      switch (s1.interpolate) {
-        case "step-before": si = s2; break;
-        case "step-after": sj = s1; break;
-      }
-
-      /* path */
-      d = "M" + s1.left + "," + si.top
-        + "L" + s2.left + "," + sj.top
-        + "L" + (s2.left + s2.width) + "," + (sj.top + sj.height)
-        + "L" + (s1.left + s1.width) + "," + (si.top + si.height)
-        + "Z";
-    }
-
-    e = this.expect(e, "path", {
-        "shape-rendering": s1.antialias ? null : "crispEdges",
-        "pointer-events": s1.events,
-        "cursor": s1.cursor,
-        "d": d,
-        "fill": fill.color,
-        "fill-opacity": fill.opacity || null,
-        "stroke": stroke.color,
-        "stroke-opacity": stroke.opacity || null,
-        "stroke-width": stroke.opacity ? s1.lineWidth / this.scale : null
-      });
-    e = this.append(e, scenes, i);
-  }
-  return e;
-};

data/vendor/protovis/src/scene/SvgBar.js

@@ -1,28 +0,0 @@
-pv.SvgScene.bar = function(scenes) {
-  var e = scenes.$g.firstChild;
-  for (var i = 0; i < scenes.length; i++) {
-    var s = scenes[i];
-
-    /* visible */
-    if (!s.visible) continue;
-    var fill = s.fillStyle, stroke = s.strokeStyle;
-    if (!fill.opacity && !stroke.opacity) continue;
-
-    e = this.expect(e, "rect", {
-        "shape-rendering": s.antialias ? null : "crispEdges",
-        "pointer-events": s.events,
-        "cursor": s.cursor,
-        "x": s.left,
-        "y": s.top,
-        "width": Math.max(1E-10, s.width),
-        "height": Math.max(1E-10, s.height),
-        "fill": fill.color,
-        "fill-opacity": fill.opacity || null,
-        "stroke": stroke.color,
-        "stroke-opacity": stroke.opacity || null,
-        "stroke-width": stroke.opacity ? s.lineWidth / this.scale : null
-      });
-    e = this.append(e, scenes, i);
-  }
-  return e;
-};

data/vendor/protovis/src/scene/SvgCurve.js

@@ -1,354 +0,0 @@
-/**
- * @private Converts the specified b-spline curve segment to a bezier curve
- * compatible with SVG "C".
- *
- * @param p0 the first control point.
- * @param p1 the second control point.
- * @param p2 the third control point.
- * @param p3 the fourth control point.
- */
-pv.SvgScene.pathBasis = (function() {
-
-  /**
-   * Matrix to transform basis (b-spline) control points to bezier control
-   * points. Derived from FvD 11.2.8.
-   */
-  var basis = [
-    [ 1/6, 2/3, 1/6,   0 ],
-    [   0, 2/3, 1/3,   0 ],
-    [   0, 1/3, 2/3,   0 ],
-    [   0, 1/6, 2/3, 1/6 ]
-  ];
-
-  /**
-   * Returns the point that is the weighted sum of the specified control points,
-   * using the specified weights. This method requires that there are four
-   * weights and four control points.
-   */
-  function weight(w, p0, p1, p2, p3) {
-    return {
-      x: w[0] * p0.left + w[1] * p1.left + w[2] * p2.left + w[3] * p3.left,
-      y: w[0] * p0.top  + w[1] * p1.top  + w[2] * p2.top  + w[3] * p3.top
-    };
-  }
-
-  var convert = function(p0, p1, p2, p3) {
-    var b1 = weight(basis[1], p0, p1, p2, p3),
-        b2 = weight(basis[2], p0, p1, p2, p3),
-        b3 = weight(basis[3], p0, p1, p2, p3);
-    return "C" + b1.x + "," + b1.y
-         + "," + b2.x + "," + b2.y
-         + "," + b3.x + "," + b3.y;
-  };
-
-  convert.segment = function(p0, p1, p2, p3) {
-    var b0 = weight(basis[0], p0, p1, p2, p3),
-        b1 = weight(basis[1], p0, p1, p2, p3),
-        b2 = weight(basis[2], p0, p1, p2, p3),
-        b3 = weight(basis[3], p0, p1, p2, p3);
-    return "M" + b0.x + "," + b0.y
-         + "C" + b1.x + "," + b1.y
-         + "," + b2.x + "," + b2.y
-         + "," + b3.x + "," + b3.y;
-  };
-
-  return convert;
-})();
-
-/**
- * @private Interpolates the given points using the basis spline interpolation.
- * Returns an SVG path without the leading M instruction to allow path
- * appending.
- *
- * @param points the array of points.
- */
-pv.SvgScene.curveBasis = function(points) {
-  if (points.length <= 2) return "";
-  var path = "",
-      p0 = points[0],
-      p1 = p0,
-      p2 = p0,
-      p3 = points[1];
-  path += this.pathBasis(p0, p1, p2, p3);
-  for (var i = 2; i < points.length; i++) {
-    p0 = p1;
-    p1 = p2;
-    p2 = p3;
-    p3 = points[i];
-    path += this.pathBasis(p0, p1, p2, p3);
-  }
-  /* Cycle through to get the last point. */
-  path += this.pathBasis(p1, p2, p3, p3);
-  path += this.pathBasis(p2, p3, p3, p3);
-  return path;
-};
-
-/**
- * @private Interpolates the given points using the basis spline interpolation.
- * If points.length == tangents.length then a regular Hermite interpolation is
- * performed, if points.length == tangents.length + 2 then the first and last
- * segments are filled in with cubic bazier segments.  Returns an array of path
- * strings.
- *
- * @param points the array of points.
- */
-pv.SvgScene.curveBasisSegments = function(points) {
-  if (points.length <= 2) return "";
-  var paths = [],
-      p0 = points[0],
-      p1 = p0,
-      p2 = p0,
-      p3 = points[1],
-      firstPath = this.pathBasis.segment(p0, p1, p2, p3);
-
-  p0 = p1;
-  p1 = p2;
-  p2 = p3;
-  p3 = points[2];
-  paths.push(firstPath + this.pathBasis(p0, p1, p2, p3)); // merge first & second path
-  for (var i = 3; i < points.length; i++) {
-    p0 = p1;
-    p1 = p2;
-    p2 = p3;
-    p3 = points[i];
-    paths.push(this.pathBasis.segment(p0, p1, p2, p3));
-  }
-
-  // merge last & second-to-last path
-  paths.push(this.pathBasis.segment(p1, p2, p3, p3) + this.pathBasis(p2, p3, p3, p3));
-  return paths;
-};
-
-/**
- * @private Interpolates the given points with respective tangents using the cubic
- * Hermite spline interpolation. If points.length == tangents.length then a regular
- * Hermite interpolation is performed, if points.length == tangents.length + 2 then
- * the first and last segments are filled in with cubic bazier segments.
- * Returns an SVG path without the leading M instruction to allow path appending.
- *
- * @param points the array of points.
- * @param tangents the array of tangent vectors.
- */
-pv.SvgScene.curveHermite = function(points, tangents) {
-  if (tangents.length < 1
-      || (points.length != tangents.length
-      && points.length != tangents.length + 2)) return "";
-  var quad = points.length != tangents.length,
-      path = "",
-      p0 = points[0],
-      p = points[1],
-      t0 = tangents[0],
-      t = t0,
-      pi = 1;
-
-  if (quad) {
-    path += "Q" + (p.left - t0.x * 2 / 3) + ","  + (p.top - t0.y * 2 / 3)
-        + "," + p.left + "," + p.top;
-    p0 = points[1];
-    pi = 2;
-  }
-
-  if (tangents.length > 1) {
-    t = tangents[1];
-    p = points[pi];
-    pi++;
-    path += "C" + (p0.left + t0.x) + "," + (p0.top + t0.y)
-        + "," + (p.left - t.x) + "," + (p.top - t.y)
-        + "," + p.left + "," + p.top;
-    for (var i = 2; i < tangents.length; i++, pi++) {
-      p = points[pi];
-      t = tangents[i];
-      path += "S" + (p.left - t.x) + "," + (p.top - t.y)
-          + "," + p.left + "," + p.top;
-    }
-  }
-
-  if (quad) {
-    var lp = points[pi];
-    path += "Q" + (p.left + t.x * 2 / 3) + ","  + (p.top + t.y * 2 / 3) + ","
-        + lp.left + "," + lp.top;
-  }
-
-  return path;
-};
-
-/**
- * @private Interpolates the given points with respective tangents using the
- * cubic Hermite spline interpolation. Returns an array of path strings.
- *
- * @param points the array of points.
- * @param tangents the array of tangent vectors.
- */
-pv.SvgScene.curveHermiteSegments = function(points, tangents) {
-  if (tangents.length < 1
-      || (points.length != tangents.length
-      && points.length != tangents.length + 2)) return [];
-  var quad = points.length != tangents.length,
-      paths = [],
-      p0 = points[0],
-      p = p0,
-      t0 = tangents[0],
-      t = t0,
-      pi = 1;
-
-  if (quad) {
-    p = points[1];
-    paths.push("M" + p0.left + "," + p0.top
-        + "Q" + (p.left - t.x * 2 / 3) + "," + (p.top - t.y * 2 / 3)
-        + "," + p.left + "," + p.top);
-    pi = 2;
-  }
-
-  for (var i = 1; i < tangents.length; i++, pi++) {
-    p0 = p;
-    t0 = t;
-    p = points[pi];
-    t = tangents[i];
-    paths.push("M" + p0.left + "," + p0.top
-        + "C" + (p0.left + t0.x) + "," + (p0.top + t0.y)
-        + "," + (p.left - t.x) + "," + (p.top - t.y)
-        + "," + p.left + "," + p.top);
-  }
-
-  if (quad) {
-    var lp = points[pi];
-    paths.push("M" + p.left + "," + p.top
-        + "Q" + (p.left + t.x * 2 / 3) + ","  + (p.top + t.y * 2 / 3) + ","
-        + lp.left + "," + lp.top);
-  }
-
-  return paths;
-};
-
-/**
- * @private Computes the tangents for the given points needed for cardinal
- * spline interpolation. Returns an array of tangent vectors. Note: that for n
- * points only the n-2 well defined tangents are returned.
- *
- * @param points the array of points.
- * @param tension the tension of hte cardinal spline.
- */
-pv.SvgScene.cardinalTangents = function(points, tension) {
-  var tangents = [],
-      a = (1 - tension) / 2,
-      p0 = points[0],
-      p1 = points[1],
-      p2 = points[2];
-
-  for (var i = 3; i < points.length; i++) {
-    tangents.push({x: a * (p2.left - p0.left), y: a * (p2.top - p0.top)});
-    p0 = p1;
-    p1 = p2;
-    p2 = points[i];
-  }
-
-  tangents.push({x: a * (p2.left - p0.left), y: a * (p2.top - p0.top)});
-  return tangents;
-};
-
-/**
- * @private Interpolates the given points using cardinal spline interpolation.
- * Returns an SVG path without the leading M instruction to allow path
- * appending.
- *
- * @param points the array of points.
- * @param tension the tension of hte cardinal spline.
- */
-pv.SvgScene.curveCardinal = function(points, tension) {
-  if (points.length <= 2) return "";
-  return this.curveHermite(points, this.cardinalTangents(points, tension));
-};
-
-/**
- * @private Interpolates the given points using cardinal spline interpolation.
- * Returns an array of path strings.
- *
- * @param points the array of points.
- * @param tension the tension of hte cardinal spline.
- */
-pv.SvgScene.curveCardinalSegments = function(points, tension) {
-  if (points.length <= 2) return "";
-  return this.curveHermiteSegments(points, this.cardinalTangents(points, tension));
-};
-
-/**
- * @private Interpolates the given points using Fritsch-Carlson Monotone cubic
- * Hermite interpolation. Returns an array of tangent vectors.
- *
- * @param points the array of points.
- */
-pv.SvgScene.monotoneTangents = function(points) {
-  var tangents = [],
-      d = [],
-      m = [],
-      dx = [],
-      k = 0;
-
-  /* Compute the slopes of the secant lines between successive points. */
-  for (k = 0; k < points.length-1; k++) {
-    d[k] = (points[k+1].top - points[k].top)/(points[k+1].left - points[k].left);
-  }
-
-  /* Initialize the tangents at every point as the average of the secants. */
-  m[0] = d[0];
-  dx[0] = points[1].left - points[0].left;
-  for (k = 1; k < points.length - 1; k++) {
-    m[k] = (d[k-1]+d[k])/2;
-    dx[k] = (points[k+1].left - points[k-1].left)/2;
-  }
-  m[k] = d[k-1];
-  dx[k] = (points[k].left - points[k-1].left);
-
-  /* Step 3. Very important, step 3. Yep. Wouldn't miss it. */
-  for (k = 0; k < points.length - 1; k++) {
-    if (d[k] == 0) {
-      m[ k ] = 0;
-      m[k+1] = 0;
-    }
-  }
-
-  /* Step 4 + 5. Out of 5 or more steps. */
-  for (k = 0; k < points.length - 1; k++) {
-    if ((Math.abs(m[k]) < 1e-5) || (Math.abs(m[k+1]) < 1e-5)) continue;
-    var ak = m[k] / d[k],
-        bk = m[k + 1] / d[k],
-        s = ak * ak + bk * bk; // monotone constant (?)
-    if (s > 9) {
-      var tk = 3 / Math.sqrt(s);
-      m[k] = tk * ak * d[k];
-      m[k + 1] = tk * bk * d[k];
-    }
-  }
-
-  var len;
-  for (var i = 0; i < points.length; i++) {
-    len = 1 + m[i] * m[i]; // pv.vector(1, m[i]).norm().times(dx[i]/3)
-    tangents.push({x: dx[i] / 3 / len, y: m[i] * dx[i] / 3 / len});
-  }
-
-  return tangents;
-};
-
-/**
- * @private Interpolates the given points using Fritsch-Carlson Monotone cubic
- * Hermite interpolation. Returns an SVG path without the leading M instruction
- * to allow path appending.
- *
- * @param points the array of points.
- */
-pv.SvgScene.curveMonotone = function(points) {
-  if (points.length <= 2) return "";
-  return this.curveHermite(points, this.monotoneTangents(points));
-}
-
-/**
- * @private Interpolates the given points using Fritsch-Carlson Monotone cubic
- * Hermite interpolation.
- * Returns an array of path strings.
- *
- * @param points the array of points.
- */
-pv.SvgScene.curveMonotoneSegments = function(points) {
-  if (points.length <= 2) return "";
-  return this.curveHermiteSegments(points, this.monotoneTangents(points));
-};