^ Item in dispute, additional discussion and context to be provided.
31 |The blue wedges measured from the centre of the circle represent area 91 | for area the deaths from Preventible or Mitigable Zymotic Diseases, the 92 | red wedges measured from the center the deaths from wounds, & the 93 | black wedges measured from the center the deaths from all other causes 94 |
In October 1844, & April 1855, the black area coincides with the 95 | red, in January & February 1856, the blue coincides with the black 96 |
The entire areas may be compared by following the blue, the red & 97 | the black lines enclosing them. 98 |
374 | 375 | 376 | 377 | 378 | 379 | 380 |
381 | 382 | 383 | 384 | 385 | 386 | 387 | 388 | 389 | 390 | 391 | 392 | 393 | 394 | 395 | 396 | 397 | 398 | 399 | 400 | 401 | 402 | 403 | 404 | 405 |1 /** 9 | 2 * Abstract; see an implementing class for details. 10 | 3 * 11 | 4 * @class Represents a reusable interaction; applies an interactive behavior to 12 | 5 * a given mark. Behaviors are themselves functions designed to be used as event 13 | 6 * handlers. For example, to add pan and zoom support to any panel, say: 14 | 7 * 15 | 8 * <pre> .event("mousedown", pv.Behavior.pan()) 16 | 9 * .event("mousewheel", pv.Behavior.zoom())</pre> 17 | 10 * 18 | 11 * The behavior should be registered on the event that triggers the start of the 19 | 12 * behavior. Typically, the behavior will take care of registering for any 20 | 13 * additional events that are necessary. For example, dragging starts on 21 | 14 * mousedown, while the drag behavior automatically listens for mousemove and 22 | 15 * mouseup events on the window. By listening to the window, the behavior can 23 | 16 * continue to receive mouse events even if the mouse briefly leaves the mark 24 | 17 * being dragged, or even the root panel. 25 | 18 * 26 | 19 * <p>Each behavior implementation has specific requirements as to which events 27 | 20 * it supports, and how it should be used. For example, the drag behavior 28 | 21 * requires that the data associated with the mark be an object with <tt>x</tt> 29 | 22 * and <tt>y</tt> attributes, such as a {@link pv.Vector}, storing the mark's 30 | 23 * position. See an implementing class for details. 31 | 24 * 32 | 25 * @see pv.Behavior.drag 33 | 26 * @see pv.Behavior.pan 34 | 27 * @see pv.Behavior.point 35 | 28 * @see pv.Behavior.select 36 | 29 * @see pv.Behavior.zoom 37 | 30 * @extends function 38 | 31 */ 39 | 32 pv.Behavior = {}; 40 | 33-------------------------------------------------------------------------------- /lib/protovis-3.2/jsdoc/symbols/src/src_color_Ramp.js.html: -------------------------------------------------------------------------------- 1 |
1 /** 9 | 2 * Returns a linear color ramp from the specified <tt>start</tt> color to the 10 | 3 * specified <tt>end</tt> color. The color arguments may be specified either as 11 | 4 * <tt>string</tt>s or as {@link pv.Color}s. This is equivalent to: 12 | 5 * 13 | 6 * <pre> pv.Scale.linear().domain(0, 1).range(...)</pre> 14 | 7 * 15 | 8 * @param {string} start the start color; may be a <tt>pv.Color</tt>. 16 | 9 * @param {string} end the end color; may be a <tt>pv.Color</tt>. 17 | 10 * @returns {Function} a color ramp from <tt>start</tt> to <tt>end</tt>. 18 | 11 * @see pv.Scale.linear 19 | 12 */ 20 | 13 pv.ramp = function(start, end) { 21 | 14 var scale = pv.Scale.linear(); 22 | 15 scale.range.apply(scale, arguments); 23 | 16 return scale; 24 | 17 }; 25 | 18-------------------------------------------------------------------------------- /lib/protovis-3.2/jsdoc/symbols/src/src_data_LinearScale.js.html: -------------------------------------------------------------------------------- 1 |
1 /** 9 | 2 * Returns a linear scale for the specified domain. The arguments to this 10 | 3 * constructor are optional, and equivalent to calling {@link #domain}. 11 | 4 * The default domain and range are [0,1]. 12 | 5 * 13 | 6 * @class Represents a linear scale; a function that performs a linear 14 | 7 * transformation. <style type="text/css">sub{line-height:0}</style> Most 15 | 8 * commonly, a linear scale represents a 1-dimensional linear transformation 16 | 9 * from a numeric domain of input data [<i>d<sub>0</sub></i>, 17 | 10 * <i>d<sub>1</sub></i>] to a numeric range of pixels [<i>r<sub>0</sub></i>, 18 | 11 * <i>r<sub>1</sub></i>]. The equation for such a scale is: 19 | 12 * 20 | 13 * <blockquote><i>f(x) = (x - d<sub>0</sub>) / (d<sub>1</sub> - d<sub>0</sub>) * 21 | 14 * (r<sub>1</sub> - r<sub>0</sub>) + r<sub>0</sub></i></blockquote> 22 | 15 * 23 | 16 * For example, a linear scale from the domain [0, 100] to range [0, 640]: 24 | 17 * 25 | 18 * <blockquote><i>f(x) = (x - 0) / (100 - 0) * (640 - 0) + 0</i><br> 26 | 19 * <i>f(x) = x / 100 * 640</i><br> 27 | 20 * <i>f(x) = x * 6.4</i><br> 28 | 21 * </blockquote> 29 | 22 * 30 | 23 * Thus, saying 31 | 24 * 32 | 25 * <pre> .height(function(d) d * 6.4)</pre> 33 | 26 * 34 | 27 * is identical to 35 | 28 * 36 | 29 * <pre> .height(pv.Scale.linear(0, 100).range(0, 640))</pre> 37 | 30 * 38 | 31 * Note that the scale is itself a function, and thus can be used as a property 39 | 32 * directly, assuming that the data associated with a mark is a number. While 40 | 33 * this is convenient for single-use scales, frequently it is desirable to 41 | 34 * define scales globally: 42 | 35 * 43 | 36 * <pre>var y = pv.Scale.linear(0, 100).range(0, 640);</pre> 44 | 37 * 45 | 38 * The <tt>y</tt> scale can now be equivalently referenced within a property: 46 | 39 * 47 | 40 * <pre> .height(function(d) y(d))</pre> 48 | 41 * 49 | 42 * Alternatively, if the data are not simple numbers, the appropriate value can 50 | 43 * be passed to the <tt>y</tt> scale (e.g., <tt>d.foo</tt>). The {@link #by} 51 | 44 * method similarly allows the data to be mapped to a numeric value before 52 | 45 * performing the linear transformation. 53 | 46 * 54 | 47 * @param {number...} domain... optional domain values. 55 | 48 * @extends pv.Scale.quantitative 56 | 49 */ 57 | 50 pv.Scale.linear = function() { 58 | 51 var scale = pv.Scale.quantitative(); 59 | 52 scale.domain.apply(scale, arguments); 60 | 53 return scale; 61 | 54 }; 62 | 55-------------------------------------------------------------------------------- /lib/protovis-3.2/jsdoc/symbols/src/src_data_RootScale.js.html: -------------------------------------------------------------------------------- 1 |
1 /** 9 | 2 * Returns a root scale for the specified domain. The arguments to this 10 | 3 * constructor are optional, and equivalent to calling {@link #domain}. 11 | 4 * The default domain and range are [0,1]. 12 | 5 * 13 | 6 * @class Represents a root scale; a function that performs a power 14 | 7 * transformation. <style type="text/css">sub{line-height:0}</style> Most 15 | 8 * commonly, a root scale represents a 1-dimensional root transformation from a 16 | 9 * numeric domain of input data [<i>d<sub>0</sub></i>, <i>d<sub>1</sub></i>] to 17 | 10 * a numeric range of pixels [<i>r<sub>0</sub></i>, <i>r<sub>1</sub></i>]. 18 | 11 * 19 | 12 * <p>Note that the scale is itself a function, and thus can be used as a 20 | 13 * property directly, assuming that the data associated with a mark is a 21 | 14 * number. While this is convenient for single-use scales, frequently it is 22 | 15 * desirable to define scales globally: 23 | 16 * 24 | 17 * <pre>var y = pv.Scale.root(0, 100).range(0, 640);</pre> 25 | 18 * 26 | 19 * The <tt>y</tt> scale can now be equivalently referenced within a property: 27 | 20 * 28 | 21 * <pre> .height(function(d) y(d))</pre> 29 | 22 * 30 | 23 * Alternatively, if the data are not simple numbers, the appropriate value can 31 | 24 * be passed to the <tt>y</tt> scale (e.g., <tt>d.foo</tt>). The {@link #by} 32 | 25 * method similarly allows the data to be mapped to a numeric value before 33 | 26 * performing the root transformation. 34 | 27 * 35 | 28 * @param {number...} domain... optional domain values. 36 | 29 * @extends pv.Scale.quantitative 37 | 30 */ 38 | 31 pv.Scale.root = function() { 39 | 32 var scale = pv.Scale.quantitative(); 40 | 33 41 | 34 /** 42 | 35 * Sets or gets the exponent; defaults to 2. 43 | 36 * 44 | 37 * @function 45 | 38 * @name pv.Scale.root.prototype.power 46 | 39 * @param {number} [v] the new exponent. 47 | 40 * @returns {pv.Scale.root} <tt>this</tt>, or the current base. 48 | 41 */ 49 | 42 scale.power = function(v) { 50 | 43 if (arguments.length) { 51 | 44 var b = Number(v), p = 1 / b; 52 | 45 scale.transform( 53 | 46 function(x) { return Math.pow(x, p); }, 54 | 47 function(y) { return Math.pow(y, b); }); 55 | 48 return this; 56 | 49 } 57 | 50 return b; 58 | 51 }; 59 | 52 60 | 53 scale.domain.apply(scale, arguments); 61 | 54 return scale.power(2); 62 | 55 }; 63 | 56-------------------------------------------------------------------------------- /lib/protovis-3.2/jsdoc/symbols/src/src_geo_Geo.js.html: -------------------------------------------------------------------------------- 1 |
1 /** 9 | 2 * @ignore 10 | 3 * @namespace 11 | 4 */ 12 | 5 pv.Geo = function() {}; 13 | 6-------------------------------------------------------------------------------- /lib/protovis-3.2/jsdoc/symbols/src/src_geo_LatLng.js.html: -------------------------------------------------------------------------------- 1 |
1 /** 9 | 2 * Abstract; not implemented. There is no explicit constructor; this class 10 | 3 * merely serves to document the representation used by {@link pv.Geo.scale}. 11 | 4 * 12 | 5 * @class Represents a pair of geographic coordinates. 13 | 6 * 14 | 7 * @name pv.Geo.LatLng 15 | 8 * @see pv.Geo.scale 16 | 9 */ 17 | 10 18 | 11 /** 19 | 12 * The <i>latitude</i> coordinate in degrees; positive is North. 20 | 13 * 21 | 14 * @type number 22 | 15 * @name pv.Geo.LatLng.prototype.lat 23 | 16 */ 24 | 17 25 | 18 /** 26 | 19 * The <i>longitude</i> coordinate in degrees; positive is East. 27 | 20 * 28 | 21 * @type number 29 | 22 * @name pv.Geo.LatLng.prototype.lng 30 | 23 */ 31 | 24-------------------------------------------------------------------------------- /lib/protovis-3.2/jsdoc/symbols/src/src_geo_Projection.js.html: -------------------------------------------------------------------------------- 1 |
1 /** 9 | 2 * Abstract; not implemented. There is no explicit constructor; this class 10 | 3 * merely serves to document the representation used by {@link pv.Geo.scale}. 11 | 4 * 12 | 5 * @class Represents a geographic projection. This class provides the core 13 | 6 * implementation for {@link pv.Geo.scale}s, mapping between geographic 14 | 7 * coordinates (latitude and longitude) and normalized screen space in the range 15 | 8 * [-1,1]. The remaining mapping between normalized screen space and actual 16 | 9 * pixels is performed by <tt>pv.Geo.scale</tt>. 17 | 10 * 18 | 11 * <p>Many geographic projections have a point around which the projection is 19 | 12 * centered. Rather than have each implementation add support for a 20 | 13 * user-specified center point, the <tt>pv.Geo.scale</tt> translates the 21 | 14 * geographic coordinates relative to the center point for both the forward and 22 | 15 * inverse projection. 23 | 16 * 24 | 17 * <p>In general, this class should not be used directly, unless the desire is 25 | 18 * to implement a new geographic projection. Instead, use <tt>pv.Geo.scale</tt>. 26 | 19 * Implementations are not required to implement inverse projections, but are 27 | 20 * needed for some forms of interactivity. Also note that some inverse 28 | 21 * projections are ambiguous, such as the connecting points in Dymaxian maps. 29 | 22 * 30 | 23 * @name pv.Geo.Projection 31 | 24 * @see pv.Geo.scale 32 | 25 */ 33 | 26 34 | 27 /** 35 | 28 * The <i>forward</i> projection. 36 | 29 * 37 | 30 * @function 38 | 31 * @name pv.Geo.Projection.prototype.project 39 | 32 * @param {pv.Geo.LatLng} latlng the latitude and longitude to project. 40 | 33 * @returns {pv.Vector} the xy-coordinates of the given point. 41 | 34 */ 42 | 35 43 | 36 /** 44 | 37 * The <i>inverse</i> projection; optional. 45 | 38 * 46 | 39 * @function 47 | 40 * @name pv.Geo.Projection.prototype.invert 48 | 41 * @param {pv.Vector} xy the x- and y-coordinates to invert. 49 | 42 * @returns {pv.Geo.LatLng} the latitude and longitude of the given point. 50 | 43 */ 51 | 44-------------------------------------------------------------------------------- /lib/protovis-3.2/jsdoc/symbols/src/src_lang_init.js.html: -------------------------------------------------------------------------------- 1 |
1 /* 9 | 2 * Parses the Protovis specifications on load, allowing the use of JavaScript 10 | 3 * 1.8 function expressions on browsers that only support JavaScript 1.6. 11 | 4 * 12 | 5 * @see pv.parse 13 | 6 */ 14 | 7 pv.listen(window, "load", function() { 15 | 8 /* 16 | 9 * Note: in Firefox any variables declared here are visible to the eval'd 17 | 10 * script below. Even worse, any global variables declared by the script 18 | 11 * could overwrite local variables here (such as the index, `i`)! To protect 19 | 12 * against this, all variables are explicitly scoped on a pv.$ object. 20 | 13 */ 21 | 14 pv.$ = {i:0, x:document.getElementsByTagName("script")}; 22 | 15 for (; pv.$.i < pv.$.x.length; pv.$.i++) { 23 | 16 pv.$.s = pv.$.x[pv.$.i]; 24 | 17 if (pv.$.s.type == "text/javascript+protovis") { 25 | 18 try { 26 | 19 window.eval(pv.parse(pv.$.s.text)); 27 | 20 } catch (e) { 28 | 21 pv.error(e); 29 | 22 } 30 | 23 } 31 | 24 } 32 | 25 delete pv.$; 33 | 26 }); 34 | 27-------------------------------------------------------------------------------- /lib/protovis-3.2/jsdoc/symbols/src/src_layout_Layout.js.html: -------------------------------------------------------------------------------- 1 |
1 /** 9 | 2 * Constructs a new, empty layout with default properties. Layouts are not 10 | 3 * typically constructed directly; instead, a concrete subclass is added to an 11 | 4 * existing panel via {@link pv.Mark#add}. 12 | 5 * 13 | 6 * @class Represents an abstract layout, encapsulating a visualization technique 14 | 7 * such as a streamgraph or treemap. Layouts are themselves containers, 15 | 8 * extending from {@link pv.Panel}, and defining a set of mark prototypes as 16 | 9 * children. These mark prototypes provide default properties that together 17 | 10 * implement the given visualization technique. 18 | 11 * 19 | 12 * <p>Layouts do not initially contain any marks; any exported marks (such as a 20 | 13 * network layout's <tt>link</tt> and <tt>node</tt>) are intended to be used as 21 | 14 * prototypes. By adding a concrete mark, such as a {@link pv.Bar}, to the 22 | 15 * appropriate mark prototype, the mark is added to the layout and inherits the 23 | 16 * given properties. This approach allows further customization of the layout, 24 | 17 * either by choosing a different mark type to add, or more simply by overriding 25 | 18 * some of the layout's defined properties. 26 | 19 * 27 | 20 * <p>Each concrete layout, such as treemap or circle-packing, has different 28 | 21 * behavior and may export different mark prototypes, depending on what marks 29 | 22 * are typically needed to render the desired visualization. Therefore it is 30 | 23 * important to understand how each layout is structured, such that the provided 31 | 24 * mark prototypes are used appropriately. 32 | 25 * 33 | 26 * <p>In addition to the mark prototypes, layouts may define custom properties 34 | 27 * that affect the overall behavior of the layout. For example, a treemap layout 35 | 28 * might use a property to specify which layout algorithm to use. These 36 | 29 * properties are just like other mark properties, and can be defined as 37 | 30 * constants or as functions. As with panels, the data property can be used to 38 | 31 * replicate layouts, and properties can be defined to in terms of layout data. 39 | 32 * 40 | 33 * @extends pv.Panel 41 | 34 */ 42 | 35 pv.Layout = function() { 43 | 36 pv.Panel.call(this); 44 | 37 }; 45 | 38 46 | 39 pv.Layout.prototype = pv.extend(pv.Panel); 47 | 40 48 | 41 /** 49 | 42 * @private Defines a local property with the specified name and cast. Note that 50 | 43 * although the property method is only defined locally, the cast function is 51 | 44 * global, which is necessary since properties are inherited! 52 | 45 * 53 | 46 * @param {string} name the property name. 54 | 47 * @param {function} [cast] the cast function for this property. 55 | 48 */ 56 | 49 pv.Layout.prototype.property = function(name, cast) { 57 | 50 if (!this.hasOwnProperty("properties")) { 58 | 51 this.properties = pv.extend(this.properties); 59 | 52 } 60 | 53 this.properties[name] = true; 61 | 54 this.propertyMethod(name, false, pv.Mark.cast[name] = cast); 62 | 55 return this; 63 | 56 }; 64 | 57-------------------------------------------------------------------------------- /lib/protovis-3.2/jsdoc/symbols/src/src_mark_Anchor.js.html: -------------------------------------------------------------------------------- 1 |
1 /** 9 | 2 * Constructs a new mark anchor with default properties. 10 | 3 * 11 | 4 * @class Represents an anchor on a given mark. An anchor is itself a mark, but 12 | 5 * without a visual representation. It serves only to provide useful default 13 | 6 * properties that can be inherited by other marks. Each type of mark can define 14 | 7 * any number of named anchors for convenience. If the concrete mark type does 15 | 8 * not define an anchor implementation specifically, one will be inherited from 16 | 9 * the mark's parent class. 17 | 10 * 18 | 11 * <p>For example, the bar mark provides anchors for its four sides: left, 19 | 12 * right, top and bottom. Adding a label to the top anchor of a bar, 20 | 13 * 21 | 14 * <pre>bar.anchor("top").add(pv.Label);</pre> 22 | 15 * 23 | 16 * will render a text label on the top edge of the bar; the top anchor defines 24 | 17 * the appropriate position properties (top and left), as well as text-rendering 25 | 18 * properties for convenience (textAlign and textBaseline). 26 | 19 * 27 | 20 * <p>Note that anchors do not <i>inherit</i> from their targets; the positional 28 | 21 * properties are copied from the scene graph, which guarantees that the anchors 29 | 22 * are positioned correctly, even if the positional properties are not defined 30 | 23 * deterministically. (In addition, it also improves performance by avoiding 31 | 24 * re-evaluating expensive properties.) If you want the anchor to inherit from 32 | 25 * the target, use {@link pv.Mark#extend} before adding. For example: 33 | 26 * 34 | 27 * <pre>bar.anchor("top").extend(bar).add(pv.Label);</pre> 35 | 28 * 36 | 29 * The anchor defines it's own positional properties, but other properties (such 37 | 30 * as the title property, say) can be inherited using the above idiom. Also note 38 | 31 * that you can override positional properties in the anchor for custom 39 | 32 * behavior. 40 | 33 * 41 | 34 * @extends pv.Mark 42 | 35 * @param {pv.Mark} target the anchor target. 43 | 36 */ 44 | 37 pv.Anchor = function(target) { 45 | 38 pv.Mark.call(this); 46 | 39 this.target = target; 47 | 40 this.parent = target.parent; 48 | 41 }; 49 | 42 50 | 43 pv.Anchor.prototype = pv.extend(pv.Mark) 51 | 44 .property("name", String); 52 | 45 53 | 46 /** 54 | 47 * The anchor name. The set of supported anchor names is dependent on the 55 | 48 * concrete mark type; see the mark type for details. For example, bars support 56 | 49 * left, right, top and bottom anchors. 57 | 50 * 58 | 51 * <p>While anchor names are typically constants, the anchor name is a true 59 | 52 * property, which means you can specify a function to compute the anchor name 60 | 53 * dynamically. For instance, if you wanted to alternate top and bottom anchors, 61 | 54 * saying 62 | 55 * 63 | 56 * <pre>m.anchor(function() (this.index % 2) ? "top" : "bottom").add(pv.Dot);</pre> 64 | 57 * 65 | 58 * would have the desired effect. 66 | 59 * 67 | 60 * @type string 68 | 61 * @name pv.Anchor.prototype.name 69 | 62 */ 70 | 63 71 | 64 /** 72 | 65 * Returns the anchor target of this mark, if it is derived from an anchor; 73 | 66 * otherwise returns null. For example, if a label is derived from a bar anchor, 74 | 67 * 75 | 68 * <pre>bar.anchor("top").add(pv.Label);</pre> 76 | 69 * 77 | 70 * then property functions on the label can refer to the bar via the 78 | 71 * <tt>anchorTarget</tt> method. This method is also useful for mark types 79 | 72 * defining properties on custom anchors. 80 | 73 * 81 | 74 * @returns {pv.Mark} the anchor target of this mark; possibly null. 82 | 75 */ 83 | 76 pv.Anchor.prototype.anchorTarget = function() { 84 | 77 return this.target; 85 | 78 }; 86 | 79-------------------------------------------------------------------------------- /lib/protovis-3.2/jsdoc/symbols/src/src_mark_Bar.js.html: -------------------------------------------------------------------------------- 1 |
1 /** 9 | 2 * Constructs a new bar mark with default properties. Bars are not typically 10 | 3 * constructed directly, but by adding to a panel or an existing mark via 11 | 4 * {@link pv.Mark#add}. 12 | 5 * 13 | 6 * @class Represents a bar: an axis-aligned rectangle that can be stroked and 14 | 7 * filled. Bars are used for many chart types, including bar charts, histograms 15 | 8 * and Gantt charts. Bars can also be used as decorations, for example to draw a 16 | 9 * frame border around a panel; in fact, a panel is a special type (a subclass) 17 | 10 * of bar. 18 | 11 * 19 | 12 * <p>Bars can be positioned in several ways. Most commonly, one of the four 20 | 13 * corners is fixed using two margins, and then the width and height properties 21 | 14 * determine the extent of the bar relative to this fixed location. For example, 22 | 15 * using the bottom and left properties fixes the bottom-left corner; the width 23 | 16 * then extends to the right, while the height extends to the top. As an 24 | 17 * alternative to the four corners, a bar can be positioned exclusively using 25 | 18 * margins; this is convenient as an inset from the containing panel, for 26 | 19 * example. See {@link pv.Mark} for details on the prioritization of redundant 27 | 20 * positioning properties. 28 | 21 * 29 | 22 * <p>See also the <a href="../../api/Bar.html">Bar guide</a>. 30 | 23 * 31 | 24 * @extends pv.Mark 32 | 25 */ 33 | 26 pv.Bar = function() { 34 | 27 pv.Mark.call(this); 35 | 28 }; 36 | 29 37 | 30 pv.Bar.prototype = pv.extend(pv.Mark) 38 | 31 .property("width", Number) 39 | 32 .property("height", Number) 40 | 33 .property("lineWidth", Number) 41 | 34 .property("strokeStyle", pv.color) 42 | 35 .property("fillStyle", pv.color); 43 | 36 44 | 37 pv.Bar.prototype.type = "bar"; 45 | 38 46 | 39 /** 47 | 40 * The width of the bar, in pixels. If the left position is specified, the bar 48 | 41 * extends rightward from the left edge; if the right position is specified, the 49 | 42 * bar extends leftward from the right edge. 50 | 43 * 51 | 44 * @type number 52 | 45 * @name pv.Bar.prototype.width 53 | 46 */ 54 | 47 55 | 48 /** 56 | 49 * The height of the bar, in pixels. If the bottom position is specified, the 57 | 50 * bar extends upward from the bottom edge; if the top position is specified, 58 | 51 * the bar extends downward from the top edge. 59 | 52 * 60 | 53 * @type number 61 | 54 * @name pv.Bar.prototype.height 62 | 55 */ 63 | 56 64 | 57 /** 65 | 58 * The width of stroked lines, in pixels; used in conjunction with 66 | 59 * <tt>strokeStyle</tt> to stroke the bar's border. 67 | 60 * 68 | 61 * @type number 69 | 62 * @name pv.Bar.prototype.lineWidth 70 | 63 */ 71 | 64 72 | 65 /** 73 | 66 * The style of stroked lines; used in conjunction with <tt>lineWidth</tt> to 74 | 67 * stroke the bar's border. The default value of this property is null, meaning 75 | 68 * bars are not stroked by default. 76 | 69 * 77 | 70 * @type string 78 | 71 * @name pv.Bar.prototype.strokeStyle 79 | 72 * @see pv.color 80 | 73 */ 81 | 74 82 | 75 /** 83 | 76 * The bar fill style; if non-null, the interior of the bar is filled with the 84 | 77 * specified color. The default value of this property is a categorical color. 85 | 78 * 86 | 79 * @type string 87 | 80 * @name pv.Bar.prototype.fillStyle 88 | 81 * @see pv.color 89 | 82 */ 90 | 83 91 | 84 /** 92 | 85 * Default properties for bars. By default, there is no stroke and the fill 93 | 86 * style is a categorical color. 94 | 87 * 95 | 88 * @type pv.Bar 96 | 89 */ 97 | 90 pv.Bar.prototype.defaults = new pv.Bar() 98 | 91 .extend(pv.Mark.prototype.defaults) 99 | 92 .lineWidth(1.5) 100 | 93 .fillStyle(pv.Colors.category20().by(pv.parent)); 101 | 94-------------------------------------------------------------------------------- /lib/protovis-3.2/jsdoc/symbols/src/src_physics_Constraint.js.html: -------------------------------------------------------------------------------- 1 |
1 /** 9 | 2 * Abstract; see an implementing class. 10 | 3 * 11 | 4 * @class Represents a constraint that acts on particles. Note that this 12 | 5 * interface does not specify how to bind a constraint to specific particles; in 13 | 6 * general, constraints are applied globally to all particles. However, some 14 | 7 * constraints may be applied to specific particles or between particles, such 15 | 8 * as position constraints, through additional specialization. 16 | 9 * 17 | 10 * @see pv.Simulation 18 | 11 * @see pv.Particle 19 | 12 * @see pv.Constraint.bound 20 | 13 * @see pv.Constraint.collision 21 | 14 * @see pv.Constraint.position 22 | 15 */ 23 | 16 pv.Constraint = {}; 24 | 17 25 | 18 /** 26 | 19 * Applies this constraint to the specified particles. 27 | 20 * 28 | 21 * @function 29 | 22 * @name pv.Constraint.prototype.apply 30 | 23 * @param {pv.Particle} particles particles to which to apply this constraint. 31 | 24 * @param {pv.Quadtree} q a quadtree for spatial acceleration. 32 | 25 * @returns {pv.Constraint} this. 33 | 26 */ 34 | 27-------------------------------------------------------------------------------- /lib/protovis-3.2/jsdoc/symbols/src/src_physics_DragForce.js.html: -------------------------------------------------------------------------------- 1 |
1 /** 9 | 2 * Constructs a new drag force with the specified constant. 10 | 3 * 11 | 4 * @class Implements a drag force, simulating friction. The drag force is 12 | 5 * applied in the opposite direction of the particle's velocity. Since Position 13 | 6 * Verlet integration does not track velocities explicitly, the error term with 14 | 7 * this estimate of velocity is fairly high, so the drag force may be 15 | 8 * inaccurate. 16 | 9 * 17 | 10 * @extends pv.Force 18 | 11 * @param {number} k the drag constant. 19 | 12 * @see #constant 20 | 13 */ 21 | 14 pv.Force.drag = function(k) { 22 | 15 var force = {}; 23 | 16 24 | 17 if (!arguments.length) k = .1; // default drag constant 25 | 18 26 | 19 /** 27 | 20 * Sets or gets the drag constant, in the range [0,1]. The default drag 28 | 21 * constant is 0.1. The drag forces scales linearly with the particle's 29 | 22 * velocity based on the given drag constant. 30 | 23 * 31 | 24 * @function 32 | 25 * @name pv.Force.drag.prototype.constant 33 | 26 * @param {number} x the new drag constant. 34 | 27 * @returns {pv.Force.drag} this, or the current drag constant. 35 | 28 */ 36 | 29 force.constant = function(x) { 37 | 30 if (arguments.length) { k = x; return force; } 38 | 31 return k; 39 | 32 }; 40 | 33 41 | 34 /** 42 | 35 * Applies this force to the specified particles. 43 | 36 * 44 | 37 * @function 45 | 38 * @name pv.Force.drag.prototype.apply 46 | 39 * @param {pv.Particle} particles particles to which to apply this force. 47 | 40 */ 48 | 41 force.apply = function(particles) { 49 | 42 if (k) for (var p = particles; p; p = p.next) { 50 | 43 p.fx -= k * p.vx; 51 | 44 p.fy -= k * p.vy; 52 | 45 } 53 | 46 }; 54 | 47 55 | 48 return force; 56 | 49 }; 57 | 50-------------------------------------------------------------------------------- /lib/protovis-3.2/jsdoc/symbols/src/src_physics_Force.js.html: -------------------------------------------------------------------------------- 1 |
1 /** 9 | 2 * Abstract; see an implementing class. 10 | 3 * 11 | 4 * @class Represents a force that acts on particles. Note that this interface 12 | 5 * does not specify how to bind a force to specific particles; in general, 13 | 6 * forces are applied globally to all particles. However, some forces may be 14 | 7 * applied to specific particles or between particles, such as spring forces, 15 | 8 * through additional specialization. 16 | 9 * 17 | 10 * @see pv.Simulation 18 | 11 * @see pv.Particle 19 | 12 * @see pv.Force.charge 20 | 13 * @see pv.Force.drag 21 | 14 * @see pv.Force.spring 22 | 15 */ 23 | 16 pv.Force = {}; 24 | 17 25 | 18 /** 26 | 19 * Applies this force to the specified particles. 27 | 20 * 28 | 21 * @function 29 | 22 * @name pv.Force.prototype.apply 30 | 23 * @param {pv.Particle} particles particles to which to apply this force. 31 | 24 * @param {pv.Quadtree} q a quadtree for spatial acceleration. 32 | 25 */ 33 | 26-------------------------------------------------------------------------------- /lib/protovis-3.2/jsdoc/symbols/src/src_physics_Particle.js.html: -------------------------------------------------------------------------------- 1 |
1 /** 9 | 2 * Abstract; not implemented. There is no explicit constructor; this class 10 | 3 * merely serves to document the attributes that are used on particles in 11 | 4 * physics simulations. 12 | 5 * 13 | 6 * @class A weighted particle that can participate in a force simulation. 14 | 7 * 15 | 8 * @name pv.Particle 16 | 9 */ 17 | 10 18 | 11 /** 19 | 12 * The next particle in the simulation. Particles form a singly-linked list. 20 | 13 * 21 | 14 * @field 22 | 15 * @type pv.Particle 23 | 16 * @name pv.Particle.prototype.next 24 | 17 */ 25 | 18 26 | 19 /** 27 | 20 * The <i>x</i>-position of the particle. 28 | 21 * 29 | 22 * @field 30 | 23 * @type number 31 | 24 * @name pv.Particle.prototype.x 32 | 25 */ 33 | 26 34 | 27 /** 35 | 28 * The <i>y</i>-position of the particle. 36 | 29 * 37 | 30 * @field 38 | 31 * @type number 39 | 32 * @name pv.Particle.prototype.y 40 | 33 */ 41 | 34 42 | 35 /** 43 | 36 * The <i>x</i>-velocity of the particle. 44 | 37 * 45 | 38 * @field 46 | 39 * @type number 47 | 40 * @name pv.Particle.prototype.vx 48 | 41 */ 49 | 42 50 | 43 /** 51 | 44 * The <i>y</i>-velocity of the particle. 52 | 45 * 53 | 46 * @field 54 | 47 * @type number 55 | 48 * @name pv.Particle.prototype.vy 56 | 49 */ 57 | 50 58 | 51 /** 59 | 52 * The <i>x</i>-position of the particle at -dt. 60 | 53 * 61 | 54 * @field 62 | 55 * @type number 63 | 56 * @name pv.Particle.prototype.px 64 | 57 */ 65 | 58 66 | 59 /** 67 | 60 * The <i>y</i>-position of the particle at -dt. 68 | 61 * 69 | 62 * @field 70 | 63 * @type number 71 | 64 * @name pv.Particle.prototype.py 72 | 65 */ 73 | 66 74 | 67 /** 75 | 68 * The <i>x</i>-force on the particle. 76 | 69 * 77 | 70 * @field 78 | 71 * @type number 79 | 72 * @name pv.Particle.prototype.fx 80 | 73 */ 81 | 74 82 | 75 /** 83 | 76 * The <i>y</i>-force on the particle. 84 | 77 * 85 | 78 * @field 86 | 79 * @type number 87 | 80 * @name pv.Particle.prototype.fy 88 | 81 */ 89 | 82-------------------------------------------------------------------------------- /lib/protovis-3.2/jsdoc/symbols/src/src_physics_PositionConstraint.js.html: -------------------------------------------------------------------------------- 1 |
1 /** 9 | 2 * Constructs a default position constraint using the <tt>fix</tt> attribute. 10 | 3 * An optional position function can be specified to determine how the fixed 11 | 4 * position per-particle is determined. 12 | 5 * 13 | 6 * @class Constraints particles to a fixed position. The fixed position per 14 | 7 * particle is determined using a given position function, which defaults to 15 | 8 * <tt>function(d) d.fix</tt>. 16 | 9 * 17 | 10 * <p>If the position function returns null, then no position constraint is 18 | 11 * applied to the given particle. Otherwise, the particle's position is set to 19 | 12 * the returned position, as expressed by a {@link pv.Vector}. (Note: the 20 | 13 * position does not need to be an instance of <tt>pv.Vector</tt>, but simply an 21 | 14 * object with <tt>x</tt> and <tt>y</tt> attributes.) 22 | 15 * 23 | 16 * <p>This constraint also supports a configurable alpha parameter, which 24 | 17 * defaults to 1. If the alpha parameter is in the range [0,1], then rather than 25 | 18 * setting the particle's new position directly to the position returned by the 26 | 19 * supplied position function, the particle's position is interpolated towards 27 | 20 * the fixed position. This results is a smooth (exponential) drift towards the 28 | 21 * fixed position, which can increase the stability of the physics simulation. 29 | 22 * In addition, the alpha parameter can be decayed over time, relaxing the 30 | 23 * position constraint, which helps to stabilize on an optimal solution. 31 | 24 * 32 | 25 * @param {function} [f] the position function. 33 | 26 */ 34 | 27 pv.Constraint.position = function(f) { 35 | 28 var a = 1, // default alpha 36 | 29 constraint = {}; 37 | 30 38 | 31 if (!arguments.length) /** @ignore */ f = function(p) { return p.fix; }; 39 | 32 40 | 33 /** 41 | 34 * Sets or gets the alpha parameter for position interpolation. If the alpha 42 | 35 * parameter is in the range [0,1], then rather than setting the particle's 43 | 36 * new position directly to the position returned by the supplied position 44 | 37 * function, the particle's position is interpolated towards the fixed 45 | 38 * position. 46 | 39 * 47 | 40 * @function 48 | 41 * @name pv.Constraint.position.prototype.alpha 49 | 42 * @param {number} x the new alpha parameter, in the range [0,1]. 50 | 43 * @returns {pv.Constraint.position} this. 51 | 44 */ 52 | 45 constraint.alpha = function(x) { 53 | 46 if (arguments.length) { 54 | 47 a = Number(x); 55 | 48 return constraint; 56 | 49 } 57 | 50 return a; 58 | 51 }; 59 | 52 60 | 53 /** 61 | 54 * Applies this constraint to the specified particles. 62 | 55 * 63 | 56 * @function 64 | 57 * @name pv.Constraint.position.prototype.apply 65 | 58 * @param {pv.Particle} particles particles to which to apply this constraint. 66 | 59 */ 67 | 60 constraint.apply = function(particles) { 68 | 61 for (var p = particles; p; p = p.next) { 69 | 62 var v = f(p); 70 | 63 if (v) { 71 | 64 p.x += (v.x - p.x) * a; 72 | 65 p.y += (v.y - p.y) * a; 73 | 66 p.fx = p.fy = p.vx = p.vy = 0; 74 | 67 } 75 | 68 } 76 | 69 }; 77 | 70 78 | 71 return constraint; 79 | 72 }; 80 | 73-------------------------------------------------------------------------------- /lib/protovis-3.2/jsdoc/symbols/src/src_pv.js.html: -------------------------------------------------------------------------------- 1 |
1 /** 9 | 2 * The top-level Protovis namespace. All public methods and fields should be 10 | 3 * registered on this object. Note that core Protovis source is surrounded by an 11 | 4 * anonymous function, so any other declared globals will not be visible outside 12 | 5 * of core methods. This also allows multiple versions of Protovis to coexist, 13 | 6 * since each version will see their own <tt>pv</tt> namespace. 14 | 7 * 15 | 8 * @namespace The top-level Protovis namespace, <tt>pv</tt>. 16 | 9 */ 17 | 10 var pv = {}; 18 | 11 19 | 12 /** 20 | 13 * Protovis major and minor version numbers. 21 | 14 * 22 | 15 * @namespace Protovis major and minor version numbers. 23 | 16 */ 24 | 17 pv.version = { 25 | 18 /** 26 | 19 * The major version number. 27 | 20 * 28 | 21 * @type number 29 | 22 * @constant 30 | 23 */ 31 | 24 major: 3, 32 | 25 33 | 26 /** 34 | 27 * The minor version number. 35 | 28 * 36 | 29 * @type number 37 | 30 * @constant 38 | 31 */ 39 | 32 minor: 2 40 | 33 }; 41 | 34 42 | 35 /** 43 | 36 * Returns the passed-in argument, <tt>x</tt>; the identity function. This method 44 | 37 * is provided for convenience since it is used as the default behavior for a 45 | 38 * number of property functions. 46 | 39 * 47 | 40 * @param x a value. 48 | 41 * @returns the value <tt>x</tt>. 49 | 42 */ 50 | 43 pv.identity = function(x) { return x; }; 51 | 44 52 | 45 /** 53 | 46 * Returns <tt>this.index</tt>. This method is provided for convenience for use 54 | 47 * with scales. For example, to color bars by their index, say: 55 | 48 * 56 | 49 * <pre>.fillStyle(pv.Colors.category10().by(pv.index))</pre> 57 | 50 * 58 | 51 * This method is equivalent to <tt>function() this.index</tt>, but more 59 | 52 * succinct. Note that the <tt>index</tt> property is also supported for 60 | 53 * accessor functions with {@link pv.max}, {@link pv.min} and other array 61 | 54 * utility methods. 62 | 55 * 63 | 56 * @see pv.Scale 64 | 57 * @see pv.Mark#index 65 | 58 */ 66 | 59 pv.index = function() { return this.index; }; 67 | 60 68 | 61 /** 69 | 62 * Returns <tt>this.childIndex</tt>. This method is provided for convenience for 70 | 63 * use with scales. For example, to color bars by their child index, say: 71 | 64 * 72 | 65 * <pre>.fillStyle(pv.Colors.category10().by(pv.child))</pre> 73 | 66 * 74 | 67 * This method is equivalent to <tt>function() this.childIndex</tt>, but more 75 | 68 * succinct. 76 | 69 * 77 | 70 * @see pv.Scale 78 | 71 * @see pv.Mark#childIndex 79 | 72 */ 80 | 73 pv.child = function() { return this.childIndex; }; 81 | 74 82 | 75 /** 83 | 76 * Returns <tt>this.parent.index</tt>. This method is provided for convenience 84 | 77 * for use with scales. This method is provided for convenience for use with 85 | 78 * scales. For example, to color bars by their parent index, say: 86 | 79 * 87 | 80 * <pre>.fillStyle(pv.Colors.category10().by(pv.parent))</pre> 88 | 81 * 89 | 82 * Tthis method is equivalent to <tt>function() this.parent.index</tt>, but more 90 | 83 * succinct. 91 | 84 * 92 | 85 * @see pv.Scale 93 | 86 * @see pv.Mark#index 94 | 87 */ 95 | 88 pv.parent = function() { return this.parent.index; }; 96 | 89 97 | 90 /** 98 | 91 * Stores the current event. This field is only set within event handlers. 99 | 92 * 100 | 93 * @type Event 101 | 94 * @name pv.event 102 | 95 */ 103 | 96-------------------------------------------------------------------------------- /lib/protovis-3.2/jsdoc/symbols/src/src_scene_SvgBar.js.html: -------------------------------------------------------------------------------- 1 |
1 pv.SvgScene.bar = function(scenes) { 9 | 2 var e = scenes.$g.firstChild; 10 | 3 for (var i = 0; i < scenes.length; i++) { 11 | 4 var s = scenes[i]; 12 | 5 13 | 6 /* visible */ 14 | 7 if (!s.visible) continue; 15 | 8 var fill = s.fillStyle, stroke = s.strokeStyle; 16 | 9 if (!fill.opacity && !stroke.opacity) continue; 17 | 10 18 | 11 e = this.expect(e, "rect", { 19 | 12 "shape-rendering": s.antialias ? null : "crispEdges", 20 | 13 "pointer-events": s.events, 21 | 14 "cursor": s.cursor, 22 | 15 "x": s.left, 23 | 16 "y": s.top, 24 | 17 "width": Math.max(1E-10, s.width), 25 | 18 "height": Math.max(1E-10, s.height), 26 | 19 "fill": fill.color, 27 | 20 "fill-opacity": fill.opacity || null, 28 | 21 "stroke": stroke.color, 29 | 22 "stroke-opacity": stroke.opacity || null, 30 | 23 "stroke-width": stroke.opacity ? s.lineWidth / this.scale : null 31 | 24 }); 32 | 25 e = this.append(e, scenes, i); 33 | 26 } 34 | 27 return e; 35 | 28 }; 36 | 29-------------------------------------------------------------------------------- /lib/protovis-3.2/jsdoc/symbols/src/src_scene_SvgRule.js.html: -------------------------------------------------------------------------------- 1 |
1 pv.SvgScene.rule = function(scenes) { 9 | 2 var e = scenes.$g.firstChild; 10 | 3 for (var i = 0; i < scenes.length; i++) { 11 | 4 var s = scenes[i]; 12 | 5 13 | 6 /* visible */ 14 | 7 if (!s.visible) continue; 15 | 8 var stroke = s.strokeStyle; 16 | 9 if (!stroke.opacity) continue; 17 | 10 18 | 11 e = this.expect(e, "line", { 19 | 12 "shape-rendering": s.antialias ? null : "crispEdges", 20 | 13 "pointer-events": s.events, 21 | 14 "cursor": s.cursor, 22 | 15 "x1": s.left, 23 | 16 "y1": s.top, 24 | 17 "x2": s.left + s.width, 25 | 18 "y2": s.top + s.height, 26 | 19 "stroke": stroke.color, 27 | 20 "stroke-opacity": stroke.opacity, 28 | 21 "stroke-width": s.lineWidth / this.scale 29 | 22 }); 30 | 23 e = this.append(e, scenes, i); 31 | 24 } 32 | 25 return e; 33 | 26 }; 34 | 27-------------------------------------------------------------------------------- /lib/protovis-3.2/jsdoc/symbols/src/src_text_Format.js.html: -------------------------------------------------------------------------------- 1 |
1 /** 9 | 2 * Abstract; see an implementing class. 10 | 3 * 11 | 4 * @class Represents an abstract text formatter and parser. A <i>format</i> is a 12 | 5 * function that converts an object of a given type, such as a <tt>Date</tt>, to 13 | 6 * a human-readable string representation. The format may also have a 14 | 7 * {@link #parse} method for converting a string representation back to the 15 | 8 * given object type. 16 | 9 * 17 | 10 * <p>Because formats are themselves functions, they can be used directly as 18 | 11 * mark properties. For example, if the data associated with a label are dates, 19 | 12 * a date format can be used as label text: 20 | 13 * 21 | 14 * <pre> .text(pv.Format.date("%m/%d/%y"))</pre> 22 | 15 * 23 | 16 * And as with scales, if the format is used in multiple places, it can be 24 | 17 * convenient to declare it as a global variable and then reference it from the 25 | 18 * appropriate property functions. For example, if the data has a <tt>date</tt> 26 | 19 * attribute, and <tt>format</tt> references a given date format: 27 | 20 * 28 | 21 * <pre> .text(function(d) format(d.date))</pre> 29 | 22 * 30 | 23 * Similarly, to parse a string into a date: 31 | 24 * 32 | 25 * <pre>var date = format.parse("4/30/2010");</pre> 33 | 26 * 34 | 27 * Not all format implementations support parsing. See the implementing class 35 | 28 * for details. 36 | 29 * 37 | 30 * @see pv.Format.date 38 | 31 * @see pv.Format.number 39 | 32 * @see pv.Format.time 40 | 33 */ 41 | 34 pv.Format = {}; 42 | 35 43 | 36 /** 44 | 37 * Formats the specified object, returning the string representation. 45 | 38 * 46 | 39 * @function 47 | 40 * @name pv.Format.prototype.format 48 | 41 * @param {object} x the object to format. 49 | 42 * @returns {string} the formatted string. 50 | 43 */ 51 | 44 52 | 45 /** 53 | 46 * Parses the specified string, returning the object representation. 54 | 47 * 55 | 48 * @function 56 | 49 * @name pv.Format.prototype.parse 57 | 50 * @param {string} x the string to parse. 58 | 51 * @returns {object} the parsed object. 59 | 52 */ 60 | 53 61 | 54 /** 62 | 55 * @private Given a string that may be used as part of a regular expression, 63 | 56 * this methods returns an appropriately quoted version of the specified string, 64 | 57 * with any special characters escaped. 65 | 58 * 66 | 59 * @param {string} s a string to quote. 67 | 60 * @returns {string} the quoted string. 68 | 61 */ 69 | 62 pv.Format.re = function(s) { 70 | 63 return s.replace(/[\\\^\$\*\+\?\[\]\(\)\.\{\}]/g, "\\$&"); 71 | 64 }; 72 | 65 73 | 66 /** 74 | 67 * @private Optionally pads the specified string <i>s</i> so that it is at least 75 | 68 * <i>n</i> characters long, using the padding character <i>c</i>. 76 | 69 * 77 | 70 * @param {string} c the padding character. 78 | 71 * @param {number} n the minimum string length. 79 | 72 * @param {string} s the string to pad. 80 | 73 * @returns {string} the padded string. 81 | 74 */ 82 | 75 pv.Format.pad = function(c, n, s) { 83 | 76 var m = n - String(s).length; 84 | 77 return (m < 1) ? s : new Array(m + 1).join(c) + s; 85 | 78 }; 86 | 79-------------------------------------------------------------------------------- /radar.js: -------------------------------------------------------------------------------- 1 | function init(h,w) { 2 | $('#title').text(document.title).width(w); 3 | 4 | var radar = new pv.Panel() 5 | .width(w) 6 | .height(h) 7 | .canvas('radar') 8 | 9 | // arcs 10 | radar.add(pv.Dot) 11 | .data(radar_arcs) 12 | .left(w/2) 13 | .bottom(h/2) 14 | .radius(function(d){return d.r;}) 15 | .strokeStyle("#ccc") 16 | .anchor("top") 17 | .add(pv.Label).text(function(d) { return d.name;}); 18 | 19 | //quadrant lines -- vertical 20 | radar.add(pv.Line) 21 | .data([(h/2-radar_arcs[radar_arcs.length-1].r),h-(h/2-radar_arcs[radar_arcs.length-1].r)]) 22 | .lineWidth(1) 23 | .left(w/2) 24 | .bottom(function(d) {return d;}) 25 | .strokeStyle("#bbb"); 26 | 27 | //quadrant lines -- horizontal 28 | radar.add(pv.Line) 29 | .data([(w/2-radar_arcs[radar_arcs.length-1].r),w-(w/2-radar_arcs[radar_arcs.length-1].r)]) 30 | .lineWidth(1) 31 | .bottom(h/2) 32 | .left(function(d) {return d;}) 33 | .strokeStyle("#bbb"); 34 | 35 | 36 | // blips 37 | // var total_index=1; 38 | // for (var i = 0; i < radar_data.length; i++) { 39 | // radar.add(pv.Dot) 40 | // .def("active", false) 41 | // .data(radar_data[i].items) 42 | // .size( function(d) { return ( d.blipSize !== undefined ? d.blipSize : 70 ); }) 43 | // .left(function(d) { var x = polar_to_raster(d.pc.r, d.pc.t)[0]; 44 | // //console.log("name:" + d.name + ", x:" + x); 45 | // return x;}) 46 | // .bottom(function(d) { var y = polar_to_raster(d.pc.r, d.pc.t)[1]; 47 | // //console.log("name:" + d.name + ", y:" + y); 48 | // return y;}) 49 | // .title(function(d) { return d.name;}) 50 | // .cursor( function(d) { return ( d.url !== undefined ? "pointer" : "auto" ); }) 51 | // .event("click", function(d) { if ( d.url !== undefined ){self.location = d.url}}) 52 | // .angle(Math.PI) // 180 degrees in radians ! 53 | // .strokeStyle(radar_data[i].color) 54 | // .fillStyle(radar_data[i].color) 55 | // .shape(function(d) {return (d.movement === 't' ? "triangle" : "circle");}) 56 | // .anchor("center") 57 | // .add(pv.Label) 58 | // .text(function(d) {return total_index++;}) 59 | // .textBaseline("middle") 60 | // .textStyle("white"); 61 | // } 62 | 63 | 64 | //Quadrant Ledgends 65 | var radar_quadrant_ctr=1; 66 | var quadrantFontSize = 18; 67 | var headingFontSize = 14; 68 | var stageHeadingCount = 0; 69 | var lastRadius = 0; 70 | var lastQuadrant=''; 71 | var spacer = 6; 72 | var fontSize = 10; 73 | var total_index = 1; 74 | 75 | //TODO: Super fragile: re-order the items, by radius, in order to logically group by the rings. 76 | for (var i = 0; i < radar_data.length; i++) { 77 | //adjust top by the number of headings. 78 | if (lastQuadrant != radar_data[i].quadrant) { 79 | radar.add(pv.Label) 80 | .left( radar_data[i].left ) 81 | .top( radar_data[i].top ) 82 | .text( radar_data[i].quadrant ) 83 | .strokeStyle( radar_data[i].color ) 84 | .fillStyle( radar_data[i].color ) 85 | .font(quadrantFontSize + "px sans-serif"); 86 | 87 | lastQuadrant = radar_data[i].quadrant; 88 | 89 | } 90 | 91 | // group items by stage based on how far they are from each arc 92 | var itemsByStage = _.groupBy(radar_data[i].items, function(item) { 93 | for(var arc_i = 0; arc_i < radar_arcs.length; arc_i++) { 94 | if (item.pc.r < radar_arcs[arc_i].r) 95 | { 96 | return arc_i; 97 | } 98 | } 99 | return 0; 100 | }); 101 | 102 | // In the case where a quadrant doesn't have an item, group_by will return undefined 103 | // To avoid this, fill in the blanks with an empty array 104 | for (var j=0;j