| (function webpackUniversalModuleDefinition(root, factory) { |
| if(typeof exports === 'object' && typeof module === 'object') |
| module.exports = factory(require("echarts")); |
| else if(typeof define === 'function' && define.amd) |
| define(["echarts"], factory); |
| else if(typeof exports === 'object') |
| exports["dataTool"] = factory(require("echarts")); |
| else |
| root["echarts"] = root["echarts"] || {}, root["echarts"]["dataTool"] = factory(root["echarts"]); |
| })(this, function(__WEBPACK_EXTERNAL_MODULE_1__) { |
| return /******/ (function(modules) { // webpackBootstrap |
| /******/ // The module cache |
| /******/ var installedModules = {}; |
| |
| /******/ // The require function |
| /******/ function __webpack_require__(moduleId) { |
| |
| /******/ // Check if module is in cache |
| /******/ if(installedModules[moduleId]) |
| /******/ return installedModules[moduleId].exports; |
| |
| /******/ // Create a new module (and put it into the cache) |
| /******/ var module = installedModules[moduleId] = { |
| /******/ exports: {}, |
| /******/ id: moduleId, |
| /******/ loaded: false |
| /******/ }; |
| |
| /******/ // Execute the module function |
| /******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); |
| |
| /******/ // Flag the module as loaded |
| /******/ module.loaded = true; |
| |
| /******/ // Return the exports of the module |
| /******/ return module.exports; |
| /******/ } |
| |
| |
| /******/ // expose the modules object (__webpack_modules__) |
| /******/ __webpack_require__.m = modules; |
| |
| /******/ // expose the module cache |
| /******/ __webpack_require__.c = installedModules; |
| |
| /******/ // __webpack_public_path__ |
| /******/ __webpack_require__.p = ""; |
| |
| /******/ // Load entry module and return exports |
| /******/ return __webpack_require__(0); |
| /******/ }) |
| /************************************************************************/ |
| /******/ ([ |
| /* 0 */ |
| /***/ (function(module, exports, __webpack_require__) { |
| |
| var __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_RESULT__ = function (require) { |
| var echarts = __webpack_require__(1); |
| echarts.dataTool = { |
| version: '1.0.0', |
| gexf: __webpack_require__(5), |
| prepareBoxplotData: __webpack_require__(6) |
| }; |
| return echarts.dataTool; |
| }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); |
| |
| /***/ }), |
| /* 1 */ |
| /***/ (function(module, exports) { |
| |
| module.exports = __WEBPACK_EXTERNAL_MODULE_1__; |
| |
| /***/ }), |
| /* 2 */, |
| /* 3 */, |
| /* 4 */, |
| /* 5 */ |
| /***/ (function(module, exports, __webpack_require__) { |
| |
| var __WEBPACK_AMD_DEFINE_RESULT__;// GEXF File Parser |
| // http://gexf.net/1.2draft/gexf-12draft-primer.pdf |
| !(__WEBPACK_AMD_DEFINE_RESULT__ = function (require) { |
| |
| 'use strict'; |
| var zrUtil = __webpack_require__(1).util; |
| |
| function parse(xml) { |
| var doc; |
| if (typeof xml === 'string') { |
| var parser = new DOMParser(); |
| doc = parser.parseFromString(xml, 'text/xml'); |
| } |
| else { |
| doc = xml; |
| } |
| if (!doc || doc.getElementsByTagName('parsererror').length) { |
| return null; |
| } |
| |
| var gexfRoot = getChildByTagName(doc, 'gexf'); |
| |
| if (!gexfRoot) { |
| return null; |
| } |
| |
| var graphRoot = getChildByTagName(gexfRoot, 'graph'); |
| |
| var attributes = parseAttributes(getChildByTagName(graphRoot, 'attributes')); |
| var attributesMap = {}; |
| for (var i = 0; i < attributes.length; i++) { |
| attributesMap[attributes[i].id] = attributes[i]; |
| } |
| |
| return { |
| nodes: parseNodes(getChildByTagName(graphRoot, 'nodes'), attributesMap), |
| links: parseEdges(getChildByTagName(graphRoot, 'edges')) |
| }; |
| } |
| |
| function parseAttributes(parent) { |
| return parent ? zrUtil.map(getChildrenByTagName(parent, 'attribute'), function (attribDom) { |
| return { |
| id: getAttr(attribDom, 'id'), |
| title: getAttr(attribDom, 'title'), |
| type: getAttr(attribDom, 'type') |
| }; |
| }) : []; |
| } |
| |
| function parseNodes(parent, attributesMap) { |
| return parent ? zrUtil.map(getChildrenByTagName(parent, 'node'), function (nodeDom) { |
| |
| var id = getAttr(nodeDom, 'id'); |
| var label = getAttr(nodeDom, 'label'); |
| |
| var node = { |
| id: id, |
| name: label, |
| itemStyle: { |
| normal: {} |
| } |
| }; |
| |
| var vizSizeDom = getChildByTagName(nodeDom, 'viz:size'); |
| var vizPosDom = getChildByTagName(nodeDom, 'viz:position'); |
| var vizColorDom = getChildByTagName(nodeDom, 'viz:color'); |
| // var vizShapeDom = getChildByTagName(nodeDom, 'viz:shape'); |
| |
| var attvaluesDom = getChildByTagName(nodeDom, 'attvalues'); |
| |
| if (vizSizeDom) { |
| node.symbolSize = parseFloat(getAttr(vizSizeDom, 'value')); |
| } |
| if (vizPosDom) { |
| node.x = parseFloat(getAttr(vizPosDom, 'x')); |
| node.y = parseFloat(getAttr(vizPosDom, 'y')); |
| // z |
| } |
| if (vizColorDom) { |
| node.itemStyle.normal.color = 'rgb(' +[ |
| getAttr(vizColorDom, 'r') | 0, |
| getAttr(vizColorDom, 'g') | 0, |
| getAttr(vizColorDom, 'b') | 0 |
| ].join(',') + ')'; |
| } |
| // if (vizShapeDom) { |
| // node.shape = getAttr(vizShapeDom, 'shape'); |
| // } |
| if (attvaluesDom) { |
| var attvalueDomList = getChildrenByTagName(attvaluesDom, 'attvalue'); |
| |
| node.attributes = {}; |
| |
| for (var j = 0; j < attvalueDomList.length; j++) { |
| var attvalueDom = attvalueDomList[j]; |
| var attId = getAttr(attvalueDom, 'for'); |
| var attValue = getAttr(attvalueDom, 'value'); |
| var attribute = attributesMap[attId]; |
| |
| if (attribute) { |
| switch (attribute.type) { |
| case 'integer': |
| case 'long': |
| attValue = parseInt(attValue, 10); |
| break; |
| case 'float': |
| case 'double': |
| attValue = parseFloat(attValue); |
| break; |
| case 'boolean': |
| attValue = attValue.toLowerCase() == 'true'; |
| break; |
| default: |
| } |
| node.attributes[attId] = attValue; |
| } |
| } |
| } |
| |
| return node; |
| }) : []; |
| } |
| |
| function parseEdges(parent) { |
| return parent ? zrUtil.map(getChildrenByTagName(parent, 'edge'), function (edgeDom) { |
| var id = getAttr(edgeDom, 'id'); |
| var label = getAttr(edgeDom, 'label'); |
| |
| var sourceId = getAttr(edgeDom, 'source'); |
| var targetId = getAttr(edgeDom, 'target'); |
| |
| var edge = { |
| id: id, |
| name: label, |
| source: sourceId, |
| target: targetId, |
| lineStyle: { |
| normal: {} |
| } |
| }; |
| |
| var lineStyle = edge.lineStyle.normal; |
| |
| var vizThicknessDom = getChildByTagName(edgeDom, 'viz:thickness'); |
| var vizColorDom = getChildByTagName(edgeDom, 'viz:color'); |
| // var vizShapeDom = getChildByTagName(edgeDom, 'viz:shape'); |
| |
| if (vizThicknessDom) { |
| lineStyle.width = parseFloat(vizThicknessDom.getAttribute('value')); |
| } |
| if (vizColorDom) { |
| lineStyle.color = 'rgb(' + [ |
| getAttr(vizColorDom, 'r') | 0, |
| getAttr(vizColorDom, 'g') | 0, |
| getAttr(vizColorDom, 'b') | 0 |
| ].join(',') + ')'; |
| } |
| // if (vizShapeDom) { |
| // edge.shape = vizShapeDom.getAttribute('shape'); |
| // } |
| |
| return edge; |
| }) : []; |
| } |
| |
| function getAttr(el, attrName) { |
| return el.getAttribute(attrName); |
| } |
| |
| function getChildByTagName (parent, tagName) { |
| var node = parent.firstChild; |
| |
| while (node) { |
| if ( |
| node.nodeType != 1 || |
| node.nodeName.toLowerCase() != tagName.toLowerCase() |
| ) { |
| node = node.nextSibling; |
| } else { |
| return node; |
| } |
| } |
| |
| return null; |
| } |
| |
| function getChildrenByTagName (parent, tagName) { |
| var node = parent.firstChild; |
| var children = []; |
| while (node) { |
| if (node.nodeName.toLowerCase() == tagName.toLowerCase()) { |
| children.push(node); |
| } |
| node = node.nextSibling; |
| } |
| |
| return children; |
| } |
| |
| return { |
| parse: parse |
| }; |
| }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); |
| |
| /***/ }), |
| /* 6 */ |
| /***/ (function(module, exports, __webpack_require__) { |
| |
| var __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_RESULT__ = function (require) { |
| |
| var quantile = __webpack_require__(7); |
| var numberUtil = __webpack_require__(1).number; |
| |
| /** |
| * Helper method for preparing data. |
| * @param {Array.<number>} rawData like |
| * [ |
| * [12,232,443], (raw data set for the first box) |
| * [3843,5545,1232], (raw datat set for the second box) |
| * ... |
| * ] |
| * @param {Object} [opt] |
| * |
| * @param {(number|string)} [opt.boundIQR=1.5] Data less than min bound is outlier. |
| * default 1.5, means Q1 - 1.5 * (Q3 - Q1). |
| * If pass 'none', min bound will not be used. |
| * @param {(number|string)} [opt.layout='horizontal'] |
| * Box plot layout, can be 'horizontal' or 'vertical' |
| */ |
| return function (rawData, opt) { |
| opt = opt || []; |
| var boxData = []; |
| var outliers = []; |
| var axisData = []; |
| var boundIQR = opt.boundIQR; |
| |
| for (var i = 0; i < rawData.length; i++) { |
| axisData.push(i + ''); |
| var ascList = numberUtil.asc(rawData[i].slice()); |
| |
| var Q1 = quantile(ascList, 0.25); |
| var Q2 = quantile(ascList, 0.5); |
| var Q3 = quantile(ascList, 0.75); |
| var IQR = Q3 - Q1; |
| |
| var low = boundIQR === 'none' |
| ? ascList[0] |
| : Q1 - (boundIQR == null ? 1.5 : boundIQR) * IQR; |
| var high = boundIQR === 'none' |
| ? ascList[ascList.length - 1] |
| : Q3 + (boundIQR == null ? 1.5 : boundIQR) * IQR; |
| |
| boxData.push([low, Q1, Q2, Q3, high]); |
| |
| for (var j = 0; j < ascList.length; j++) { |
| var dataItem = ascList[j]; |
| if (dataItem < low || dataItem > high) { |
| var outlier = [i, dataItem]; |
| opt.layout === 'vertical' && outlier.reverse(); |
| outliers.push(outlier); |
| } |
| } |
| } |
| return { |
| boxData: boxData, |
| outliers: outliers, |
| axisData: axisData |
| }; |
| }; |
| |
| }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); |
| |
| /***/ }), |
| /* 7 */ |
| /***/ (function(module, exports, __webpack_require__) { |
| |
| var __WEBPACK_AMD_DEFINE_RESULT__;/** |
| * Copyright (c) 2010-2015, Michael Bostock |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are met: |
| * |
| * * Redistributions of source code must retain the above copyright notice, this |
| * list of conditions and the following disclaimer. |
| * |
| * * Redistributions in binary form must reproduce the above copyright notice, |
| * this list of conditions and the following disclaimer in the documentation |
| * and/or other materials provided with the distribution. |
| * |
| * * The name Michael Bostock may not be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL MICHAEL BOSTOCK BE LIABLE FOR ANY DIRECT, |
| * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, |
| * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY |
| * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING |
| * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, |
| * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| !(__WEBPACK_AMD_DEFINE_RESULT__ = function (require) { |
| |
| /** |
| * @see <https://github.com/mbostock/d3/blob/master/src/arrays/quantile.js> |
| * @see <http://en.wikipedia.org/wiki/Quantile> |
| * @param {Array.<number>} ascArr |
| */ |
| return function(ascArr, p) { |
| var H = (ascArr.length - 1) * p + 1, |
| h = Math.floor(H), |
| v = +ascArr[h - 1], |
| e = H - h; |
| return e ? v + e * (ascArr[h] - v) : v; |
| }; |
| |
| }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); |
| |
| /***/ }) |
| /******/ ]) |
| }); |
| ; |