echarts 3.5.4 → 3.6.0

package/src/layout/barGrid.js

@@ -6,29 +6,96 @@ define(function(require) {
     var numberUtil = require('../util/number');
     var parsePercent = numberUtil.parsePercent;
 
+    var STACK_PREFIX = '__ec_stack_';
+
     function getSeriesStackId(seriesModel) {
-        return seriesModel.get('stack') || '__ec_stack_' + seriesModel.seriesIndex;
+        return seriesModel.get('stack') || STACK_PREFIX + seriesModel.seriesIndex;
     }
 
     function getAxisKey(axis) {
         return axis.dim + axis.index;
     }
 
-    function calBarWidthAndOffset(barSeries, api) {
-        // Columns info on each category axis. Key is cartesian name
-        var columnsMap = {};
+    /**
+     * @param {Object} opt
+     * @param {module:echarts/coord/Axis} opt.axis Only support category axis currently.
+     * @param {number} opt.count Positive interger.
+     * @param {number} [opt.barWidth]
+     * @param {number} [opt.barMaxWidth]
+     * @param {number} [opt.barGap]
+     * @param {number} [opt.barCategoryGap]
+     * @return {Object} {width, offset, offsetCenter} If axis.type is not 'category', return undefined.
+     */
+    function getLayoutOnAxis(opt, api) {
+        var params = [];
+        var baseAxis = opt.axis;
+        var axisKey = 'axis0';
+
+        if (baseAxis.type !== 'category') {
+            return;
+        }
+        var bandWidth = baseAxis.getBandWidth();
+
+        for (var i = 0; i < opt.count || 0; i++) {
+            params.push(zrUtil.defaults({
+                bandWidth: bandWidth,
+                axisKey: axisKey,
+                stackId: STACK_PREFIX + i
+            }, opt));
+        }
+        var widthAndOffsets = doCalBarWidthAndOffset(params, api);
+
+        var result = [];
+        for (var i = 0; i < opt.count; i++) {
+            var item = widthAndOffsets[axisKey][STACK_PREFIX + i];
+            item.offsetCenter = item.offset + item.width / 2;
+            result.push(item);
+        }
 
-        zrUtil.each(barSeries, function (seriesModel, idx) {
+        return result;
+    }
+
+    function calBarWidthAndOffset(barSeries, api) {
+        var seriesInfoList = zrUtil.map(barSeries, function (seriesModel) {
             var data = seriesModel.getData();
             var cartesian = seriesModel.coordinateSystem;
-
             var baseAxis = cartesian.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)] || {
+            var barWidth = parsePercent(
+                seriesModel.get('barWidth'), bandWidth
+            );
+            var barMaxWidth = parsePercent(
+                seriesModel.get('barMaxWidth'), bandWidth
+            );
+            var barGap = seriesModel.get('barGap');
+            var barCategoryGap = seriesModel.get('barCategoryGap');
+
+            return {
+                bandWidth: bandWidth,
+                barWidth: barWidth,
+                barMaxWidth: barMaxWidth,
+                barGap: barGap,
+                barCategoryGap: barCategoryGap,
+                axisKey: getAxisKey(baseAxis),
+                stackId: getSeriesStackId(seriesModel)
+            };
+        });
+
+        return doCalBarWidthAndOffset(seriesInfoList, api);
+    }
+
+    function doCalBarWidthAndOffset(seriesInfoList, api) {
+        // Columns info on each category axis. Key is cartesian name
+        var columnsMap = {};
+
+        zrUtil.each(seriesInfoList, function (seriesInfo, idx) {
+            var axisKey = seriesInfo.axisKey;
+            var bandWidth = seriesInfo.bandWidth;
+            var columnsOnAxis = columnsMap[axisKey] || {
                 bandWidth: bandWidth,
                 remainedWidth: bandWidth,
                 autoWidthCount: 0,
@@ -37,9 +104,9 @@ define(function(require) {
                 stacks: {}
             };
             var stacks = columnsOnAxis.stacks;
-            columnsMap[getAxisKey(baseAxis)] = columnsOnAxis;
+            columnsMap[axisKey] = columnsOnAxis;
 
-            var stackId = getSeriesStackId(seriesModel);
+            var stackId = seriesInfo.stackId;
 
             if (!stacks[stackId]) {
                 columnsOnAxis.autoWidthCount++;
@@ -49,29 +116,24 @@ define(function(require) {
                 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');
-
             // Caution: In a single coordinate system, these barGrid attributes
             // will be shared by series. Consider that they have default values,
             // only the attributes set on the last series will work.
             // Do not change this fact unless there will be a break change.
 
             // TODO
+            var barWidth = seriesInfo.barWidth;
             if (barWidth && !stacks[stackId].width) {
                 barWidth = Math.min(columnsOnAxis.remainedWidth, barWidth);
                 stacks[stackId].width = barWidth;
                 columnsOnAxis.remainedWidth -= barWidth;
             }
 
+            var barMaxWidth = seriesInfo.barMaxWidth;
             barMaxWidth && (stacks[stackId].maxWidth = barMaxWidth);
+            var barGap = seriesInfo.barGap;
             (barGap != null) && (columnsOnAxis.gap = barGap);
+            var barCategoryGap = seriesInfo.barCategoryGap;
             (barCategoryGap != null) && (columnsOnAxis.categoryGap = barCategoryGap);
         });
 
@@ -161,6 +223,11 @@ define(function(require) {
 
         ecModel.eachSeriesByType(seriesType, function (seriesModel) {
 
+            // Check series coordinate, do layout for cartesian2d only
+            if (seriesModel.coordinateSystem.type !== 'cartesian2d') {
+                return;
+            }
+
             var data = seriesModel.getData();
             var cartesian = seriesModel.coordinateSystem;
             var baseAxis = cartesian.getBaseAxis();
@@ -247,5 +314,7 @@ define(function(require) {
         }, this);
     }
 
+    barLayoutGrid.getLayoutOnAxis = getLayoutOnAxis;
+
     return barLayoutGrid;
 });

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);
             }
         });
     };