mdarray-sol 0.1.0-java

data/node_modules/dc/src/bubble-overlay.js

@@ -0,0 +1,207 @@
+/**
+ * The bubble overlay chart is quite different from the typical bubble chart. With the bubble overlay
+ * chart you can arbitrarily place bubbles on an existing svg or bitmap image, thus changing the
+ * typical x and y positioning while retaining the capability to visualize data using bubble radius
+ * and coloring.
+ *
+ * Examples:
+ * - {@link http://dc-js.github.com/dc.js/crime/index.html Canadian City Crime Stats}
+ * @class bubbleOverlay
+ * @memberof dc
+ * @mixes dc.bubbleMixin
+ * @mixes dc.baseMixin
+ * @example
+ * // create a bubble overlay chart on top of the '#chart-container1 svg' element using the default global chart group
+ * var bubbleChart1 = dc.bubbleOverlayChart('#chart-container1').svg(d3.select('#chart-container1 svg'));
+ * // create a bubble overlay chart on top of the '#chart-container2 svg' element using chart group A
+ * var bubbleChart2 = dc.compositeChart('#chart-container2', 'chartGroupA').svg(d3.select('#chart-container2 svg'));
+ * @param {String|node|d3.selection} parent - Any valid
+ * {@link https://github.com/mbostock/d3/wiki/Selections#selecting-elements d3 single selector} specifying
+ * a dom block element such as a div; or a dom element or d3 selection.
+ * @param {String} [chartGroup] - The name of the chart group this chart instance should be placed in.
+ * Interaction with a chart will only trigger events and redraws within the chart's group.
+ * @return {dc.bubbleOverlay}
+ */
+dc.bubbleOverlay = function (parent, chartGroup) {
+    var BUBBLE_OVERLAY_CLASS = 'bubble-overlay';
+    var BUBBLE_NODE_CLASS = 'node';
+    var BUBBLE_CLASS = 'bubble';
+
+    /**
+     * **mandatory**
+     *
+     * Set the underlying svg image element. Unlike other dc charts this chart will not generate a svg
+     * element; therefore the bubble overlay chart will not work if this function is not invoked. If the
+     * underlying image is a bitmap, then an empty svg will need to be created on top of the image.
+     * @method svg
+     * @memberof dc.bubbleOverlay
+     * @instance
+     * @example
+     * // set up underlying svg element
+     * chart.svg(d3.select('#chart svg'));
+     * @param {SVGElement|d3.selection} [imageElement]
+     * @return {dc.bubbleOverlay}
+     */
+    var _chart = dc.bubbleMixin(dc.baseMixin({}));
+    var _g;
+    var _points = [];
+
+    _chart.transitionDuration(750);
+
+    _chart.radiusValueAccessor(function (d) {
+        return d.value;
+    });
+
+    /**
+     * **mandatory**
+     *
+     * Set up a data point on the overlay. The name of a data point should match a specific 'key' among
+     * data groups generated using keyAccessor.  If a match is found (point name <-> data group key)
+     * then a bubble will be generated at the position specified by the function. x and y
+     * value specified here are relative to the underlying svg.
+     * @method point
+     * @memberof dc.bubbleOverlay
+     * @instance
+     * @param {String} name
+     * @param {Number} x
+     * @param {Number} y
+     * @return {dc.bubbleOverlay}
+     */
+    _chart.point = function (name, x, y) {
+        _points.push({name: name, x: x, y: y});
+        return _chart;
+    };
+
+    _chart._doRender = function () {
+        _g = initOverlayG();
+
+        _chart.r().range([_chart.MIN_RADIUS, _chart.width() * _chart.maxBubbleRelativeSize()]);
+
+        initializeBubbles();
+
+        _chart.fadeDeselectedArea();
+
+        return _chart;
+    };
+
+    function initOverlayG () {
+        _g = _chart.select('g.' + BUBBLE_OVERLAY_CLASS);
+        if (_g.empty()) {
+            _g = _chart.svg().append('g').attr('class', BUBBLE_OVERLAY_CLASS);
+        }
+        return _g;
+    }
+
+    function initializeBubbles () {
+        var data = mapData();
+
+        _points.forEach(function (point) {
+            var nodeG = getNodeG(point, data);
+
+            var circle = nodeG.select('circle.' + BUBBLE_CLASS);
+
+            if (circle.empty()) {
+                circle = nodeG.append('circle')
+                    .attr('class', BUBBLE_CLASS)
+                    .attr('r', 0)
+                    .attr('fill', _chart.getColor)
+                    .on('click', _chart.onClick);
+            }
+
+            dc.transition(circle, _chart.transitionDuration())
+                .attr('r', function (d) {
+                    return _chart.bubbleR(d);
+                });
+
+            _chart._doRenderLabel(nodeG);
+
+            _chart._doRenderTitles(nodeG);
+        });
+    }
+
+    function mapData () {
+        var data = {};
+        _chart.data().forEach(function (datum) {
+            data[_chart.keyAccessor()(datum)] = datum;
+        });
+        return data;
+    }
+
+    function getNodeG (point, data) {
+        var bubbleNodeClass = BUBBLE_NODE_CLASS + ' ' + dc.utils.nameToId(point.name);
+
+        var nodeG = _g.select('g.' + dc.utils.nameToId(point.name));
+
+        if (nodeG.empty()) {
+            nodeG = _g.append('g')
+                .attr('class', bubbleNodeClass)
+                .attr('transform', 'translate(' + point.x + ',' + point.y + ')');
+        }
+
+        nodeG.datum(data[point.name]);
+
+        return nodeG;
+    }
+
+    _chart._doRedraw = function () {
+        updateBubbles();
+
+        _chart.fadeDeselectedArea();
+
+        return _chart;
+    };
+
+    function updateBubbles () {
+        var data = mapData();
+
+        _points.forEach(function (point) {
+            var nodeG = getNodeG(point, data);
+
+            var circle = nodeG.select('circle.' + BUBBLE_CLASS);
+
+            dc.transition(circle, _chart.transitionDuration())
+                .attr('r', function (d) {
+                    return _chart.bubbleR(d);
+                })
+                .attr('fill', _chart.getColor);
+
+            _chart.doUpdateLabels(nodeG);
+
+            _chart.doUpdateTitles(nodeG);
+        });
+    }
+
+    _chart.debug = function (flag) {
+        if (flag) {
+            var debugG = _chart.select('g.' + dc.constants.DEBUG_GROUP_CLASS);
+
+            if (debugG.empty()) {
+                debugG = _chart.svg()
+                    .append('g')
+                    .attr('class', dc.constants.DEBUG_GROUP_CLASS);
+            }
+
+            var debugText = debugG.append('text')
+                .attr('x', 10)
+                .attr('y', 20);
+
+            debugG
+                .append('rect')
+                .attr('width', _chart.width())
+                .attr('height', _chart.height())
+                .on('mousemove', function () {
+                    var position = d3.mouse(debugG.node());
+                    var msg = position[0] + ', ' + position[1];
+                    debugText.text(msg);
+                });
+        } else {
+            _chart.selectAll('.debug').remove();
+        }
+
+        return _chart;
+    };
+
+    _chart.anchor(parent, chartGroup);
+
+    return _chart;
+};

