(1) Fix stack in dataset

(2) Support stack based on value (only category axis) but not on index
(3) Fix some defects of List
Fix #7535 Fix #7560 Fix #6861

src/chart/bar/BarView.js

@@ -162,7 +162,14 @@ var elementCreator = {
         data, dataIndex, itemModel, layout, isRadial,
         animationModel, isUpdate
     ) {
-        var sector = new graphic.Sector({shape: zrUtil.extend({}, layout)});
+        // Keep the same logic with bar in catesion: use end value to control
+        // direction. Notice that if clockwise is true (by default), the sector
+        // will always draw clockwisely, no matter whether endAngle is greater
+        // or less than startAngle.
+        var clockwise = layout.startAngle < layout.endAngle;
+        var sector = new graphic.Sector({
+            shape: zrUtil.defaults({clockwise: clockwise}, layout)
+        });
 
         // Animation
         if (animationModel) {

src/chart/helper/createListFromArray.js

@@ -7,6 +7,7 @@ import {getDataItemValue} from '../../util/model';
 import CoordinateSystem from '../../CoordinateSystem';
 import {getCoordSysDefineBySeries} from '../../model/referHelper';
 import Source from '../../data/Source';
+import {enableDataStack} from '../../data/helper/dataStackHelper';
 
 /**
  * @param {module:echarts/data/Source|Array} source Or raw data.
@@ -31,7 +32,7 @@ function createListFromArray(source, seriesModel) {
             if (axisModel) {
                 var axisType = axisModel.get('type');
                 dimInfo.type = getDimensionTypeByAxis(axisType);
-                dimInfo.stackable = isStackable(axisType);
+                // dimInfo.stackable = isStackable(axisType);
             }
             return dimInfo;
         });
@@ -69,8 +70,12 @@ function createListFromArray(source, seriesModel) {
         dimInfoList[firstCategoryDimIndex].otherDims.itemName = 0;
     }
 
+    var stackCalculationInfo = enableDataStack(seriesModel, dimInfoList);
+
     var list = new List(dimInfoList, seriesModel);
 
+    list.setCalculationInfo(stackCalculationInfo);
+
     var dimValueGetter = (firstCategoryDimIndex != null && isNeedCompleteOrdinalData(source))
         ? function (itemOpt, dimName, dataIndex, dimIndex) {
             // Use dataIndex as ordinal value in categoryAxis
@@ -86,10 +91,6 @@ function createListFromArray(source, seriesModel) {
     return list;
 }
 
-function isStackable(axisType) {
-    return axisType !== 'category' && axisType !== 'time';
-}
-
 function isNeedCompleteOrdinalData(source) {
     if (source.sourceFormat === SOURCE_FORMAT_ORIGINAL) {
         var sampleItem = firstDataNotNull(source.data || []);

src/chart/line/LineSeries.js

@@ -45,7 +45,13 @@ export default SeriesModel.extend({
             width: 2,
             type: 'solid'
         },
-        // areaStyle: {origin: 'auto'},
+        // areaStyle: {
+            // origin of areaStyle. Valid values:
+            // `'auto'/null/undefined`: from axisLine to data
+            // `'start'`: from min to data
+            // `'end'`: from data to max
+            // origin: 'auto'
+        // },
         // false, 'start', 'end', 'middle'
         step: false,
 

src/chart/line/LineView.js

@@ -9,6 +9,7 @@ import * as graphic from '../../util/graphic';
 import * as modelUtil from '../../util/model';
 import {Polyline, Polygon} from './poly';
 import ChartView from '../../view/Chart';
+import {prepareDataCoordInfo, getStackedOnPoint} from './helper';
 
 function isPointsSame(points1, points2) {
     if (points1.length !== points2.length) {
@@ -40,68 +41,23 @@ function getAxisExtentWithGap(axis) {
     return extent;
 }
 
-function sign(val) {
-    return val >= 0 ? 1 : -1;
-}
-
 /**
  * @param {module:echarts/coord/cartesian/Cartesian2D|module:echarts/coord/polar/Polar} coordSys
  * @param {module:echarts/data/List} data
+ * @param {Object} dataCoordInfo
  * @param {Array.<Array.<number>>} points
- * @param {string} origin origin of areaStyle. Valid values: 'auto', 'start',
- *                        'end'.
- *                        auto: from axisLine to data
- *                        start: from min to data
- *                        end: from data to max
- * @private
  */
-function getStackedOnPoints(seriesModel, coordSys, data, origin) {
-    var baseAxis = coordSys.getBaseAxis();
-    var valueAxis = coordSys.getOtherAxis(baseAxis);
-
-    var valueStart = 0;
-    var extent = valueAxis.scale.getExtent();
-    if (origin === 'start') {
-        valueStart = extent[0];
-    }
-    else if (origin === 'end') {
-        valueStart = extent[1];
-    }
-    else {
-        // auto
-        var extent = valueAxis.scale.getExtent();
-        if (extent[0] > 0) {
-            // Both positive
-            valueStart = extent[0];
-        }
-        else if (extent[1] < 0) {
-            // Both negative
-            valueStart = extent[1];
-        }
-        // If is one positive, and one negative, onZero shall be true
+function getStackedOnPoints(coordSys, data, dataCoordInfo) {
+    if (!dataCoordInfo.valueDim) {
+        return [];
     }
 
-    var valueCoordDim = valueAxis.dim;
-    var baseDataOffset = valueCoordDim === 'x' || valueCoordDim === 'radius' ? 1 : 0;
-    var valueDim = data.mapDimension(valueCoordDim);
-
-    return data.mapArray(valueDim ? [valueDim] : [], function (val, idx) {
-        var stackedOnSameSign;
-        var stackedOn = data.stackedOn;
-        // Find first stacked value with same sign
-        while (stackedOn &&
-            sign(stackedOn.get(valueDim, idx)) === sign(val)
-        ) {
-            stackedOnSameSign = stackedOn;
-            break;
-        }
-        var stackedData = [];
-        stackedData[baseDataOffset] = data.get(baseAxis.dim, idx);
-        stackedData[1 - baseDataOffset] = stackedOnSameSign
-            ? stackedOnSameSign.get(valueDim, idx, true) : valueStart;
-
-        return coordSys.dataToPoint(stackedData);
-    }, true);
+    var points = [];
+    for (var idx = 0, len = data.count(); idx < len; idx++) {
+        points.push(getStackedOnPoint(dataCoordInfo, coordSys, data, idx));
+    }
+console.log(JSON.stringify(points));
+    return points;
 }
 
 function createGridClipShape(cartesian, hasAnimation, seriesModel) {
@@ -328,7 +284,7 @@ export default ChartView.extend({
         var lineStyleModel = seriesModel.getModel('lineStyle');
         var areaStyleModel = seriesModel.getModel('areaStyle');
 
-        var points = data.mapArray(data.getItemLayout, true);
+        var points = data.mapArray(data.getItemLayout);
 
         var isCoordSysPolar = coordSys.type === 'polar';
         var prevCoordSys = this._coordSys;
@@ -342,8 +298,11 @@ export default ChartView.extend({
         var hasAnimation = seriesModel.get('animation');
 
         var isAreaChart = !areaStyleModel.isEmpty();
-        var origin = areaStyleModel.get('origin');
-        var stackedOnPoints = getStackedOnPoints(seriesModel, coordSys, data, origin);
+
+        var valueOrigin = areaStyleModel.get('origin');
+        var dataCoordInfo = prepareDataCoordInfo(coordSys, data, valueOrigin);
+
+        var stackedOnPoints = getStackedOnPoints(coordSys, data, dataCoordInfo);
 
         var showSymbol = seriesModel.get('showSymbol');
 
@@ -423,7 +382,7 @@ export default ChartView.extend({
             ) {
                 if (hasAnimation) {
                     this._updateAnimation(
-                        data, stackedOnPoints, coordSys, api, step
+                        data, stackedOnPoints, coordSys, api, step, valueOrigin
                     );
                 }
                 else {
@@ -466,7 +425,7 @@ export default ChartView.extend({
         });
 
         if (polygon) {
-            var stackedOn = data.stackedOn;
+            var stackedOnSeries = data.getCalculationInfo('stackedOnSeries');
             var stackedOnSmooth = 0;
 
             polygon.useStyle(zrUtil.defaults(
@@ -478,8 +437,7 @@ export default ChartView.extend({
                 }
             ));
 
-            if (stackedOn) {
-                var stackedOnSeries = stackedOn.hostModel;
+            if (stackedOnSeries) {
                 stackedOnSmooth = getSmooth(stackedOnSeries.get('smooth'));
             }
 
@@ -497,6 +455,7 @@ export default ChartView.extend({
         this._stackedOnPoints = stackedOnPoints;
         this._points = points;
         this._step = step;
+        this._valueOrigin = valueOrigin;
     },
 
     dispose: function () {},
@@ -632,7 +591,7 @@ export default ChartView.extend({
      * @private
      */
     // FIXME Two value axis
-    _updateAnimation: function (data, stackedOnPoints, coordSys, api, step) {
+    _updateAnimation: function (data, stackedOnPoints, coordSys, api, step, valueOrigin) {
         var polyline = this._polyline;
         var polygon = this._polygon;
         var seriesModel = data.hostModel;
@@ -640,7 +599,8 @@ export default ChartView.extend({
         var diff = lineAnimationDiff(
             this._data, data,
             this._stackedOnPoints, stackedOnPoints,
-            this._coordSys, coordSys
+            this._coordSys, coordSys,
+            this._valueOrigin, valueOrigin
         );
 
         var current = diff.current;

src/chart/line/helper.js

+import {isDimensionStacked} from '../../data/helper/dataStackHelper';
+import {map} from 'zrender/src/core/util';
+
+/**
+ * @param {Object} coordSys
+ * @param {module:echarts/data/List} data
+ * @param {string} valueOrigin lineSeries.option.areaStyle.origin
+ */
+export function prepareDataCoordInfo(coordSys, data, valueOrigin) {
+    var baseAxis = coordSys.getBaseAxis();
+    var valueAxis = coordSys.getOtherAxis(baseAxis);
+    var valueStart = getValueStart(valueAxis, valueOrigin);
+
+    var baseAxisDim = baseAxis.dim;
+    var valueAxisDim = valueAxis.dim;
+    var valueDim = data.mapDimension(valueAxisDim);
+    var baseDim = data.mapDimension(baseAxisDim);
+    var baseDataOffset = valueAxisDim === 'x' || valueAxisDim === 'radius' ? 1 : 0;
+
+    var stacked = isDimensionStacked(data, valueDim, baseDim);
+
+    var dataDimsForPoint = map(coordSys.dimensions, function (coordDim) {
+        return data.mapDimension(coordDim);
+    });
+
+    return {
+        dataDimsForPoint: dataDimsForPoint,
+        valueStart: valueStart,
+        valueAxisDim: valueAxisDim,
+        baseAxisDim: baseAxisDim,
+        stacked: stacked,
+        valueDim: valueDim,
+        baseDim: baseDim,
+        baseDataOffset: baseDataOffset,
+        stackedOverDimension: data.getCalculationInfo('stackedOverDimension')
+    };
+}
+
+function getValueStart(valueAxis, valueOrigin) {
+    var valueStart = 0;
+    var extent = valueAxis.scale.getExtent();
+
+    if (valueOrigin === 'start') {
+        valueStart = extent[0];
+    }
+    else if (valueOrigin === 'end') {
+        valueStart = extent[1];
+    }
+    // auto
+    else {
+        // Both positive
+        if (extent[0] > 0) {
+            valueStart = extent[0];
+        }
+        // Both negative
+        else if (extent[1] < 0) {
+            valueStart = extent[1];
+        }
+        // If is one positive, and one negative, onZero shall be true
+    }
+
+    return valueStart;
+}
+
+export function getStackedOnPoint(dataCoordInfo, coordSys, data, idx) {
+    var value = dataCoordInfo.stacked
+        ? data.get(data.getCalculationInfo('stackedOverDimension'), idx)
+        : dataCoordInfo.valueStart;
+
+    var baseDataOffset = dataCoordInfo.baseDataOffset;
+    var stackedData = [];
+    stackedData[baseDataOffset] = data.get(dataCoordInfo.baseDim, idx);
+    stackedData[1 - baseDataOffset] = value;
+
+    return coordSys.dataToPoint(stackedData);
+}

src/chart/line/lineAnimationDiff.js

+import {prepareDataCoordInfo, getStackedOnPoint} from './helper';
 
 // var arrayDiff = require('zrender/src/core/arrayDiff');
 // 'zrender/src/core/arrayDiff' has been used before, but it did
 // not do well in performance when roam with fixed dataZoom window.
 
-function sign(val) {
-    return val >= 0 ? 1 : -1;
-}
-
-function getStackedOnPoint(coordSys, data, idx) {
-    var baseAxis = coordSys.getBaseAxis();
-    var valueAxis = coordSys.getOtherAxis(baseAxis);
-    var valueStart = baseAxis.onZero
-        ? 0 : valueAxis.scale.getExtent()[0];
-
-    var valueDim = valueAxis.dim;
-    var baseDataOffset = valueDim === 'x' || valueDim === 'radius' ? 1 : 0;
-
-    var stackedOnSameSign;
-    var stackedOn = data.stackedOn;
-    var val = data.get(valueDim, idx);
-    // Find first stacked value with same sign
-    while (stackedOn &&
-        sign(stackedOn.get(valueDim, idx)) === sign(val)
-    ) {
-        stackedOnSameSign = stackedOn;
-        break;
-    }
-    var stackedData = [];
-    stackedData[baseDataOffset] = data.get(baseAxis.dim, idx);
-    stackedData[1 - baseDataOffset] = stackedOnSameSign
-        ? stackedOnSameSign.get(valueDim, idx, true) : valueStart;
-
-    return coordSys.dataToPoint(stackedData);
-}
-
 // function convertToIntId(newIdList, oldIdList) {
 //     // Generate int id instead of string id.
 //     // Compare string maybe slow in score function of arrDiff
@@ -78,7 +48,8 @@ function diffData(oldData, newData) {
 export default function (
     oldData, newData,
     oldStackedOnPoints, newStackedOnPoints,
-    oldCoordSys, newCoordSys
+    oldCoordSys, newCoordSys,
+    oldValueOrigin, newValueOrigin
 ) {
     var diff = diffData(oldData, newData);
 
@@ -99,7 +70,10 @@ export default function (
     var status = [];
     var sortedIndices = [];
     var rawIndices = [];
-    var dims = newCoordSys.dimensions;
+
+    var newDataOldCoordInfo = prepareDataCoordInfo(oldCoordSys, newData, oldValueOrigin);
+    var oldDataNewCoordInfo = prepareDataCoordInfo(newCoordSys, oldData, newValueOrigin);
+
     for (var i = 0; i < diff.length; i++) {
         var diffItem = diff[i];
         var pointAdded = true;
@@ -126,14 +100,15 @@ export default function (
                 var idx = diffItem.idx;
                 currPoints.push(
                     oldCoordSys.dataToPoint([
-                        newData.get(dims[0], idx, true), newData.get(dims[1], idx, true)
+                        newData.get(newDataOldCoordInfo.dataDimsForPoint[0], idx),
+                        newData.get(newDataOldCoordInfo.dataDimsForPoint[1], idx)
                     ])
                 );
 
                 nextPoints.push(newData.getItemLayout(idx).slice());
 
                 currStackedPoints.push(
-                    getStackedOnPoint(oldCoordSys, newData, idx)
+                    getStackedOnPoint(newDataOldCoordInfo, oldCoordSys, newData, idx)
                 );
                 nextStackedPoints.push(newStackedOnPoints[idx]);
 
@@ -147,14 +122,13 @@ export default function (
                 if (rawIndex !== idx) {
                     currPoints.push(oldData.getItemLayout(idx));
                     nextPoints.push(newCoordSys.dataToPoint([
-                        oldData.get(dims[0], idx, true), oldData.get(dims[1], idx, true)
+                        oldData.get(oldDataNewCoordInfo.dataDimsForPoint[0], idx),
+                        oldData.get(oldDataNewCoordInfo.dataDimsForPoint[1], idx)
                     ]));
 
                     currStackedPoints.push(oldStackedOnPoints[idx]);
                     nextStackedPoints.push(
-                        getStackedOnPoint(
-                            newCoordSys, oldData, idx
-                        )
+                        getStackedOnPoint(oldDataNewCoordInfo, newCoordSys, oldData, idx)
                     );
 
                     rawIndices.push(rawIndex);

src/component/axisPointer/axisTrigger.js

@@ -187,7 +187,8 @@ function buildPayloadsBySeries(value, axisInfo) {
                 value,
                 // Add a threshold to avoid find the wrong dataIndex
                 // when data length is not same.
-                false, axis.type === 'category' ? 0.5 : null
+                // false,
+                axis.type === 'category' ? 0.5 : null
             );
             if (!dataIndices.length) {
                 return;

src/component/dataZoom/AxisProxy.js

@@ -64,11 +64,11 @@ var AxisProxy = function (dimName, axisIndex, dataZoomModel, ecModel) {
      */
     this._dataZoomModel = dataZoomModel;
 
-    /**
-     * @readOnly
-     * @private
-     */
-    this.hasSeriesStacked;
+    // /**
+    //  * @readOnly
+    //  * @private
+    //  */
+    // this.hasSeriesStacked;
 };
 
 AxisProxy.prototype = {
@@ -248,14 +248,15 @@ AxisProxy.prototype = {
         // Culculate data window and data extent, and record them.
         this._dataExtent = calculateDataExtent(this, this._dimName, targetSeries);
 
-        this.hasSeriesStacked = false;
-        each(targetSeries, function (series) {
-            var data = series.getData();
-            var dataDim = data.mapDimension(this._dimName);
-            if (data.isStacked(dataDim)) {
-                this.hasSeriesStacked = true;
-            }
-        }, this);
+        // this.hasSeriesStacked = false;
+        // each(targetSeries, function (series) {
+            // var data = series.getData();
+            // var dataDim = data.mapDimension(this._dimName);
+            // var stackedDimension = data.getCalculationInfo('stackedDimension');
+            // if (stackedDimension && stackedDimension === dataDim) {
+                // this.hasSeriesStacked = true;
+            // }
+        // }, this);
 
         var dataWindow = this.calculateDataWindow(dataZoomModel.option);
 
@@ -305,13 +306,15 @@ AxisProxy.prototype = {
         // when using toolbox#dataZoom, utill tooltip#dataZoom support "single axis
         // selection" some day, which might need "adapt to data extent on the
         // otherAxis", which is disabled by filterMode-'empty'.
-        var otherAxisModel = this.getOtherAxisModel();
-        if (dataZoomModel.get('$fromToolbox')
-            && otherAxisModel
-            && otherAxisModel.hasSeriesStacked
-        ) {
-            filterMode = 'empty';
-        }
+        // But currently, stack has been fixed to based on value but not index,
+        // so this is not an issue any more.
+        // var otherAxisModel = this.getOtherAxisModel();
+        // if (dataZoomModel.get('$fromToolbox')
+        //     && otherAxisModel
+        //     && otherAxisModel.hasSeriesStacked
+        // ) {
+        //     filterMode = 'empty';
+        // }
 
         // TODO
         // filterMode 'weakFilter' and 'empty' is not optimized for huge data yet.

src/component/marker/markerHelper.js

 import * as zrUtil from 'zrender/src/core/util';
 import * as numberUtil from '../../util/number';
+import {isDimensionStacked} from '../../data/helper/dataStackHelper';
 
 var indexOf = zrUtil.indexOf;
 
@@ -11,32 +12,48 @@ function hasXAndY(item) {
     return !isNaN(parseFloat(item.x)) && !isNaN(parseFloat(item.y));
 }
 
-function getPrecision(data, valueAxisDim, dataIndex) {
-    var precision = -1;
-    do {
-        precision = Math.max(
-            numberUtil.getPrecision(data.get(
-                valueAxisDim, dataIndex
-            )),
-            precision
-        );
-        data = data.stackedOn;
-    } while (data);
-
-    return precision;
-}
+// Make it simple, do not visit all stacked value to count precision.
+// function getPrecision(data, valueAxisDim, dataIndex) {
+//     var precision = -1;
+//     var stackedDim = data.mapDimension(valueAxisDim);
+//     do {
+//         precision = Math.max(
+//             numberUtil.getPrecision(data.get(stackedDim, dataIndex)),
+//             precision
+//         );
+//         var stackedOnSeries = data.getCalculationInfo('stackedOnSeries');
+//         if (stackedOnSeries) {
+//             var byValue = data.get(data.getCalculationInfo('stackedByDimension'), dataIndex);
+//             data = stackedOnSeries.getData();
+//             dataIndex = data.indexOf(data.getCalculationInfo('stackedByDimension'), byValue);
+//             stackedDim = data.getCalculationInfo('stackedDimension');
+//         }
+//         else {
+//             data = null;
+//         }
+//     } while (data);
+
+//     return precision;
+// }
 
 function markerTypeCalculatorWithExtent(
     mlType, data, otherDataDim, targetDataDim, otherCoordIndex, targetCoordIndex
 ) {
     var coordArr = [];
-    var value = numCalculate(data, targetDataDim, mlType);
 
-    var dataIndex = data.indicesOfNearest(targetDataDim, value, true)[0];
-    coordArr[otherCoordIndex] = data.get(otherDataDim, dataIndex, true);
-    coordArr[targetCoordIndex] = data.get(targetDataDim, dataIndex, true);
+    var stacked = isDimensionStacked(data, targetDataDim, otherDataDim);
+    var calcDataDim = stacked
+        ? data.getCalculationInfo('stackResultDimension')
+        : targetDataDim;
+
+    var value = numCalculate(data, calcDataDim, mlType);
+
+    var dataIndex = data.indicesOfNearest(calcDataDim, value)[0];
+    coordArr[otherCoordIndex] = data.get(otherDataDim, dataIndex);
+    coordArr[targetCoordIndex] = data.get(targetDataDim, dataIndex);
 
-    var precision = getPrecision(data, targetDataDim, dataIndex);
+    // Make it simple, do not visit all stacked value to count precision.
+    var precision = numberUtil.getPrecision(data.get(targetDataDim, dataIndex));
     precision = Math.min(precision, 20);
     if (precision >= 0) {
         coordArr[targetCoordIndex] = +coordArr[targetCoordIndex].toFixed(precision);

src/data/helper/dataStackHelper.js

+import {each, isString} from 'zrender/src/core/util';
+
+/**
+ * @param {module:echarts/model/Series} seriesModel
+ * @param {Array.<string|Object>} dimensionInfoList The same as the input of <module:echarts/data/List>.
+ *        The input dimensionInfoList will be modified.
+ * @return {Object} calculationInfo
+ * {
+ *     stackedDimension: stackedDimInfo.name,
+ *     stackedByDimension: stackedByDimension,
+ *     stackedOverDimension: stackedOverDimension,
+ *     stackResultDimension: stackResultDimension
+ * }
+ */
+export function enableDataStack(seriesModel, dimensionInfoList) {
+    // Compatibal: when `stack` is set as '', do not stack.
+    var mayStack = !!(seriesModel && seriesModel.get('stack'));
+    var stackedByDimInfo;
+    var stackedDimInfo;
+    var stackResultDimension;
+    var stackedOverDimension;
+
+    each(dimensionInfoList, function (dimensionInfo, index) {
+        if (isString(dimensionInfo)) {
+            dimensionInfoList[index] = dimensionInfo = {name: dimensionInfo};
+        }
+
+        if (mayStack && !dimensionInfo.isExtraCoord) {
+            // Find the first ordinal dimension as the stackedByDimInfo.
+            if (!stackedByDimInfo && dimensionInfo.ordinalMeta) {
+                stackedByDimInfo = dimensionInfo;
+            }
+            // Find the first stackable dimension as the stackedDimInfo.
+            if (!stackedDimInfo
+                && dimensionInfo.type !== 'ordinal'
+                && dimensionInfo.type !== 'time'
+            ) {
+                stackedDimInfo = dimensionInfo;
+            }
+        }
+    });
+
+    // Add stack dimension, they can be both calculated by coordinate system in `unionExtent`.
+    // That put stack logic in List is for using conveniently in echarts extensions, but it
+    // might not be a good way.
+    if (stackedByDimInfo && stackedDimInfo) {
+        // Use a weird name that not duplicated with other names.
+        stackResultDimension = '__\0ecstackresult';
+        stackedOverDimension = '__\0ecstackedover';
+
+        // Create inverted index to fast query index by value.
+        stackedByDimInfo.createInvertedIndices = true;
+
+        var stackedDimCoordDim = stackedDimInfo.coordDim;
+        var stackedDimType = stackedDimInfo.type;
+        var stackedDimCoordIndex = 0;
+
+        each(dimensionInfoList, function (dimensionInfo) {
+            if (dimensionInfo.coordDim === stackedDimCoordDim) {
+                stackedDimCoordIndex++;
+            }
+        });
+
+        dimensionInfoList.push({
+            name: stackResultDimension,
+            coordDim: stackedDimCoordDim,
+            coordDimIndex: stackedDimCoordIndex,
+            type: stackedDimType,
+            isExtraCoord: true
+        });
+
+        stackedDimCoordIndex++;
+
+        dimensionInfoList.push({
+            name: stackedOverDimension,
+            coordDim: stackedDimCoordDim,
+            coordDimIndex: stackedDimCoordIndex,
+            type: stackedDimType,
+            isExtraCoord: true
+        });
+    }
+
+    return {
+        stackedDimension: stackedDimInfo && stackedDimInfo.name,
+        stackedByDimension: stackedByDimInfo && stackedByDimInfo.name,
+        stackedOverDimension: stackedOverDimension,
+        stackResultDimension: stackResultDimension
+    };
+}
+
+export function isDimensionStacked(data, stackedDim, stackedByDim) {
+    return stackedDim
+        && stackedByDim
+        && stackedDim === data.getCalculationInfo('stackedDimension')
+        && stackedByDim === data.getCalculationInfo('stackedByDimension');
+}

src/data/helper/dimensionHelper.js

-import {each, createHashMap, assert} from 'zrender/src/core/util';
+import {each, filter, createHashMap, assert} from 'zrender/src/core/util';
 import { __DEV__ } from '../../config';
 
 export var OTHER_DIMENSIONS = createHashMap([
@@ -72,6 +72,18 @@ export function summarizeDimensions(data) {
     encode.defaultedLabel = defaultedLabel;
     encode.defaultedTooltip = defaultedTooltip;
 
+    var encodeFirstDimNotExtra = summary.encodeFirstDimNotExtra = {};
+    each(encode, function (coordDimArr, coordDim) {
+        for (var i = 0; i < (coordDimArr || []).length; i++) {
+            var dim = coordDimArr[i];
+            var dimInfo = data.getDimensionInfo(dim);
+            if (dimInfo && !dimInfo.isExtraCoord) {
+                encodeFirstDimNotExtra[coordDim] = dim;
+                break;
+            }
+        }
+    });
+
     return summary;
 }
 

src/echarts.js

@@ -21,8 +21,7 @@ import ExtensionAPI from './ExtensionAPI';
 import CoordinateSystemManager from './CoordinateSystem';
 import OptionManager from './model/OptionManager';
 import backwardCompat from './preprocessor/backwardCompat';
-// -STACK-
-// import dataStack from './processor/dataStack';
+import dataStack from './processor/dataStack';
 import ComponentModel from './model/Component';
 import SeriesModel from './model/Series';
 import ComponentView from './view/Component';
@@ -798,8 +797,7 @@ var updateMethods = {
         // deteming whether use progressive rendering.
         updateStreamModes(this, ecModel);
 
-        // -STACK-
-        stackSeriesData(ecModel);
+        // stackSeriesData(ecModel);
 
         coordSysMgr.update(ecModel, api);
 
@@ -1402,26 +1400,6 @@ function prepareView(ecIns, type, ecModel, scheduler) {
     }
 }
 
-/**
- * -STACK-
- * @private
- */
-function stackSeriesData(ecModel) {
-    var stackedDataMap = {};
-    ecModel.eachSeries(function (series) {
-        var stack = series.get('stack');
-        var data = series.getData();
-        if (stack && data.type === 'list') {
-            var previousStack = stackedDataMap[stack];
-            // Avoid conflict with Object.prototype
-            if (stackedDataMap.hasOwnProperty(stack) && previousStack) {
-                data.stackedOn = previousStack;
-            }
-            stackedDataMap[stack] = data;
-        }
-    });
-}
-
 // /**
 //  * Encode visual infomation from data after data processing
 //  *
@@ -2180,8 +2158,7 @@ export function getMap(mapName) {
 
 registerVisual(PRIORITY_VISUAL_GLOBAL, seriesColor);
 registerPreprocessor(backwardCompat);
-// -STACK-
-// registerProcessor(PRIORITY_PROCESSOR_STATISTIC, dataStack);
+registerProcessor(PRIORITY_PROCESSOR_STATISTIC, dataStack);
 registerLoading('default', loadingDefault);
 
 // Default actions

src/layout/barGrid.js

 import * as zrUtil from 'zrender/src/core/util';
 import {parsePercent} from '../util/number';
+import {isDimensionStacked} from '../data/helper/dataStackHelper';
 
 var STACK_PREFIX = '__ec_stack_';
 
@@ -236,18 +237,6 @@ export function layout(seriesType, ecModel, api) {
 
         var barMinHeight = seriesModel.get('barMinHeight') || 0;
 
-        var valueAxisStart = baseAxis.onZero
-            ? valueAxis.toGlobalCoord(valueAxis.dataToCoord(0))
-            : valueAxis.getGlobalExtent()[0];
-
-        var coordDims = [
-            data.mapDimension('x'),
-            data.mapDimension('y')
-        ];
-        var coords = data.mapArray(coordDims, function (x, y) {
-            return cartesian.dataToPoint([x, y]);
-        }, true);
-
         lastStackCoords[stackId] = lastStackCoords[stackId] || [];
         lastStackCoordsOrigin[stackId] = lastStackCoordsOrigin[stackId] || []; // Fix #4243
 
@@ -256,54 +245,69 @@ export function layout(seriesType, ecModel, api) {
             size: columnWidth
         });
 
-        data.each(data.mapDimension(valueAxis.dim), function (value, idx) {
+        var valueDim = data.mapDimension(valueAxis.dim);
+        var baseDim = data.mapDimension(baseAxis.dim);
+        var stacked = isDimensionStacked(data, valueDim, baseDim);
+        var isValueAxisH = valueAxis.isHorizontal();
+
+        var valueAxisStart = (baseAxis.onZero || stacked)
+            ? valueAxis.toGlobalCoord(valueAxis.dataToCoord(0))
+            : valueAxis.getGlobalExtent()[0];
+
+        for (var idx = 0, len = data.count(); idx < len; idx++) {
+            var value = data.get(valueDim, idx);
+            var baseValue = data.get(baseDim, idx);
+
             if (isNaN(value)) {
-                return;
+                continue;
             }
 
-            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 = coords[idx];
-            var lastCoord = lastStackCoords[stackId][idx][sign];
-            var lastCoordOrigin = lastStackCoordsOrigin[stackId][idx][sign];
+            var baseCoord = valueAxisStart;
+
+            // Because of the barMinHeight, we can not use the value in
+            // stackResultDimension directly.
+            if (stacked) {
+                // Only ordinal axis can be stacked.
+                if (!lastStackCoords[stackId][baseValue]) {
+                    lastStackCoords[stackId][baseValue] = {
+                        p: valueAxisStart, // Positive stack
+                        n: valueAxisStart  // Negative stack
+                    };
+                }
+                // Should also consider #4243
+                baseCoord = lastStackCoords[stackId][baseValue][sign];
+            }
+
             var x;
             var y;
             var width;
             var height;
 
-            if (valueAxis.isHorizontal()) {
-                x = lastCoord;
+            if (isValueAxisH) {
+                var coord = cartesian.dataToPoint([value, baseValue]);
+                x = baseCoord;
                 y = coord[1] + columnOffset;
-                width = coord[0] - lastCoordOrigin;
+                width = coord[0] - valueAxisStart;
                 height = columnWidth;
 
-                lastStackCoordsOrigin[stackId][idx][sign] += width;
                 if (Math.abs(width) < barMinHeight) {
                     width = (width < 0 ? -1 : 1) * barMinHeight;
                 }
-                lastStackCoords[stackId][idx][sign] += width;
+                stacked && (lastStackCoords[stackId][baseValue][sign] += width);
             }
             else {
+                var coord = cartesian.dataToPoint([baseValue, value]);
                 x = coord[0] + columnOffset;
-                y = lastCoord;
+                y = baseCoord;
                 width = columnWidth;
-                height = coord[1] - lastCoordOrigin;
+                height = coord[1] - valueAxisStart;
 
-                lastStackCoordsOrigin[stackId][idx][sign] += height;
                 if (Math.abs(height) < barMinHeight) {
                     // Include zero to has a positive bar
                     height = (height <= 0 ? -1 : 1) * barMinHeight;
                 }
-                lastStackCoords[stackId][idx][sign] += height;
+                stacked && (lastStackCoords[stackId][baseValue][sign] += height);
             }
 
             data.setItemLayout(idx, {
@@ -312,7 +316,7 @@ export function layout(seriesType, ecModel, api) {
                 width: width,
                 height: height
             });
-        }, true);
+        }
 
     }, this);
 }

src/layout/barPolar.js

 import * as zrUtil from 'zrender/src/core/util';
 import {parsePercent} from '../util/number';
+import {isDimensionStacked} from '../data/helper/dataStackHelper';
 
 function getSeriesStackId(seriesModel) {
     return seriesModel.get('stack')
@@ -21,7 +22,6 @@ function barLayoutPolar(seriesType, ecModel, api) {
     var height = api.getHeight();
 
     var lastStackCoords = {};
-    var lastStackCoordsOrigin = {};
 
     var barWidthAndOffset = calRadialBar(
         zrUtil.filter(
@@ -42,7 +42,6 @@ function barLayoutPolar(seriesType, ecModel, api) {
 
         var data = seriesModel.getData();
         var polar = seriesModel.coordinateSystem;
-        var angleAxis = polar.getAngleAxis();
         var baseAxis = polar.getBaseAxis();
 
         var stackId = getSeriesStackId(seriesModel);
@@ -59,91 +58,86 @@ function barLayoutPolar(seriesType, ecModel, api) {
         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');
+        lastStackCoords[stackId] = lastStackCoords[stackId] || [];
 
-        var coordDims = [
-            data.mapDimension('radius'),
-            data.mapDimension('angle')
-        ];
-        var coords = data.mapArray(coordDims, function (radius, angle) {
-            return polar.dataToPoint([radius, angle]);
-        }, true);
+        var valueDim = data.mapDimension(valueAxis.dim);
+        var baseDim = data.mapDimension(baseAxis.dim);
+        var stacked = isDimensionStacked(data, valueDim, baseDim);
 
-        lastStackCoords[stackId] = lastStackCoords[stackId] || [];
-        lastStackCoordsOrigin[stackId] = lastStackCoordsOrigin[stackId] || []; // Fix #4243
+        var valueAxisStart = valueAxis.getExtent()[0];
+
+        for (var idx = 0, len = data.count(); idx < len; idx++) {
+            var value = data.get(valueDim, idx);
+            var baseValue = data.get(baseDim, idx);
 
-        data.each(data.mapDimension(valueAxis.dim), function (value, idx) {
             if (isNaN(value)) {
-                return;
+                continue;
             }
 
-            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 baseCoord = valueAxisStart;
+
+            // Because of the barMinHeight, we can not use the value in
+            // stackResultDimension directly.
+            // Only ordinal axis can be stacked.
+            if (stacked) {
+                if (!lastStackCoords[stackId][baseValue]) {
+                    lastStackCoords[stackId][baseValue] = {
+                        p: valueAxisStart, // Positive stack
+                        n: valueAxisStart  // Negative stack
+                    };
+                }
+                // Should also consider #4243
+                baseCoord = lastStackCoords[stackId][baseValue][sign];
+            }
 
-            var lastCoordOrigin = lastStackCoordsOrigin[stackId][idx][sign];
             var r0;
             var r;
             var startAngle;
             var endAngle;
 
+            // radial sector
             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;
+                var radiusSpan = valueAxis.dataToRadius(value) - valueAxisStart;
+                var angle = baseAxis.dataToAngle(baseValue);
+
+                if (Math.abs(radiusSpan) < barMinHeight) {
+                    radiusSpan = (radiusSpan < 0 ? -1 : 1) * barMinHeight;
                 }
 
-                lastStackCoordsOrigin[stackId][idx][sign] = r;
+                r0 = baseCoord;
+                r = baseCoord + radiusSpan;
+                startAngle = angle - columnOffset;
+                endAngle = startAngle - columnWidth;
+
+                stacked && (lastStackCoords[stackId][baseValue][sign] = r);
             }
+            // tangential sector
             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);
-                }
+                // angleAxis must be clamped.
+                var angleSpan = valueAxis.dataToAngle(value, true) - valueAxisStart;
+                var radius = baseAxis.dataToRadius(baseValue);
 
-                var angle = angleAxis.dataToAngle(value);
-                if (Math.abs(angle - lastCoordOrigin) < barMinAngle) {
-                    angle = lastCoordOrigin - (value < 0 ? -1 : 1)
-                        * barMinAngle;
+                if (Math.abs(angleSpan) < barMinAngle) {
+                    angleSpan = (angleSpan < 0 ? -1 : 1) * barMinAngle;
                 }
 
-                startAngle = -lastCoordOrigin * Math.PI / 180;
-                endAngle = -angle * Math.PI / 180;
+                r0 = radius + columnOffset;
+                r = r0 + columnWidth;
+                startAngle = baseCoord;
+                endAngle = baseCoord + angleSpan;
 
                 // 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;
+                // 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];
+                // }
+                stacked && (lastStackCoords[stackId][baseValue][sign] = endAngle);
             }
 
             data.setItemLayout(idx, {
@@ -151,11 +145,13 @@ function barLayoutPolar(seriesType, ecModel, api) {
                 cy: cy,
                 r0: r0,
                 r: r,
-                startAngle: startAngle,
-                endAngle: endAngle
+                // Consider that positive angle is anti-clockwise,
+                // while positive radian of sector is clockwise
+                startAngle: -startAngle * Math.PI / 180,
+                endAngle: -endAngle * Math.PI / 180
             });
 
-        }, true);
+        }
 
     }, this);
 

src/layout/points.js

 import {map} from 'zrender/src/core/util';
 import createRenderPlanner from '../chart/helper/createRenderPlanner';
+import {isDimensionStacked} from '../data/helper/dataStackHelper';
 
 export default function (seriesType) {
     return {
@@ -18,10 +19,17 @@ export default function (seriesType) {
             }
 
             var dims = map(coordSys.dimensions, function (dim) {
-                return data.getDimension(data.mapDimension(dim));
+                return data.mapDimension(dim);
             }).slice(0, 2);
             var dimLen = dims.length;
 
+            if (isDimensionStacked(data, dims[0], dims[1])) {
+                dims[0] = data.getCalculationInfo('stackResultDimension');
+            }
+            if (isDimensionStacked(data, dims[1], dims[0])) {
+                dims[1] = data.getCalculationInfo('stackResultDimension');
+            }
+
             function progress(params, data) {
                 var segCount = params.end - params.start;
                 var points = isLargeRender && new Float32Array(segCount * dimLen);

src/processor/dataStack.js

+import {createHashMap, each} from 'zrender/src/core/util';
+
+// (1) [Caution]: the logic is correct based on the premises:
+//     data processing stage is blocked in stream.
+//     See <module:echarts/stream/Scheduler#performDataProcessorTasks>
+// (2) Only register once when import repeatly.
+//     Should be executed before after series filtered and before stack calculation.
+export default function (ecModel) {
+    var stackInfoMap = createHashMap();
+    ecModel.eachSeries(function (seriesModel) {
+        var stack = seriesModel.get('stack');
+        // Compatibal: when `stack` is set as '', do not stack.
+        if (stack) {
+            var stackInfoList = stackInfoMap.get(stack) || stackInfoMap.set(stack, []);
+            var data = seriesModel.getData();
+
+            stackInfoList.length && data.setCalculationInfo(
+                'stackedOnSeries', stackInfoList[stackInfoList.length - 1].seriesModel
+            );
+
+            stackInfoList.push({
+                // Used for calculate axis extent automatically.
+                stackResultDimension: data.getCalculationInfo('stackResultDimension'),
+                stackedOverDimension: data.getCalculationInfo('stackedOverDimension'),
+                stackedDimension: data.getCalculationInfo('stackedDimension'),
+                stackedByDimension: data.getCalculationInfo('stackedByDimension'),
+                data: data,
+                seriesModel: seriesModel
+            });
+        }
+    });
+
+    stackInfoMap.each(calculateStack);
+}
+
+function calculateStack(stackInfoList) {
+    each(stackInfoList, function (targetStackInfo, idxInStack) {
+        var resultVal = [];
+        var resultNaN = [NaN, NaN];
+        var dims = [targetStackInfo.stackResultDimension, targetStackInfo.stackedOverDimension];
+        var targetData = targetStackInfo.data;
+
+        // Should not write on raw data, because stack series model list changes
+        // depending on legend selection.
+        var newData = targetData.map(dims, function (v0, v1, dataIndex) {
+            var sum = targetData.get(targetStackInfo.stackedDimension, dataIndex);
+
+            // Consider `connectNulls` of line area, if value is NaN, stackedOver
+            // should also be NaN, to draw a appropriate belt area.
+            if (isNaN(sum)) {
+                return resultNaN;
+            }
+
+            var byValue = targetData.get(targetStackInfo.stackedByDimension, dataIndex);
+            var stackedOver = 0;
+
+            for (var j = idxInStack - 1; j >= 0; j--) {
+                var stackInfo = stackInfoList[j];
+
+                // Has been optimized by inverted indices on `stackedByDimension`.
+                var stackedDataRawIndex = stackInfo.data.rawIndexOf(stackInfo.stackedByDimension, byValue);
+                if (stackedDataRawIndex >= 0) {
+                    var val = stackInfo.data.getByRawIndex(stackInfo.stackResultDimension, stackedDataRawIndex);
+
+                    // Considering positive stack, negative stack and empty data
+                    if ((sum >= 0 && val > 0) // Positive stack
+                        || (sum <= 0 && val < 0) // Negative stack
+                    ) {
+                        sum += val;
+                        stackedOver = val;
+                        break;
+                    }
+                }
+            }
+
+            resultVal[0] = sum;
+            resultVal[1] = stackedOver;
+
+            return resultVal;
+        });
+
+        targetData.hostModel.setData(newData);
+        // Update for consequent calculation
+        targetStackInfo.data = newData;
+    });
+}

test/area.html → test/area-stack.html

@@ -30,34 +30,52 @@
                 var data1 = [];
                 var data2 = [];
                 var data3 = [];
+                var data4 = [];
+                var data5 = [];
+                var data6 = [];
 
                 xAxisData.push('类目' + -1);
                 data1.push('-');
                 data2.push('-');
                 data3.push('-');
+                data4.push('-');
+                data5.push('-');
+                data6.push('-');
 
                 for (var i = 0; i < 5; i++) {
                     xAxisData.push('类目' + i);
                     data1.push((-Math.random() - 0.2).toFixed(3));
                     data2.push((Math.random() + 0.3).toFixed(3));
                     data3.push((Math.random() + 0.2).toFixed(3));
+                    data4.push((-Math.random() - 0.2).toFixed(3));
+                    data5.push((-Math.random() - 0.2).toFixed(3));
+                    data6.push((Math.random() + 0.2).toFixed(3));
                 }
 
                 xAxisData.push('类目' + i);
                 data1.push('-');
                 data2.push('-');
                 data3.push('-');
+                data4.push('-');
+                data5.push('-');
+                data6.push('-');
 
                 for (; i < 10; i++) {
                     xAxisData.push('类目' + i);
                     data1.push((-Math.random() - 0.2).toFixed(3));
                     data2.push((Math.random() + 0.3).toFixed(3));
                     data3.push((Math.random() + 0.2).toFixed(3));
+                    data4.push((-Math.random() - 0.2).toFixed(3));
+                    data5.push((-Math.random() - 0.2).toFixed(3));
+                    data6.push((Math.random() + 0.2).toFixed(3));
                 }
                 xAxisData.push('类目' + i);
                 data1.push('-');
                 data2.push('-');
                 data3.push('-');
+                data4.push('-');
+                data5.push('-');
+                data6.push('-');
 
                 var itemStyle = {
                     normal: {
@@ -81,7 +99,13 @@
 
                 chart.setOption({
                     legend: {
-                        data: ['line', 'line2', 'line3']
+                    },
+                    toolbox: {
+                        feature: {
+                            magicType: {
+                                type: ['line', 'bar', 'stack', 'tiled']
+                            }
+                        }
                     },
                     tooltip: {
                         trigger: 'axis',
@@ -106,6 +130,11 @@
                             // show: false
                         }
                     },
+                    dataZoom: [{
+                        type: 'inside'
+                    }, {
+                        type: 'slider'
+                    }],
                     series: [{
                         name: 'line',
                         type: 'line',
@@ -125,7 +154,7 @@
                         connectNulls: true,
                         smooth: true
                     }, {
-                        name: 'line3',
+                        name: '+connectNulls:true',
                         type: 'line',
                         stack: 'all',
                         symbolSize: 10,
@@ -138,6 +167,48 @@
                         },
                         connectNulls: true,
                         smooth: true
+                    }, {
+                        name: '-connectNulls:false',
+                        type: 'line',
+                        stack: 'all',
+                        symbolSize: 10,
+                        data: data4,
+                        itemStyle: itemStyle,
+                        label: {
+                            normal: {
+                                show: true
+                            }
+                        },
+                        connectNulls: false,
+                        smooth: true
+                    }, {
+                        name: '-connectNulls:true',
+                        type: 'line',
+                        stack: 'all',
+                        symbolSize: 10,
+                        data: data5,
+                        itemStyle: itemStyle,
+                        label: {
+                            normal: {
+                                show: true
+                            }
+                        },
+                        connectNulls: true,
+                        smooth: true
+                    }, {
+                        name: '+connectNulls:false',
+                        type: 'line',
+                        stack: 'all',
+                        symbolSize: 10,
+                        data: data6,
+                        itemStyle: itemStyle,
+                        label: {
+                            normal: {
+                                show: true
+                            }
+                        },
+                        connectNulls: false,
+                        smooth: true
                     }]
                 });
             })

test/bar-large.html

@@ -46,6 +46,8 @@
                     data4.push((Math.random() + 0.3).toFixed(2));
                 }
 
+                var data = [["4.70","4.69","2.48","0.77","3.08","4.57","2.68","3.35","0.37","1.86","2.68","0.64","1.82","1.88","0.31","0.45","4.48","3.08","1.58","2.98","1.87","0.96","3.43","2.58","0.41","2.69","0.59","3.47","4.33","1.75","0.51","1.01","1.60","3.62","2.29","2.40","1.52","2.30","0.18","3.99","0.26","2.92","2.94","0.54","2.98","3.71","2.24","0.32","1.98","2.56","1.81","4.67","2.49","1.73","1.79","2.79","3.39","1.83","3.24","3.76","1.23","1.69","3.55","2.66","1.83","3.69","2.70","0.75","0.71","1.44","3.23","1.49","1.50","3.61","4.41","1.26","2.93","2.84","4.11","0.80","2.67","2.59","2.71","4.85","1.28","1.21","4.32","4.04","1.15","4.38","4.41","4.94","4.13","0.86","1.97","3.58","3.02","1.29","1.47","3.75"],["0.78","0.90","0.54","0.75","0.68","0.68","0.84","0.87","0.78","0.79","0.77","0.34","0.81","0.80","0.28","0.87","0.98","0.92","0.66","0.87","0.88","0.56","0.34","0.67","0.60","0.00","0.22","0.87","0.81","0.69","0.41","0.02","0.18","0.55","0.48","0.90","0.62","0.17","0.37","0.35","0.31","0.78","0.34","0.56","0.22","0.87","0.55","0.94","0.58","0.66","0.33","0.73","0.78","0.44","0.79","0.12","0.81","0.77","0.33","0.30","0.86","0.87","0.09","0.91","0.90","0.34","0.76","0.93","0.55","0.41","0.63","0.96","0.80","0.41","0.53","0.53","0.66","0.24","0.24","0.99","0.92","0.85","0.44","0.92","0.28","0.61","0.20","0.74","0.52","0.91","0.42","0.08","0.00","0.57","0.81","0.39","0.41","0.72","0.02","0.20"],["1.17","0.65","0.98","1.08","1.02","1.41","1.01","1.17","0.63","0.94","0.78","1.43","0.67","1.09","1.29","0.60","0.50","1.38","0.76","0.94","0.79","1.44","0.55","1.48","1.13","0.63","1.07","0.57","1.43","0.81","0.87","0.70","1.04","1.43","1.00","0.50","0.54","0.57","0.97","0.58","1.19","0.73","0.76","0.75","1.39","0.93","0.60","1.28","1.14","1.18","0.60","0.59","1.46","0.64","1.44","0.59","1.49","0.84","0.71","1.44","1.11","1.18","1.40","0.64","1.15","1.07","1.35","0.86","1.13","1.41","1.03","0.57","1.44","0.93","1.47","1.16","1.40","1.14","0.97","0.78","1.49","0.59","0.99","1.35","0.88","1.02","1.16","1.07","0.81","0.87","1.34","0.98","1.17","1.46","0.71","1.13","0.80","1.24","0.76","0.68"],["1.04","0.54","0.55","1.05","1.20","1.13","0.53","0.63","0.82","0.52","0.86","0.33","0.64","1.14","0.47","0.72","0.97","1.18","1.02","0.53","1.14","1.24","1.13","0.60","0.47","0.94","0.64","0.43","0.71","0.33","0.46","0.82","0.80","0.97","0.43","1.29","0.65","0.92","0.63","0.58","0.31","1.09","0.35","0.43","1.19","0.47","0.59","0.52","0.79","0.69","0.54","0.39","0.33","1.26","0.40","0.76","0.80","0.96","0.82","1.26","0.70","0.50","0.67","1.27","1.24","0.49","0.94","0.97","0.90","1.03","1.28","0.46","0.57","1.23","0.40","0.71","1.08","0.51","1.03","0.38","0.81","0.44","1.02","0.79","1.08","1.01","0.66","0.80","0.65","0.97","0.56","0.33","0.61","0.92","0.40","0.77","1.05","1.21","0.34","0.84"]];
+
                 chart.setOption({
                     legend: {
                         data: ['bar', 'bar2', 'bar3', 'bar4'],
@@ -57,6 +59,9 @@
                             magicType: {
                                 type: ['line', 'bar', 'stack', 'tiled']
                             },
+                            dataZoom: {
+                                yAxisIndex: false
+                            },
                             dataView: {},
                             saveAsImage: {
                                 pixelRatio: 2
@@ -64,6 +69,15 @@
                         }
                     },
                     tooltip: {},
+                    dataZoom: [{
+                        startValue: 48,
+                        endValue: 99,
+                        type: 'inside'
+                    }, {
+                        startValue: 48,
+                        endValue: 99,
+                        type: 'slider'
+                    }],
                     xAxis: {
                         data: xAxisData,
                         silent: false,
@@ -83,23 +97,23 @@
                         name: 'bar',
                         type: 'bar',
                         stack: 'one',
-                        data: data1
+                        data: data[0]
                     }, {
                         show: false,
                         name: 'bar2',
                         type: 'bar',
                         stack: 'one',
-                        data: data2
+                        data: data[1]
                     }, {
                         name: 'bar3',
                         type: 'bar',
                         stack: 'two',
-                        data: data3
+                        data: data[2]
                     }, {
                         name: 'bar4',
                         type: 'bar',
                         stack: 'two',
-                        data: data4,
+                        data: data[3],
                         silent: true
                     }],
                     animationDelay: function (idx) {

test/bar-polar-basic-radial.html

@@ -34,6 +34,8 @@
                         data: ['周一', '周二', '周三', '周四', '周五', '周六', '周日'],
                         z: 10
                     },
+                    tooltip: {
+                    },
                     radiusAxis: {
                     },
                     polar: {

test/bar-polar-basic.html

@@ -38,6 +38,7 @@
                     },
                     polar: {
                     },
+                    tooltip: {},
                     series: [{
                         type: 'bar',
                         data: [1, 2, 4, 3, 6, 5, 7],

test/bar-polar-multi-series.html

@@ -32,6 +32,7 @@
 
                 chart.setOption({
                     angleAxis: {
+                        // clockwise: false
                     },
                     radiusAxis: {
                         type: 'category',

test/bar-polar-null-data-radial.html

@@ -36,18 +36,22 @@
                     },
                     radiusAxis: {
                     },
-                    polar: {
-                    },
+                    tooltip: {},
+                    legend: {},
+                    polar: {},
                     series: [{
                         type: 'bar',
+                        name: 'A',
                         data: [1, '-', 3, '-'],
                         coordinateSystem: 'polar'
                     }, {
                         type: 'bar',
+                        name: 'B',
                         data: ['-', 4, '-', '-'],
                         coordinateSystem: 'polar'
                     }, {
                         type: 'bar',
+                        name: 'C',
                         data: ['-', '-', 3, 4],
                         coordinateSystem: 'polar'
                     }]

test/bar-stack.html

+<!DOCTYPE>
+<html>
+    <head>
+        <meta charset="utf-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1" />
+        <script src="lib/esl.js"></script>
+        <script src="lib/config.js"></script>
+        <script src="lib/jquery.min.js"></script>
+        <script src="lib/facePrint.js"></script>
+        <script src="lib/testHelper.js"></script>
+        <link rel="stylesheet" href="lib/reset.css">
+    </head>
+    <body>
+        <style>
+            h1 {
+                line-height: 60px;
+                height: 60px;
+                background: #146402;
+                text-align: center;
+                font-weight: bold;
+                color: #eee;
+                font-size: 14px;
+            }
+            .chart {
+                height: 500px;
+            }
+        </style>
+
+
+        <div class="chart" id="main0"></div>
+
+
+
+
+        <script>
+
+            require([
+                'echarts'
+                // 'echarts/chart/line',
+                // 'echarts/chart/bar',
+                // 'echarts/chart/pie',
+                // 'echarts/chart/scatter',
+                // 'echarts/chart/map',
+                // 'echarts/chart/parallel',
+                // 'echarts/chart/radar',
+                // 'echarts/component/grid',
+                // 'echarts/component/polar',
+                // 'echarts/component/geo',
+                // 'echarts/component/singleAxis',
+                // 'echarts/component/legend',
+                // 'echarts/component/tooltip',
+                // 'echarts/component/toolbox',
+                // 'echarts/component/visualMap',
+                // 'echarts/component/dataZoom'
+            ], function (echarts) {
+
+                var option = {
+                    "title": {
+                        "text": "简单柱状图标题",
+                        "left": 16,
+                        "textStyle": {
+                            "fontSize": 14
+                        },
+                        "show": true
+                    },
+                    "tooltip": {
+                        "trigger": "axis",
+                        "axisPointer": {
+                            "type": "shadow"
+                        }
+                    },
+                    "toolbox": {
+                        "show": true,
+                        "feature": {
+                            "dataZoom": {
+                                "yAxisIndex": "none"
+                            },
+                            "dataView": {
+                                "readOnly": false
+                            },
+                            "magicType": {
+                                "type": [
+                                    "line",
+                                    "bar",
+                                    "stack",
+                                    "tiled"
+                                ]
+                            },
+                            "restore": {},
+                            "saveAsImage": {}
+                        }
+                    },
+                    "xAxis": {
+                        type: 'category'
+                    },
+                    "yAxis": {
+                    },
+                    "legend": {
+                        "tooltip": {
+                            "show": false
+                        }
+                    },
+                    dataZoom: [{
+                        type: 'inside'
+                    }, {
+                        type: 'slider'
+                    }],
+                    "series": [{
+                        "type": "bar",
+                        "stack": "all",
+                        "data": [
+                            ["审批通过", 33],
+                            ["审批中", 154],
+                            ["撤回", 13],
+                            ["barMinHeight:10px", 1]
+                        ],
+                        barMinHeight: 10,
+                        label: {
+                            normal: {show: true}
+                        },
+                        "name": "zly13"
+                    }, {
+                        "type": "bar",
+                        "stack": "all",
+                        label: {
+                            normal: {show: true}
+                        },
+                        "data": [
+                            ["哪有那么多审批", 66],
+                            ["审批中", 66],
+                            ["撤回",200],
+                            ["barMinHeight:10px", 100]
+                        ],
+                        "name": "zly0031"
+                    }],
+                    "grid": {
+                        "top": "65px",
+                        "bottom": "10%",
+                        "normalBottom": "10%",
+                        "dataZoomBottom": "90px",
+                        "containLabel": true
+                    }
+                };
+
+                testHelper.createChart(echarts, 'main0', option);
+            });
+
+        </script>
+    </body>
+</html>
\ No newline at end of file

test/dataset-layout.html

@@ -22,6 +22,7 @@
         <div id="layout0"></div>
         <div id="layout1"></div>
         <div id="layout2"></div>
+        <div id="layout3"></div>
 
 
 
@@ -135,6 +136,8 @@
 
 
 
+
+
         <script>
             require(['echarts'], function (echarts) {
 
@@ -203,5 +206,54 @@
 
 
 
+        <script>
+            require(['echarts'], function (echarts) {
+
+                // Thanks to: https://github.com/lzp4ever
+                var option = {
+                    legend: {},
+                    tooltip: {
+                        trigger: 'axis',
+                    },
+                    toolbox: {
+                        top: 25,
+                        // right: 20,
+                        feature: {
+                            magicType: {
+                                type: ['stack', 'tiled']
+                            }
+                        }
+                    },
+                    dataset: {
+                        source: [
+                            ['series', '1', '2', '3', '4', '5', '6'],
+                            ['a', 41.1, 30.4, 65.1, 53.3, 83.8, 98.7],
+                            ['b', 86.5, 92.1, 85.7, 83.1, 73.4, 55.1],
+                            ['c', 24.1, 67.2, 79.5, 86.4, 65.2, 82.5],
+                            ['d', 55.2, 67.1, 69.2, 72.4, 53.9, 39.1],
+                        ],
+                    },
+                    xAxis: { type: 'category' },
+                    yAxis: { gridIndex: 0 },
+                    series: [
+                        { type: 'line', stack: 'sameStack', smooth: true, seriesLayoutBy: 'row', areaStyle: {}, label: {show: true} },
+                        { type: 'line', stack: 'sameStack', smooth: true, seriesLayoutBy: 'row', areaStyle: {}, label: {show: true} },
+                        { type: 'line', stack: 'sameStack', smooth: true, seriesLayoutBy: 'row', areaStyle: {}, label: {show: true} },
+                        { type: 'line', stack: 'sameStack', smooth: true, seriesLayoutBy: 'row', areaStyle: {}, label: {show: true} },
+
+                    ],
+                };
+
+                var chart = testHelper.create(echarts, 'layout3', {
+                    title: 'stack',
+                    option: option,
+                    dataTable: option.dataset.source
+                });
+            });
+        </script>
+
+
+
+
     </body>
 </html>
\ No newline at end of file

test/finished.html

@@ -20,26 +20,26 @@
 
             .snapshot-rendered {
                 position: absolute;
-                right: 10;
-                top: 10;
-                width: 220;
-                height: 200;
+                right: 10px;
+                top: 10px;
+                width: 220px;
+                height: 200px;
                 background: #fff;
                 border: 5px solid rgba(0,0,0,0.5);
             }
             .snapshot-finished {
                 position: absolute;
-                right: 10;
-                bottom: 10;
-                width: 220;
-                height: 200;
+                right: 10px;
+                bottom: 10px;
+                width: 220px;
+                height: 200px;
                 background: #fff;
                 border: 5px solid rgba(0,0,0,0.5);
             }
             .snapshot-info {
                 position: absolute;
-                right: 10;
-                width: 220;
+                right: 10px;
+                width: 220px;
                 text-align: center;
                 background: #333;
                 color: #fff;

test/line-animation.html

@@ -73,7 +73,7 @@
                     var now = new Date(base += oneDay);
                     date.push([now.getFullYear(), now.getMonth() + 1, now.getDate()].join('/'));
                     // data.push(Math.round((Math.random() - 0.5) * 20 + data[i - 1]));
-                    data.push(i * i);
+                    data.push(i * i - 15);
                 }
 
                 option = {
@@ -151,17 +151,16 @@
                                     shadowOffsetY: 10
                                 }
                             },
-                            // areaStyle: {
-                            //     normal: {
-                            //         color: new echarts.graphic.LinearGradient(0, 0, 0, 1, [{
-                            //             offset: 0,
-                            //             color: 'rgb(255, 158, 68)'
-                            //         }, {
-                            //             offset: 1,
-                            //             color: 'rgb(255, 70, 131)'
-                            //         }])
-                            //     }
-                            // },
+                            areaStyle: {
+                                // origin: 'end',
+                                color: new echarts.graphic.LinearGradient(0, 0, 0, 1, [{
+                                    offset: 0,
+                                    color: 'rgb(255, 158, 68)'
+                                }, {
+                                    offset: 1,
+                                    color: 'rgb(255, 70, 131)'
+                                }])
+                            },
                             data: data
                         }
                     ],

test/scatter.html

@@ -112,7 +112,7 @@
                         },
                         itemStyle: {
                             color: function (params) {
-                                return 'rgba(30, 70, 50, ' + params.value[2] + ')';
+                                return 'rgba(30, 70, 50, ' + (params.value ? params.value[2] : 0) + ')';
                             }
                         },
                         data: data2