echarts 3.5.1 → 3.6.0

package/src/layout/barPolar.js

@@ -0,0 +1,287 @@
+define(function (require) {
+
+    'use strict';
+
+    var zrUtil = require('zrender/core/util');
+    var parsePercent = require('../util/number').parsePercent;
+
+    function getSeriesStackId(seriesModel) {
+        return seriesModel.get('stack')
+            || '__ec_stack_' + seriesModel.seriesIndex;
+    }
+
+    function getAxisKey(axis) {
+        return axis.dim;
+    }
+
+    /**
+     * @param {string} seriesType
+     * @param {module:echarts/model/Global} ecModel
+     * @param {module:echarts/ExtensionAPI} api
+     */
+    function barLayoutPolar(seriesType, ecModel, api) {
+
+        var width = api.getWidth();
+        var height = api.getHeight();
+
+        var lastStackCoords = {};
+        var lastStackCoordsOrigin = {};
+
+        var barWidthAndOffset = calRadialBar(
+            zrUtil.filter(
+                ecModel.getSeriesByType(seriesType),
+                function (seriesModel) {
+                    return !ecModel.isSeriesFiltered(seriesModel)
+                        && seriesModel.coordinateSystem
+                        && seriesModel.coordinateSystem.type === 'polar';
+                }
+            )
+        );
+
+        ecModel.eachSeriesByType(seriesType, function (seriesModel) {
+            // Check series coordinate, do layout for polar only
+            if (seriesModel.coordinateSystem.type !== 'polar') {
+                return;
+            }
+
+            var data = seriesModel.getData();
+            var polar = seriesModel.coordinateSystem;
+            var angleAxis = polar.getAngleAxis();
+            var baseAxis = polar.getBaseAxis();
+
+            var stackId = getSeriesStackId(seriesModel);
+            var columnLayoutInfo
+                = barWidthAndOffset[getAxisKey(baseAxis)][stackId];
+            var columnOffset = columnLayoutInfo.offset;
+            var columnWidth = columnLayoutInfo.width;
+            var valueAxis = polar.getOtherAxis(baseAxis);
+
+            var center = seriesModel.get('center') || ['50%', '50%'];
+            var cx = parsePercent(center[0], width);
+            var cy = parsePercent(center[1], height);
+
+            var barMinHeight = seriesModel.get('barMinHeight') || 0;
+            var barMinAngle = seriesModel.get('barMinAngle') || 0;
+
+            var valueAxisStart = valueAxis.getExtent()[0];
+            var valueMax = valueAxis.model.get('max');
+            var valueMin = valueAxis.model.get('min');
+
+            var coords = polar.dataToPoints(data);
+            lastStackCoords[stackId] = lastStackCoords[stackId] || [];
+            lastStackCoordsOrigin[stackId] = lastStackCoordsOrigin[stackId] || []; // Fix #4243
+
+            data.each(valueAxis.dim, function (value, idx) {
+                if (isNaN(value)) {
+                    return;
+                }
+
+                if (!lastStackCoords[stackId][idx]) {
+                    lastStackCoords[stackId][idx] = {
+                        p: valueAxisStart, // Positive stack
+                        n: valueAxisStart  // Negative stack
+                    };
+                    lastStackCoordsOrigin[stackId][idx] = {
+                        p: valueAxisStart, // Positive stack
+                        n: valueAxisStart  // Negative stack
+                    };
+                }
+                var sign = value >= 0 ? 'p' : 'n';
+                var coord = polar.pointToCoord(coords[idx]);
+
+                var lastCoordOrigin = lastStackCoordsOrigin[stackId][idx][sign];
+                var r0;
+                var r;
+                var startAngle;
+                var endAngle;
+
+                if (valueAxis.dim === 'radius') {
+                    // radial sector
+                    r0 = lastCoordOrigin;
+                    r = coord[0];
+                    startAngle = (-coord[1] + columnOffset) * Math.PI / 180;
+                    endAngle = startAngle + columnWidth * Math.PI / 180;
+
+                    if (Math.abs(r) < barMinHeight) {
+                        r = r0 + (r < 0 ? -1 : 1) * barMinHeight;
+                    }
+
+                    lastStackCoordsOrigin[stackId][idx][sign] = r;
+                }
+                else {
+                    // tangential sector
+                    r0 = coord[0] + columnOffset;
+                    r = r0 + columnWidth;
+
+                    // clamp data if min or max is defined for valueAxis
+                    if (valueMax != null) {
+                        value = Math.min(value, valueMax);
+                    }
+                    if (valueMin != null) {
+                        value = Math.max(value, valueMin);
+                    }
+
+                    var angle = angleAxis.dataToAngle(value);
+                    if (Math.abs(angle - lastCoordOrigin) < barMinAngle) {
+                        angle = lastCoordOrigin - (value < 0 ? -1 : 1)
+                            * barMinAngle;
+                    }
+
+                    startAngle = -lastCoordOrigin * Math.PI / 180;
+                    endAngle = -angle * Math.PI / 180;
+
+                    // if the previous stack is at the end of the ring,
+                    // add a round to differentiate it from origin
+                    var extent = angleAxis.getExtent();
+                    var stackCoord = angle;
+                    if (stackCoord === extent[0] && value > 0) {
+                        stackCoord = extent[1];
+                    }
+                    else if (stackCoord === extent[1] && value < 0) {
+                        stackCoord = extent[0];
+                    }
+                    lastStackCoordsOrigin[stackId][idx][sign] = stackCoord;
+                }
+
+                data.setItemLayout(idx, {
+                    cx: cx,
+                    cy: cy,
+                    r0: r0,
+                    r: r,
+                    startAngle: startAngle,
+                    endAngle: endAngle
+                });
+
+            }, true);
+
+        }, this);
+
+    }
+
+    /**
+     * Calculate bar width and offset for radial bar charts
+     */
+    function calRadialBar(barSeries, api) {
+        // Columns info on each category axis. Key is polar name
+        var columnsMap = {};
+
+        zrUtil.each(barSeries, function (seriesModel, idx) {
+            var data = seriesModel.getData();
+            var polar = seriesModel.coordinateSystem;
+
+            var baseAxis = polar.getBaseAxis();
+
+            var axisExtent = baseAxis.getExtent();
+            var bandWidth = baseAxis.type === 'category'
+                ? baseAxis.getBandWidth()
+                : (Math.abs(axisExtent[1] - axisExtent[0]) / data.count());
+
+            var columnsOnAxis = columnsMap[getAxisKey(baseAxis)] || {
+                bandWidth: bandWidth,
+                remainedWidth: bandWidth,
+                autoWidthCount: 0,
+                categoryGap: '20%',
+                gap: '30%',
+                stacks: {}
+            };
+            var stacks = columnsOnAxis.stacks;
+            columnsMap[getAxisKey(baseAxis)] = columnsOnAxis;
+
+            var stackId = getSeriesStackId(seriesModel);
+
+            if (!stacks[stackId]) {
+                columnsOnAxis.autoWidthCount++;
+            }
+            stacks[stackId] = stacks[stackId] || {
+                width: 0,
+                maxWidth: 0
+            };
+
+            var barWidth = parsePercent(
+                seriesModel.get('barWidth'),
+                bandWidth
+            );
+            var barMaxWidth = parsePercent(
+                seriesModel.get('barMaxWidth'),
+                bandWidth
+            );
+            var barGap = seriesModel.get('barGap');
+            var barCategoryGap = seriesModel.get('barCategoryGap');
+
+            if (barWidth && !stacks[stackId].width) {
+                barWidth = Math.min(columnsOnAxis.remainedWidth, barWidth);
+                stacks[stackId].width = barWidth;
+                columnsOnAxis.remainedWidth -= barWidth;
+            }
+
+            barMaxWidth && (stacks[stackId].maxWidth = barMaxWidth);
+            (barGap != null) && (columnsOnAxis.gap = barGap);
+            (barCategoryGap != null) && (columnsOnAxis.categoryGap = barCategoryGap);
+        });
+
+
+        var result = {};
+
+        zrUtil.each(columnsMap, function (columnsOnAxis, coordSysName) {
+
+            result[coordSysName] = {};
+
+            var stacks = columnsOnAxis.stacks;
+            var bandWidth = columnsOnAxis.bandWidth;
+            var categoryGap = parsePercent(columnsOnAxis.categoryGap, bandWidth);
+            var barGapPercent = parsePercent(columnsOnAxis.gap, 1);
+
+            var remainedWidth = columnsOnAxis.remainedWidth;
+            var autoWidthCount = columnsOnAxis.autoWidthCount;
+            var autoWidth = (remainedWidth - categoryGap)
+                / (autoWidthCount + (autoWidthCount - 1) * barGapPercent);
+            autoWidth = Math.max(autoWidth, 0);
+
+            // Find if any auto calculated bar exceeded maxBarWidth
+            zrUtil.each(stacks, function (column, stack) {
+                var maxWidth = column.maxWidth;
+                if (maxWidth && maxWidth < autoWidth) {
+                    maxWidth = Math.min(maxWidth, remainedWidth);
+                    if (column.width) {
+                        maxWidth = Math.min(maxWidth, column.width);
+                    }
+                    remainedWidth -= maxWidth;
+                    column.width = maxWidth;
+                    autoWidthCount--;
+                }
+            });
+
+            // Recalculate width again
+            autoWidth = (remainedWidth - categoryGap)
+                / (autoWidthCount + (autoWidthCount - 1) * barGapPercent);
+            autoWidth = Math.max(autoWidth, 0);
+
+            var widthSum = 0;
+            var lastColumn;
+            zrUtil.each(stacks, function (column, idx) {
+                if (!column.width) {
+                    column.width = autoWidth;
+                }
+                lastColumn = column;
+                widthSum += column.width * (1 + barGapPercent);
+            });
+            if (lastColumn) {
+                widthSum -= lastColumn.width * barGapPercent;
+            }
+
+            var offset = -widthSum / 2;
+            zrUtil.each(stacks, function (column, stackId) {
+                result[coordSysName][stackId] = result[coordSysName][stackId] || {
+                    offset: offset,
+                    width: column.width
+                };
+
+                offset += column.width * (1 + barGapPercent);
+            });
+        });
+
+        return result;
+    }
+
+    return barLayoutPolar;
+});