data/node_modules/dc/src/cap-mixin.js

@@ -0,0 +1,151 @@
+/**
+ * Cap is a mixin that groups small data elements below a _cap_ into an *others* grouping for both the
+ * Row and Pie Charts.
+ *
+ * The top ordered elements in the group up to the cap amount will be kept in the chart, and the rest
+ * will be replaced with an *others* element, with value equal to the sum of the replaced values. The
+ * keys of the elements below the cap limit are recorded in order to filter by those keys when the
+ * others* element is clicked.
+ * @name capMixin
+ * @memberof dc
+ * @mixin
+ * @param {Object} _chart
+ * @return {dc.capMixin}
+ */
+dc.capMixin = function (_chart) {
+
+    var _cap = Infinity;
+
+    var _othersLabel = 'Others';
+
+    var _othersGrouper = function (topRows) {
+        var topRowsSum = d3.sum(topRows, _chart.valueAccessor()),
+            allRows = _chart.group().all(),
+            allRowsSum = d3.sum(allRows, _chart.valueAccessor()),
+            topKeys = topRows.map(_chart.keyAccessor()),
+            allKeys = allRows.map(_chart.keyAccessor()),
+            topSet = d3.set(topKeys),
+            others = allKeys.filter(function (d) {return !topSet.has(d);});
+        if (allRowsSum > topRowsSum) {
+            return topRows.concat([{'others': others, 'key': _othersLabel, 'value': allRowsSum - topRowsSum}]);
+        }
+        return topRows;
+    };
+
+    _chart.cappedKeyAccessor = function (d, i) {
+        if (d.others) {
+            return d.key;
+        }
+        return _chart.keyAccessor()(d, i);
+    };
+
+    _chart.cappedValueAccessor = function (d, i) {
+        if (d.others) {
+            return d.value;
+        }
+        return _chart.valueAccessor()(d, i);
+    };
+
+    _chart.data(function (group) {
+        if (_cap === Infinity) {
+            return _chart._computeOrderedGroups(group.all());
+        } else {
+            var topRows = group.top(_cap); // ordered by crossfilter group order (default value)
+            topRows = _chart._computeOrderedGroups(topRows); // re-order using ordering (default key)
+            if (_othersGrouper) {
+                return _othersGrouper(topRows);
+            }
+            return topRows;
+        }
+    });
+
+    /**
+     * Get or set the count of elements to that will be included in the cap.
+     * @method cap
+     * @memberof dc.capMixin
+     * @instance
+     * @param {Number} [count=Infinity]
+     * @return {Number}
+     * @return {dc.capMixin}
+     */
+    _chart.cap = function (count) {
+        if (!arguments.length) {
+            return _cap;
+        }
+        _cap = count;
+        return _chart;
+    };
+
+    /**
+     * Get or set the label for *Others* slice when slices cap is specified
+     * @method othersLabel
+     * @memberof dc.capMixin
+     * @instance
+     * @param {String} [label="Others"]
+     * @return {String}
+     * @return {dc.capMixin}
+     */
+    _chart.othersLabel = function (label) {
+        if (!arguments.length) {
+            return _othersLabel;
+        }
+        _othersLabel = label;
+        return _chart;
+    };
+
+    /**
+     * Get or set the grouper function that will perform the insertion of data for the *Others* slice
+     * if the slices cap is specified. If set to a falsy value, no others will be added. By default the
+     * grouper function computes the sum of all values below the cap.
+     * @method othersGrouper
+     * @memberof dc.capMixin
+     * @instance
+     * @example
+     * // Default others grouper
+     * chart.othersGrouper(function (topRows) {
+     *    var topRowsSum = d3.sum(topRows, _chart.valueAccessor()),
+     *        allRows = _chart.group().all(),
+     *        allRowsSum = d3.sum(allRows, _chart.valueAccessor()),
+     *        topKeys = topRows.map(_chart.keyAccessor()),
+     *        allKeys = allRows.map(_chart.keyAccessor()),
+     *        topSet = d3.set(topKeys),
+     *        others = allKeys.filter(function (d) {return !topSet.has(d);});
+     *    if (allRowsSum > topRowsSum) {
+     *        return topRows.concat([{'others': others, 'key': _othersLabel, 'value': allRowsSum - topRowsSum}]);
+     *    }
+     *    return topRows;
+     * });
+     * // Custom others grouper
+     * chart.othersGrouper(function (data) {
+     *     // compute the value for others, presumably the sum of all values below the cap
+     *     var othersSum  = yourComputeOthersValueLogic(data)
+     *
+     *     // the keys are needed to properly filter when the others element is clicked
+     *     var othersKeys = yourComputeOthersKeysArrayLogic(data);
+     *
+     *     // add the others row to the dataset
+     *     data.push({'key': 'Others', 'value': othersSum, 'others': othersKeys });
+     *
+     *     return data;
+     * });
+     * @param {Function} [grouperFunction]
+     * @return {Function}
+     * @return {dc.capMixin}
+     */
+    _chart.othersGrouper = function (grouperFunction) {
+        if (!arguments.length) {
+            return _othersGrouper;
+        }
+        _othersGrouper = grouperFunction;
+        return _chart;
+    };
+
+    dc.override(_chart, 'onClick', function (d) {
+        if (d.others) {
+            _chart.filter([d.others]);
+        }
+        _chart._onClick(d);
+    });
+
+    return _chart;
+};

