This is an automated email from the ASF dual-hosted git repository. sushuang pushed a commit to branch next in repository https://gitbox.apache.org/repos/asf/incubator-echarts-examples.git
commit e2cf1068c84faf72dfd828a9c35672a3cc1d4feb Author: 100pah <sushuang0...@gmail.com> AuthorDate: Thu Nov 19 19:48:46 2020 +0800 example: aggregate --- public/data/asset/js/myTransform.js | 697 +++++++++++++++++++++----------- public/data/data-transform-aggregate.js | 80 ++++ 2 files changed, 543 insertions(+), 234 deletions(-) diff --git a/public/data/asset/js/myTransform.js b/public/data/asset/js/myTransform.js index 1d72b52..a2f97b5 100644 --- a/public/data/asset/js/myTransform.js +++ b/public/data/asset/js/myTransform.js @@ -1,247 +1,476 @@ -/* -* Licensed to the Apache Software Foundation (ASF) under one -* or more contributor license agreements. See the NOTICE file -* distributed with this work for additional information -* regarding copyright ownership. The ASF licenses this file -* to you under the Apache License, Version 2.0 (the -* "License"); you may not use this file except in compliance -* with the License. You may obtain a copy of the License at -* -* http://www.apache.org/licenses/LICENSE-2.0 -* -* Unless required by applicable law or agreed to in writing, -* software distributed under the License is distributed on an -* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY -* KIND, either express or implied. See the License for the -* specific language governing permissions and limitations -* under the License. -*/ - -(function (exports) { - - /** - * @usage - * - * ```js - * dataset: [{ - * source: [ - * ['aa', 'bb', 'cc', 'tag'], - * [12, 0.33, 5200, 'AA'], - * [21, 0.65, 7100, 'AA'], - * [51, 0.15, 1100, 'BB'], - * [71, 0.75, 9100, 'BB'], - * ... - * ] - * }, { - * transform: { - * type: 'my:aggregate', - * config: { - * resultDimensions: [ - * // by default, use the same name with `from`. - * { from: 'aa', method: 'sum' }, - * { from: 'bb', method: 'count' }, - * { from: 'cc' }, // method by default: use the first value. - * { from: 'tag' } - * ], - * groupBy: 'tag' - * } - * } - * // Then the result data will be: - * // [ - * // ['aa', 'bb', 'cc', 'tag'], - * // [12, 0.33, 5200, 'AA'], - * // [21, 0.65, 8100, 'BB'], - * // ... - * // ] - * }] - * ``` - */ - var transform = { - - type: 'myTransform:aggregate', - - /** - * @param params - * @param params.config.resultDimensions Mandatory. - * { - * // Optional. The name of the result dimensions. - * // If not provided, inherit the name from `from`. - * name: DimensionName; - * // Mandatory. `from` is used to reference dimension from `source`. - * from: DimensionIndex | DimensionName; - * // Optional. Aggregate method. Currently only these method supported. - * // If not provided, use `'first'`. - * method: 'sum' | 'count' | 'first'; - * }[] - * @param params.config.groupBy DimensionIndex | DimensionName Optional. - */ - transform: function (params) { - var upstream = params.upstream; - var config = params.config; - var resultDimensionsConfig = config.resultDimensions; - - var resultDimInfoList = []; - var resultDimensions = []; - for (var i = 0; i < resultDimensionsConfig.length; i++) { - var resultDimInfoConfig = resultDimensionsConfig[i]; - var resultDimInfo = upstream.getDimensionInfo(resultDimInfoConfig.from); - assert(resultDimInfo, 'Can not find dimension by `from`: ' + resultDimInfoConfig.from); - resultDimInfo.method = resultDimInfoConfig.method; - resultDimInfoList.push(resultDimInfo); - if (resultDimInfoConfig.name != null) { - resultDimInfo.name = resultDimInfoConfig.name; - } - resultDimensions.push(resultDimInfo.name); - } - - var resultData = []; - - var groupBy = config.groupBy; - var groupByDimInfo; - if (groupBy != null) { - var groupMap = {}; - groupByDimInfo = upstream.getDimensionInfo(groupBy); - assert(groupByDimInfo, 'Can not find dimension by `groupBy`: ' + groupBy); - - for (var dataIndex = 0, len = upstream.count(); dataIndex < len; dataIndex++) { - var groupByVal = upstream.retrieveValue(dataIndex, groupByDimInfo.index); - - if (!groupMap.hasOwnProperty(groupByVal)) { - var newLine = createLine(upstream, dataIndex, resultDimInfoList, groupByDimInfo, groupByVal); - resultData.push(newLine); - groupMap[groupByVal] = newLine; - } - else { - var targetLine = groupMap[groupByVal]; - aggregateLine(upstream, dataIndex, targetLine, resultDimInfoList, groupByDimInfo); - } - } - } - else { - var targetLine = createLine(upstream, 0, resultDimInfoList); - resultData.push(targetLine); - for (var dataIndex = 0, len = upstream.count(); dataIndex < len; dataIndex++) { - aggregateLine(upstream, dataIndex, targetLine, resultDimInfoList); - } - } - - return { - dimensions: resultDimensions, - data: resultData - }; +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'], factory) : (global = global || self, factory(global.myTransform = {})); +})(this, function (exports) { + 'use strict'; + + var transform = { + type: 'myTransform:id', + transform: function (params) { + var upstream = params.upstream; + var config = params.config; + var dimensionIndex = config.dimensionIndex; + var dimensionName = config.dimensionName; + var dimsDef = upstream.cloneAllDimensionInfo(); + dimsDef[dimensionIndex] = dimensionName; + var data = upstream.cloneRawData(); + + for (var i = 0, len = data.length; i < len; i++) { + var line = data[i]; + line[dimensionIndex] = i; + } + + return { + dimensions: dimsDef, + data: data + }; + } + }; + var arrayProto = Array.prototype; + var nativeForEach = arrayProto.forEach; + var nativeSlice = arrayProto.slice; + var nativeMap = arrayProto.map; + + var ctorFunction = function () {}.constructor; + + var protoFunction = ctorFunction ? ctorFunction.prototype : null; + + function each(arr, cb, context) { + if (!(arr && cb)) { + return; + } + + if (arr.forEach && arr.forEach === nativeForEach) { + arr.forEach(cb, context); + } else if (arr.length === +arr.length) { + for (var i = 0, len = arr.length; i < len; i++) { + cb.call(context, arr[i], i, arr); + } + } else { + for (var key in arr) { + if (arr.hasOwnProperty(key)) { + cb.call(context, arr[key], key, arr); } + } + } + } + + function map(arr, cb, context) { + if (!arr) { + return []; + } + + if (!cb) { + return slice(arr); + } + + if (arr.map && arr.map === nativeMap) { + return arr.map(cb, context); + } else { + var result = []; + + for (var i = 0, len = arr.length; i < len; i++) { + result.push(cb.call(context, arr[i], i, arr)); + } + + return result; + } + } + + function bindPolyfill(func, context) { + var args = []; + + for (var _i = 2; _i < arguments.length; _i++) { + args[_i - 2] = arguments[_i]; + } + + return function () { + return func.apply(context, args.concat(nativeSlice.call(arguments))); }; + } - function createLine(upstream, dataIndex, resultDimInfoList, groupByDimInfo, groupByVal) { - var newLine = []; - for (var j = 0; j < resultDimInfoList.length; j++) { - var resultDimInfo = resultDimInfoList[j]; - var method = resultDimInfo.method; - newLine[j] = (groupByDimInfo && resultDimInfo.index === groupByDimInfo.index) - ? groupByVal - : (method === 'sum' || method === 'count') - ? 0 - // By default, method: 'first' - : upstream.retrieveValue(dataIndex, resultDimInfo.index); - } - return newLine; - } - - function aggregateLine(upstream, dataIndex, targetLine, resultDimInfoList, groupByDimInfo) { - for (var j = 0; j < resultDimInfoList.length; j++) { - var resultDimInfo = resultDimInfoList[j]; - var method = resultDimInfo.method; - if (!groupByDimInfo || resultDimInfo.index !== groupByDimInfo.index) { - if (method === 'sum') { - targetLine[j] += upstream.retrieveValue(dataIndex, resultDimInfo.index); - } - else if (method === 'count') { - targetLine[j] += 1; - } - } + var bind = protoFunction && isFunction(protoFunction.bind) ? protoFunction.call.bind(protoFunction.bind) : bindPolyfill; + + function isFunction(value) { + return typeof value === 'function'; + } + + function slice(arr) { + var args = []; + + for (var _i = 1; _i < arguments.length; _i++) { + args[_i - 1] = arguments[_i]; + } + + return nativeSlice.apply(arr, args); + } + + function assert(condition, message) { + if (!condition) { + throw new Error(message); + } + } + + function hasOwn(own, prop) { + return own.hasOwnProperty(prop); + } + + function quantile(ascArr, p) { + var H = (ascArr.length - 1) * p + 1; + var h = Math.floor(H); + var v = +ascArr[h - 1]; + var e = H - h; + return e ? v + e * (ascArr[h] - v) : v; + } + + var METHOD_INTERNAL = { + 'SUM': true, + 'COUNT': true, + 'FIRST': true, + 'AVERAGE': true, + 'Q1': true, + 'Q2': true, + 'Q3': true, + 'MIN': true, + 'MAX': true + }; + var METHOD_NEEDS_COLLECT = { + AVERAGE: ['COUNT'] + }; + var METHOD_NEEDS_GATHER_VALUES = { + Q1: true, + Q2: true, + Q3: true + }; + var METHOD_ALIAS = { + MEDIAN: 'Q2' + }; + + var ResultDimInfoInternal = function () { + function ResultDimInfoInternal(index, indexInUpstream, method, name, needGatherValues) { + this.collectionInfoList = []; + this.gatheredValuesByGroup = {}; + this.gatheredValuesNoGroup = []; + this.needGatherValues = false; + this._collectionInfoMap = {}; + this.method = method; + this.name = name; + this.index = index; + this.indexInUpstream = indexInUpstream; + this.needGatherValues = needGatherValues; + } + + ResultDimInfoInternal.prototype.addCollectionInfo = function (item) { + this._collectionInfoMap[item.method] = this.collectionInfoList.length; + this.collectionInfoList.push(item); + }; + + ResultDimInfoInternal.prototype.getCollectionInfo = function (method) { + return this.collectionInfoList[this._collectionInfoMap[method]]; + }; + + ResultDimInfoInternal.prototype.gatherValue = function (groupByDimInfo, groupVal, value) { + value = +value; + + if (groupByDimInfo) { + if (groupVal != null) { + var groupValStr = groupVal + ''; + var values = this.gatheredValuesByGroup[groupValStr] || (this.gatheredValuesByGroup[groupValStr] = []); + values.push(value); } + } else { + this.gatheredValuesNoGroup.push(value); + } + }; + + return ResultDimInfoInternal; + }(); + + var transform$1 = { + type: 'myTransform:aggregate', + transform: function (params) { + var upstream = params.upstream; + var config = params.config; + var groupByDimInfo = prepareGroupByDimInfo(config, upstream); + + var _a = prepareDimensions(config, upstream, groupByDimInfo), + finalResultDimInfoList = _a.finalResultDimInfoList, + collectionDimInfoList = _a.collectionDimInfoList; + + var collectionResult; + + if (collectionDimInfoList.length) { + collectionResult = travel(groupByDimInfo, upstream, collectionDimInfoList, createCollectionResultLine, updateCollectionResultLine); + } + + each(collectionDimInfoList, function (dimInfo) { + dimInfo.__collectionResult = collectionResult; + asc(dimInfo.gatheredValuesNoGroup); + each(dimInfo.gatheredValuesByGroup, function (values) { + asc(values); + }); + }); + var finalResult = travel(groupByDimInfo, upstream, finalResultDimInfoList, createFinalResultLine, updateFinalResultLine); + return { + dimensions: map(finalResultDimInfoList, function (item) { + return item.name; + }), + data: finalResult.outList + }; } + }; + + function prepareDimensions(config, upstream, groupByDimInfo) { + var resultDimensionsConfig = config.resultDimensions; + var finalResultDimInfoList = []; + var collectionDimInfoList = []; + var gIndexInLine = 0; + + for (var i = 0; i < resultDimensionsConfig.length; i++) { + var resultDimInfoConfig = resultDimensionsConfig[i]; + var dimInfoInUpstream = upstream.getDimensionInfo(resultDimInfoConfig.from); + assert(dimInfoInUpstream, 'Can not find dimension by `from`: ' + resultDimInfoConfig.from); + var rawMethod = resultDimInfoConfig.method; + assert(groupByDimInfo.index !== dimInfoInUpstream.index || rawMethod == null, "Dimension " + dimInfoInUpstream.name + " is the \"groupBy\" dimension, must not have any \"method\"."); + var method = normalizeMethod(rawMethod); + assert(method, 'method is required'); + var name_1 = resultDimInfoConfig.name != null ? resultDimInfoConfig.name : dimInfoInUpstream.name; + var finalResultDimInfo = new ResultDimInfoInternal(finalResultDimInfoList.length, dimInfoInUpstream.index, method, name_1, hasOwn(METHOD_NEEDS_GATHER_VALUES, method)); + finalResultDimInfoList.push(finalResultDimInfo); + var needCollect = false; - function assert(cond, msg) { - if (!cond) { - throw new Error(msg || 'transition player error'); + if (hasOwn(METHOD_NEEDS_COLLECT, method)) { + needCollect = true; + var collectionTargetMethods = METHOD_NEEDS_COLLECT[method]; + + for (var j = 0; j < collectionTargetMethods.length; j++) { + finalResultDimInfo.addCollectionInfo({ + method: collectionTargetMethods[j], + indexInLine: gIndexInLine++ + }); } + } + + if (hasOwn(METHOD_NEEDS_GATHER_VALUES, method)) { + needCollect = true; + } + + if (needCollect) { + collectionDimInfoList.push(finalResultDimInfo); + } } - var myTransform = exports.myTransform = exports.myTransform || {}; - myTransform.aggregate = transform; - -})(this); - - - - - -(function (exports) { - - /** - * @usage - * - * ```js - * dataset: [{ - * source: [ - * ['aa', 'bb', 'cc', 'tag'], - * [12, 0.33, 5200, 'AA'], - * [21, 0.65, 8100, 'AA'], - * ... - * ] - * }, { - * transform: { - * type: 'my:id', - * config: { - * dimensionIndex: 4, - * dimensionName: 'ID' - * } - * } - * // Then the result data will be: - * // [ - * // ['aa', 'bb', 'cc', 'tag', 'ID'], - * // [12, 0.33, 5200, 'AA', 0], - * // [21, 0.65, 8100, 'BB', 1], - * // ... - * // ] - * }] - * ``` - */ - var transform = { - - type: 'myTransform:id', - - /** - * @param params.config.dimensionIndex DimensionIndex - * Mandatory. Specify where to put the new id dimension. - * @param params.config.dimensionName DimensionName - * Optional. If not provided, left the dimension name not defined. - */ - transform: function (params) { - var upstream = params.upstream; - var config = params.config; - var dimensionIndex = config.dimensionIndex; - var dimensionName = config.dimensionName; - - var dimsDef = upstream.cloneAllDimensionInfo(); - dimsDef[dimensionIndex] = dimensionName; - - var data = upstream.cloneRawData(); - - for (var i = 0, len = data.length; i < len; i++) { - var line = data[i]; - line[dimensionIndex] = i; - } - - return { - dimensions: dimsDef, - data: upstream.data - }; + return { + collectionDimInfoList: collectionDimInfoList, + finalResultDimInfoList: finalResultDimInfoList + }; + } + + function prepareGroupByDimInfo(config, upstream) { + var groupByConfig = config.groupBy; + var groupByDimInfo; + + if (groupByConfig != null) { + groupByDimInfo = upstream.getDimensionInfo(groupByConfig); + assert(groupByDimInfo, 'Can not find dimension by `groupBy`: ' + groupByConfig); + } + + return groupByDimInfo; + } + + function travel(groupByDimInfo, upstream, resultDimInfoList, doCreate, doUpdate) { + var outList = []; + var mapByGroup; + + if (groupByDimInfo) { + mapByGroup = {}; + + for (var dataIndex = 0, len = upstream.count(); dataIndex < len; dataIndex++) { + var groupByVal = upstream.retrieveValue(dataIndex, groupByDimInfo.index); + + if (groupByVal == null) { + continue; + } + + var groupByValStr = groupByVal + ''; + + if (!hasOwn(mapByGroup, groupByValStr)) { + var newLine = doCreate(upstream, dataIndex, resultDimInfoList, groupByDimInfo, groupByVal); + outList.push(newLine); + mapByGroup[groupByValStr] = newLine; + } else { + var targetLine = mapByGroup[groupByValStr]; + doUpdate(upstream, dataIndex, targetLine, resultDimInfoList, groupByDimInfo, groupByVal); } + } + } else { + var targetLine = doCreate(upstream, 0, resultDimInfoList); + outList.push(targetLine); + + for (var dataIndex = 1, len = upstream.count(); dataIndex < len; dataIndex++) { + doUpdate(upstream, dataIndex, targetLine, resultDimInfoList); + } + } + + return { + mapByGroup: mapByGroup, + outList: outList }; + } + + function normalizeMethod(method) { + if (method == null) { + return 'FIRST'; + } + + var methodInternal = method.toUpperCase(); + methodInternal = hasOwn(METHOD_ALIAS, methodInternal) ? METHOD_ALIAS[methodInternal] : methodInternal; + assert(hasOwn(METHOD_INTERNAL, methodInternal), "Illegal method " + method + "."); + return methodInternal; + } + + var createCollectionResultLine = function (upstream, dataIndex, collectionDimInfoList, groupByDimInfo, groupByVal) { + var newLine = []; + + for (var i = 0; i < collectionDimInfoList.length; i++) { + var dimInfo = collectionDimInfoList[i]; + var collectionInfoList = dimInfo.collectionInfoList; + + for (var j = 0; j < collectionInfoList.length; j++) { + var collectionInfo = collectionInfoList[j]; + newLine[collectionInfo.indexInLine] = +lineCreator[collectionInfo.method](upstream, dataIndex, dimInfo, groupByDimInfo, groupByVal); + } + + if (dimInfo.needGatherValues) { + var val = upstream.retrieveValue(dataIndex, dimInfo.indexInUpstream); + dimInfo.gatherValue(groupByDimInfo, groupByVal, val); + } + } + + return newLine; + }; + + var updateCollectionResultLine = function (upstream, dataIndex, targetLine, collectionDimInfoList, groupByDimInfo, groupByVal) { + for (var i = 0; i < collectionDimInfoList.length; i++) { + var dimInfo = collectionDimInfoList[i]; + var collectionInfoList = dimInfo.collectionInfoList; + + for (var j = 0; j < collectionInfoList.length; j++) { + var collectionInfo = collectionInfoList[j]; + var indexInLine = collectionInfo.indexInLine; + targetLine[indexInLine] = +lineUpdater[collectionInfo.method](targetLine[indexInLine], upstream, dataIndex, dimInfo, groupByDimInfo, groupByVal); + } + + if (dimInfo.needGatherValues) { + var val = upstream.retrieveValue(dataIndex, dimInfo.indexInUpstream); + dimInfo.gatherValue(groupByDimInfo, groupByVal, val); + } + } + }; + + var createFinalResultLine = function (upstream, dataIndex, finalResultDimInfoList, groupByDimInfo, groupByVal) { + var newLine = []; + + for (var i = 0; i < finalResultDimInfoList.length; i++) { + var dimInfo = finalResultDimInfoList[i]; + var method = dimInfo.method; + newLine[i] = isGroupByDimension(groupByDimInfo, dimInfo) ? groupByVal : lineCreator[method](upstream, dataIndex, dimInfo, groupByDimInfo, groupByVal); + } + + return newLine; + }; + + var updateFinalResultLine = function (upstream, dataIndex, targetLine, finalResultDimInfoList, groupByDimInfo, groupByVal) { + for (var i = 0; i < finalResultDimInfoList.length; i++) { + var dimInfo = finalResultDimInfoList[i]; + + if (isGroupByDimension(groupByDimInfo, dimInfo)) { + continue; + } + + var method = dimInfo.method; + targetLine[i] = lineUpdater[method](targetLine[i], upstream, dataIndex, dimInfo, groupByDimInfo, groupByVal); + } + }; + + function isGroupByDimension(groupByDimInfo, targetDimInfo) { + return groupByDimInfo && targetDimInfo.indexInUpstream === groupByDimInfo.index; + } + + function asc(list) { + list.sort(function (a, b) { + return a - b; + }); + } + + var lineCreator = { + 'SUM': function () { + return 0; + }, + 'COUNT': function () { + return 1; + }, + 'FIRST': function (upstream, dataIndex, dimInfo) { + return upstream.retrieveValue(dataIndex, dimInfo.indexInUpstream); + }, + 'MIN': function (upstream, dataIndex, dimInfo) { + return upstream.retrieveValue(dataIndex, dimInfo.indexInUpstream); + }, + 'MAX': function (upstream, dataIndex, dimInfo) { + return upstream.retrieveValue(dataIndex, dimInfo.indexInUpstream); + }, + 'AVERAGE': function (upstream, dataIndex, dimInfo, groupByDimInfo, groupByVal) { + var collectLine = groupByDimInfo ? dimInfo.__collectionResult.mapByGroup[groupByVal + ''] : dimInfo.__collectionResult.outList[0]; + return upstream.retrieveValue(dataIndex, dimInfo.indexInUpstream) / collectLine[dimInfo.getCollectionInfo('COUNT').indexInLine]; + }, + 'Q1': function (upstream, dataIndex, dimInfo, groupByDimInfo, groupByVal) { + return lineCreatorForQ(0.25, dimInfo, groupByDimInfo, groupByVal); + }, + 'Q2': function (upstream, dataIndex, dimInfo, groupByDimInfo, groupByVal) { + return lineCreatorForQ(0.5, dimInfo, groupByDimInfo, groupByVal); + }, + 'Q3': function (upstream, dataIndex, dimInfo, groupByDimInfo, groupByVal) { + return lineCreatorForQ(0.75, dimInfo, groupByDimInfo, groupByVal); + } + }; + var lineUpdater = { + 'SUM': function (val, upstream, dataIndex, dimInfo) { + return val + upstream.retrieveValue(dataIndex, dimInfo.indexInUpstream); + }, + 'COUNT': function (val) { + return val + 1; + }, + 'FIRST': function (val) { + return val; + }, + 'MIN': function (val, upstream, dataIndex, dimInfo) { + return Math.min(val, upstream.retrieveValue(dataIndex, dimInfo.indexInUpstream)); + }, + 'MAX': function (val, upstream, dataIndex, dimInfo) { + return Math.max(val, upstream.retrieveValue(dataIndex, dimInfo.indexInUpstream)); + }, + 'AVERAGE': function (val, upstream, dataIndex, dimInfo, groupByDimInfo, groupByVal) { + var collectLine = groupByDimInfo ? dimInfo.__collectionResult.mapByGroup[groupByVal + ''] : dimInfo.__collectionResult.outList[0]; + return val + upstream.retrieveValue(dataIndex, dimInfo.indexInUpstream) / collectLine[dimInfo.getCollectionInfo('COUNT').indexInLine]; + }, + 'Q1': function (val, upstream, dataIndex, dimInfo) { + return val; + }, + 'Q2': function (val, upstream, dataIndex, dimInfo) { + return val; + }, + 'Q3': function (val, upstream, dataIndex, dimInfo) { + return val; + } + }; - var myTransform = exports.myTransform = exports.myTransform || {}; - myTransform.id = transform; + function lineCreatorForQ(percent, dimInfo, groupByDimInfo, groupByVal) { + var gatheredValues = groupByDimInfo ? dimInfo.gatheredValuesByGroup[groupByVal + ''] : dimInfo.gatheredValuesNoGroup; + return quantile(gatheredValues, percent); + } -})(this); + exports.aggregate = transform$1; + exports.id = transform; + Object.defineProperty(exports, '__esModule', { + value: true + }); +}); \ No newline at end of file diff --git a/public/data/data-transform-aggregate.js b/public/data/data-transform-aggregate.js new file mode 100644 index 0000000..4a8c467 --- /dev/null +++ b/public/data/data-transform-aggregate.js @@ -0,0 +1,80 @@ +/* +title: Data Transform Simple Aggregate +category: bar +titleCN: 简单的数据聚合 +difficulty: 3 +*/ + +$.when( + $.get(ROOT_PATH + '/data/asset/data/life-expectancy-table.json'), + $.getScript(ROOT_PATH + '/data/asset/js/myTransform.js') +).done(function (res) { + run(res[0]); +}); + +function run(_rawData) { + + echarts.registerTransform(window.myTransform.aggregate); + + option = { + dataset: [{ + id: 'raw', + source: _rawData + }, { + id: 'income_aggregate', + fromDatasetId: 'raw', + transform: [{ + type: 'filter', + config: { + dimension: 'Year', gte: 1950 + } + }, { + type: 'myTransform:aggregate', + config: { + resultDimensions: [ + { name: 'min', from: 'Income', method: 'min' }, + { name: 'Q1', from: 'Income', method: 'Q1' }, + { name: 'median', from: 'Income', method: 'median' }, + { name: 'Q3', from: 'Income', method: 'Q3' }, + { name: 'max', from: 'Income', method: 'max' }, + { name: 'Country', from: 'Country' } + ], + groupBy: 'Country' + } + }, { + type: 'sort', + config: { + dimension: 'max', + order: 'asc' + } + }] + }], + title: { + text: 'Income since 1950' + }, + tooltip: { + trigger: 'axis' + }, + xAxis: { + name: 'Income', + nameLocation: 'middle', + nameGap: 30 + }, + yAxis: { + type: 'category' + }, + series: { + type: 'boxplot', + datasetId: 'income_aggregate', + encode: { + x: ['min', 'Q1', 'median', 'Q3', 'max'], + y: 'Country', + itemName: ['Country'], + tooltip: ['min', 'Q1', 'median', 'Q3', 'max'] + } + } + }; + + myChart.setOption(option); + +} --------------------------------------------------------------------- To unsubscribe, e-mail: commits-unsubscr...@echarts.apache.org For additional commands, e-mail: commits-h...@echarts.apache.org