package/src/layout/points.js

@@ -5,23 +5,29 @@ define(function (require) {
             var data = seriesModel.getData();
             var coordSys = seriesModel.coordinateSystem;
 
-            if (coordSys) {
-                var dims = coordSys.dimensions;
+            if (!coordSys) {
+                return;
+            }
+
+            var dims = [];
+            var coordDims = coordSys.dimensions;
+            for (var i = 0; i < coordDims.length; i++) {
+                dims.push(seriesModel.coordDimToDataDim(coordSys.dimensions[i])[0]);
+            }
 
-                if (dims.length === 1) {
-                    data.each(dims[0], function (x, idx) {
-                        // Also {Array.<number>}, not undefined to avoid if...else... statement
-                        data.setItemLayout(idx, isNaN(x) ? [NaN, NaN] : coordSys.dataToPoint(x));
-                    });
-                }
-                else if (dims.length === 2) {
-                    data.each(dims, function (x, y, idx) {
-                        // Also {Array.<number>}, not undefined to avoid if...else... statement
-                        data.setItemLayout(
-                            idx, (isNaN(x) || isNaN(y)) ? [NaN, NaN] : coordSys.dataToPoint([x, y])
-                        );
-                    }, true);
-                }
+            if (dims.length === 1) {
+                data.each(dims[0], function (x, idx) {
+                    // Also {Array.<number>}, not undefined to avoid if...else... statement
+                    data.setItemLayout(idx, isNaN(x) ? [NaN, NaN] : coordSys.dataToPoint(x));
+                });
+            }
+            else if (dims.length === 2) {
+                data.each(dims, function (x, y, idx) {
+                    // Also {Array.<number>}, not undefined to avoid if...else... statement
+                    data.setItemLayout(
+                        idx, (isNaN(x) || isNaN(y)) ? [NaN, NaN] : coordSys.dataToPoint([x, y])
+                    );
+                }, true);
             }
         });
     };