data/node_modules/dc/src/color-mixin.js

@@ -0,0 +1,172 @@
+/**
+ * The Color Mixin is an abstract chart functional class providing universal coloring support
+ * as a mix-in for any concrete chart implementation.
+ * @name colorMixin
+ * @memberof dc
+ * @mixin
+ * @param {Object} _chart
+ * @return {dc.colorMixin}
+ */
+dc.colorMixin = function (_chart) {
+    var _colors = d3.scale.category20c();
+    var _defaultAccessor = true;
+
+    var _colorAccessor = function (d) { return _chart.keyAccessor()(d); };
+
+    /**
+     * Retrieve current color scale or set a new color scale. This methods accepts any function that
+     * operates like a d3 scale.
+     * @method colors
+     * @memberof dc.colorMixin
+     * @instance
+     * @see {@link http://github.com/mbostock/d3/wiki/Scales d3.scale}
+     * @example
+     * // alternate categorical scale
+     * chart.colors(d3.scale.category20b());
+     * // ordinal scale
+     * chart.colors(d3.scale.ordinal().range(['red','green','blue']));
+     * // convenience method, the same as above
+     * chart.ordinalColors(['red','green','blue']);
+     * // set a linear scale
+     * chart.linearColors(["#4575b4", "#ffffbf", "#a50026"]);
+     * @param {d3.scale} [colorScale=d3.scale.category20c()]
+     * @return {d3.scale}
+     * @return {dc.colorMixin}
+     */
+    _chart.colors = function (colorScale) {
+        if (!arguments.length) {
+            return _colors;
+        }
+        if (colorScale instanceof Array) {
+            _colors = d3.scale.quantize().range(colorScale); // deprecated legacy support, note: this fails for ordinal domains
+        } else {
+            _colors = d3.functor(colorScale);
+        }
+        return _chart;
+    };
+
+    /**
+     * Convenience method to set the color scale to
+     * {@link https://github.com/mbostock/d3/wiki/Ordinal-Scales#ordinal d3.scale.ordinal} with
+     * range `r`.
+     * @method ordinalColors
+     * @memberof dc.colorMixin
+     * @instance
+     * @param {Array<String>} r
+     * @return {dc.colorMixin}
+     */
+    _chart.ordinalColors = function (r) {
+        return _chart.colors(d3.scale.ordinal().range(r));
+    };
+
+    /**
+     * Convenience method to set the color scale to an Hcl interpolated linear scale with range `r`.
+     * @method linearColors
+     * @memberof dc.colorMixin
+     * @instance
+     * @param {Array<Number>} r
+     * @return {dc.colorMixin}
+     */
+    _chart.linearColors = function (r) {
+        return _chart.colors(d3.scale.linear()
+                             .range(r)
+                             .interpolate(d3.interpolateHcl));
+    };
+
+    /**
+     * Set or the get color accessor function. This function will be used to map a data point in a
+     * crossfilter group to a color value on the color scale. The default function uses the key
+     * accessor.
+     * @method colorAccessor
+     * @memberof dc.colorMixin
+     * @instance
+     * @example
+     * // default index based color accessor
+     * .colorAccessor(function (d, i){return i;})
+     * // color accessor for a multi-value crossfilter reduction
+     * .colorAccessor(function (d){return d.value.absGain;})
+     * @param {Function} [colorAccessor]
+     * @return {Function}
+     * @return {dc.colorMixin}
+     */
+    _chart.colorAccessor = function (colorAccessor) {
+        if (!arguments.length) {
+            return _colorAccessor;
+        }
+        _colorAccessor = colorAccessor;
+        _defaultAccessor = false;
+        return _chart;
+    };
+
+    // what is this?
+    _chart.defaultColorAccessor = function () {
+        return _defaultAccessor;
+    };
+
+    /**
+     * Set or get the current domain for the color mapping function. The domain must be supplied as an
+     * array.
+     *
+     * Note: previously this method accepted a callback function. Instead you may use a custom scale
+     * set by {@link dc.colorMixin#colors .colors}.
+     * @method colorDomain
+     * @memberof dc.colorMixin
+     * @instance
+     * @param {Array<String>} [domain]
+     * @return {Array<String>}
+     * @return {dc.colorMixin}
+     */
+    _chart.colorDomain = function (domain) {
+        if (!arguments.length) {
+            return _colors.domain();
+        }
+        _colors.domain(domain);
+        return _chart;
+    };
+
+    /**
+     * Set the domain by determining the min and max values as retrieved by
+     * {@link dc.colorMixin#colorAccessor .colorAccessor} over the chart's dataset.
+     * @method calculateColorDomain
+     * @memberof dc.colorMixin
+     * @instance
+     * @return {dc.colorMixin}
+     */
+    _chart.calculateColorDomain = function () {
+        var newDomain = [d3.min(_chart.data(), _chart.colorAccessor()),
+                         d3.max(_chart.data(), _chart.colorAccessor())];
+        _colors.domain(newDomain);
+        return _chart;
+    };
+
+    /**
+     * Get the color for the datum d and counter i. This is used internally by charts to retrieve a color.
+     * @method getColor
+     * @memberof dc.colorMixin
+     * @instance
+     * @param {*} d
+     * @param {Number} [i]
+     * @return {String}
+     */
+    _chart.getColor = function (d, i) {
+        return _colors(_colorAccessor.call(this, d, i));
+    };
+
+    /**
+     * Get the color for the datum d and counter i. This is used internally by charts to retrieve a color.
+     * @method colorCalculator
+     * @memberof dc.colorMixin
+     * @instance
+     * @param {*} [colorCalculator]
+     * @return {*}
+     */
+    _chart.colorCalculator = function (colorCalculator) {
+        if (!arguments.length) {
+            return _chart.getColor;
+        }
+        _chart.getColor = colorCalculator;
+        return _chart;
+    };
+
+    return _chart;
+};