package/src/model/Global.js

@@ -63,7 +63,7 @@ define(function (require) {
             this._optionManager = optionManager;
         },
 
-        setOption: function (option, optionPreprocessorFuncs, onlyGraphic) {
+        setOption: function (option, optionPreprocessorFuncs) {
             zrUtil.assert(
                 !(OPTION_INNER_KEY in option),
                 'please use chart.getOption()'
@@ -71,7 +71,7 @@ define(function (require) {
 
             this._optionManager.setOption(option, optionPreprocessorFuncs);
 
-            this.resetOption(null, onlyGraphic);
+            this.resetOption(null);
         },
 
         /**
@@ -81,7 +81,7 @@ define(function (require) {
          *                      'media': only reset media query option
          * @return {boolean} Whether option changed.
          */
-        resetOption: function (type, onlyGraphic) {
+        resetOption: function (type) {
             var optionChanged = false;
             var optionManager = this._optionManager;
 
@@ -92,11 +92,7 @@ define(function (require) {
                     initBase.call(this, baseOption);
                 }
                 else {
-                    // If only graphic, other series and component will not
-                    // go through update process, data should not be restored.
-                    // Otherwise grphic els mounted on data will be eliminated
-                    // and downplay will not work.
-                    !onlyGraphic && this.restoreData();
+                    this.restoreData();
                     this.mergeOption(baseOption);
                 }
                 optionChanged = true;
@@ -158,7 +154,7 @@ define(function (require) {
                 var newCptOptionList = modelUtil.normalizeToArray(newOption[mainType]);
 
                 var mapResult = modelUtil.mappingToExists(
-                    componentsMap[mainType], newCptOptionList
+                    componentsMap.get(mainType), newCptOptionList
                 );
 
                 modelUtil.makeIdAndName(mapResult);
@@ -177,7 +173,7 @@ define(function (require) {
                 );
 
                 option[mainType] = [];
-                componentsMap[mainType] = [];
+                componentsMap.set(mainType, []);
 
                 each(mapResult, function (resultItem, index) {
                     var componentModel = resultItem.exist;
@@ -227,13 +223,13 @@ define(function (require) {
                         }
                     }
 
-                    componentsMap[mainType][index] = componentModel;
+                    componentsMap.get(mainType)[index] = componentModel;
                     option[mainType][index] = componentModel.option;
                 }, this);
 
                 // Backup series for filtering.
                 if (mainType === 'series') {
-                    this._seriesIndices = createSeriesIndices(componentsMap.series);
+                    this._seriesIndices = createSeriesIndices(componentsMap.get('series'));
                 }
             }
         },
@@ -277,7 +273,7 @@ define(function (require) {
          * @return {module:echarts/model/Component}
          */
         getComponent: function (mainType, idx) {
-            var list = this._componentsMap[mainType];
+            var list = this._componentsMap.get(mainType);
             if (list) {
                 return list[idx || 0];
             }
@@ -303,7 +299,7 @@ define(function (require) {
             var id = condition.id;
             var name = condition.name;
 
-            var cpts = this._componentsMap[mainType];
+            var cpts = this._componentsMap.get(mainType);
 
             if (!cpts || !cpts.length) {
                 return [];
@@ -378,7 +374,7 @@ define(function (require) {
             var queryCond = getQueryCond(query);
             var result = queryCond
                 ? this.queryComponents(queryCond)
-                : this._componentsMap[mainType];
+                : this._componentsMap.get(mainType);
 
             return doFilter(filterBySubType(result, condition));
 
@@ -437,14 +433,14 @@ define(function (require) {
             if (typeof mainType === 'function') {
                 context = cb;
                 cb = mainType;
-                each(componentsMap, function (components, componentType) {
+                componentsMap.each(function (components, componentType) {
                     each(components, function (component, index) {
                         cb.call(context, componentType, component, index);
                     });
                 });
             }
             else if (zrUtil.isString(mainType)) {
-                each(componentsMap[mainType], cb, context);
+                each(componentsMap.get(mainType), cb, context);
             }
             else if (isObject(mainType)) {
                 var queryResult = this.findComponents(mainType);
@@ -457,7 +453,7 @@ define(function (require) {
          * @return {Array.<module:echarts/model/Series>}
          */
         getSeriesByName: function (name) {
-            var series = this._componentsMap.series;
+            var series = this._componentsMap.get('series');
             return filter(series, function (oneSeries) {
                 return oneSeries.name === name;
             });
@@ -468,7 +464,7 @@ define(function (require) {
          * @return {module:echarts/model/Series}
          */
         getSeriesByIndex: function (seriesIndex) {
-            return this._componentsMap.series[seriesIndex];
+            return this._componentsMap.get('series')[seriesIndex];
         },
 
         /**
@@ -476,7 +472,7 @@ define(function (require) {
          * @return {Array.<module:echarts/model/Series>}
          */
         getSeriesByType: function (subType) {
-            var series = this._componentsMap.series;
+            var series = this._componentsMap.get('series');
             return filter(series, function (oneSeries) {
                 return oneSeries.subType === subType;
             });
@@ -486,7 +482,7 @@ define(function (require) {
          * @return {Array.<module:echarts/model/Series>}
          */
         getSeries: function () {
-            return this._componentsMap.series.slice();
+            return this._componentsMap.get('series').slice();
         },
 
         /**
@@ -499,7 +495,7 @@ define(function (require) {
         eachSeries: function (cb, context) {
             assertSeriesInitialized(this);
             each(this._seriesIndices, function (rawSeriesIndex) {
-                var series = this._componentsMap.series[rawSeriesIndex];
+                var series = this._componentsMap.get('series')[rawSeriesIndex];
                 cb.call(context, series, rawSeriesIndex);
             }, this);
         },
@@ -511,7 +507,7 @@ define(function (require) {
          * @param {*} context
          */
         eachRawSeries: function (cb, context) {
-            each(this._componentsMap.series, cb, context);
+            each(this._componentsMap.get('series'), cb, context);
         },
 
         /**
@@ -525,7 +521,7 @@ define(function (require) {
         eachSeriesByType: function (subType, cb, context) {
             assertSeriesInitialized(this);
             each(this._seriesIndices, function (rawSeriesIndex) {
-                var series = this._componentsMap.series[rawSeriesIndex];
+                var series = this._componentsMap.get('series')[rawSeriesIndex];
                 if (series.subType === subType) {
                     cb.call(context, series, rawSeriesIndex);
                 }
@@ -551,6 +547,13 @@ define(function (require) {
             return zrUtil.indexOf(this._seriesIndices, seriesModel.componentIndex) < 0;
         },
 
+        /**
+         * @return {Array.<number>}
+         */
+        getCurrentSeriesIndices: function () {
+            return (this._seriesIndices || []).slice();
+        },
+
         /**
          * @param {Function} cb
          * @param {*} context
@@ -558,7 +561,7 @@ define(function (require) {
         filterSeries: function (cb, context) {
             assertSeriesInitialized(this);
             var filteredSeries = filter(
-                this._componentsMap.series, cb, context
+                this._componentsMap.get('series'), cb, context
             );
             this._seriesIndices = createSeriesIndices(filteredSeries);
         },
@@ -566,10 +569,10 @@ define(function (require) {
         restoreData: function () {
             var componentsMap = this._componentsMap;
 
-            this._seriesIndices = createSeriesIndices(componentsMap.series);
+            this._seriesIndices = createSeriesIndices(componentsMap.get('series'));
 
             var componentTypes = [];
-            each(componentsMap, function (components, componentType) {
+            componentsMap.each(function (components, componentType) {
                 componentTypes.push(componentType);
             });
 
@@ -577,7 +580,7 @@ define(function (require) {
                 componentTypes,
                 ComponentModel.getAllClassMainTypes(),
                 function (componentType, dependencies) {
-                    each(componentsMap[componentType], function (component) {
+                    each(componentsMap.get(componentType), function (component) {
                         component.restoreData();
                     });
                 }
@@ -621,7 +624,7 @@ define(function (require) {
          * @type {Object.<string, Array.<module:echarts/model/Model>>}
          * @private
          */
-        this._componentsMap = {series: []};
+        this._componentsMap = zrUtil.createHashMap({series: []});
 
         /**
          * Mapping between filtered series list and raw series list.
@@ -651,7 +654,7 @@ define(function (require) {
 
         var ret = {};
         each(types, function (type) {
-            ret[type] = (componentsMap[type] || []).slice();
+            ret[type] = (componentsMap.get(type) || []).slice();
         });
 
         return ret;
@@ -702,7 +705,7 @@ define(function (require) {
         // which make sure that their initialization is after series.
         if (__DEV__) {
             if (!ecModel._seriesIndices) {
-                throw new Error('Series has not been initialized yet.');
+                throw new Error('Option should contains series.');
             }
         }
     }