echarts 4.5.0 → 4.9.0

package/lib/chart/helper/Line.js

@@ -65,19 +65,23 @@ function makeSymbolTypeKey(symbolCategory) {
 
 
 function createSymbol(name, lineData, idx) {
-  var color = lineData.getItemVisual(idx, 'color');
   var symbolType = lineData.getItemVisual(idx, name);
-  var symbolSize = lineData.getItemVisual(idx, name + 'Size');
 
   if (!symbolType || symbolType === 'none') {
     return;
   }
 
+  var color = lineData.getItemVisual(idx, 'color');
+  var symbolSize = lineData.getItemVisual(idx, name + 'Size');
+  var symbolRotate = lineData.getItemVisual(idx, name + 'Rotate');
+
   if (!zrUtil.isArray(symbolSize)) {
     symbolSize = [symbolSize, symbolSize];
   }
 
-  var symbolPath = symbolUtil.createSymbol(symbolType, -symbolSize[0] / 2, -symbolSize[1] / 2, symbolSize[0], symbolSize[1], color);
+  var symbolPath = symbolUtil.createSymbol(symbolType, -symbolSize[0] / 2, -symbolSize[1] / 2, symbolSize[0], symbolSize[1], color); // rotate by default if symbolRotate is not specified or NaN
+
+  symbolPath.__specifiedRotation = symbolRotate == null || isNaN(symbolRotate) ? void 0 : +symbolRotate * Math.PI / 180 || 0;
   symbolPath.name = name;
   return symbolPath;
 }
@@ -143,16 +147,38 @@ function updateSymbolAndLabelBeforeLineUpdate() {
   vector.normalize(d, d);
 
   if (symbolFrom) {
-    symbolFrom.attr('position', fromPos);
-    var tangent = line.tangentAt(0);
-    symbolFrom.attr('rotation', Math.PI / 2 - Math.atan2(tangent[1], tangent[0]));
+    symbolFrom.attr('position', fromPos); // Fix #12388
+    // when symbol is set to be 'arrow' in markLine,
+    // symbolRotate value will be ignored, and compulsively use tangent angle.
+    // rotate by default if symbol rotation is not specified
+
+    var specifiedRotation = symbolFrom.__specifiedRotation;
+
+    if (specifiedRotation == null) {
+      var tangent = line.tangentAt(0);
+      symbolFrom.attr('rotation', Math.PI / 2 - Math.atan2(tangent[1], tangent[0]));
+    } else {
+      symbolFrom.attr('rotation', specifiedRotation);
+    }
+
     symbolFrom.attr('scale', [invScale * percent, invScale * percent]);
   }
 
   if (symbolTo) {
-    symbolTo.attr('position', toPos);
-    var tangent = line.tangentAt(1);
-    symbolTo.attr('rotation', -Math.PI / 2 - Math.atan2(tangent[1], tangent[0]));
+    symbolTo.attr('position', toPos); // Fix #12388
+    // when symbol is set to be 'arrow' in markLine,
+    // symbolRotate value will be ignored, and compulsively use tangent angle.
+    // rotate by default if symbol rotation is not specified
+
+    var specifiedRotation = symbolTo.__specifiedRotation;
+
+    if (specifiedRotation == null) {
+      var tangent = line.tangentAt(1);
+      symbolTo.attr('rotation', -Math.PI / 2 - Math.atan2(tangent[1], tangent[0]));
+    } else {
+      symbolTo.attr('rotation', specifiedRotation);
+    }
+
     symbolTo.attr('scale', [invScale * percent, invScale * percent]);
   }
 
@@ -161,40 +187,93 @@ function updateSymbolAndLabelBeforeLineUpdate() {
     var textPosition;
     var textAlign;
     var textVerticalAlign;
-    var distance = 5 * invScale; // End
-
-    if (label.__position === 'end') {
-      textPosition = [d[0] * distance + toPos[0], d[1] * distance + toPos[1]];
-      textAlign = d[0] > 0.8 ? 'left' : d[0] < -0.8 ? 'right' : 'center';
-      textVerticalAlign = d[1] > 0.8 ? 'top' : d[1] < -0.8 ? 'bottom' : 'middle';
-    } // Middle
-    else if (label.__position === 'middle') {
-        var halfPercent = percent / 2;
-        var tangent = line.tangentAt(halfPercent);
-        var n = [tangent[1], -tangent[0]];
-        var cp = line.pointAt(halfPercent);
-
-        if (n[1] > 0) {
-          n[0] = -n[0];
-          n[1] = -n[1];
-        }
-
-        textPosition = [cp[0] + n[0] * distance, cp[1] + n[1] * distance];
-        textAlign = 'center';
-        textVerticalAlign = 'bottom';
-        var rotation = -Math.atan2(tangent[1], tangent[0]);
+    var textOrigin;
+    var distance = label.__labelDistance;
+    var distanceX = distance[0] * invScale;
+    var distanceY = distance[1] * invScale;
+    var halfPercent = percent / 2;
+    var tangent = line.tangentAt(halfPercent);
+    var n = [tangent[1], -tangent[0]];
+    var cp = line.pointAt(halfPercent);
+
+    if (n[1] > 0) {
+      n[0] = -n[0];
+      n[1] = -n[1];
+    }
 
-        if (toPos[0] < fromPos[0]) {
-          rotation = Math.PI + rotation;
-        }
+    var dir = tangent[0] < 0 ? -1 : 1;
 
-        label.attr('rotation', rotation);
-      } // Start
-      else {
-          textPosition = [-d[0] * distance + fromPos[0], -d[1] * distance + fromPos[1]];
-          textAlign = d[0] > 0.8 ? 'right' : d[0] < -0.8 ? 'left' : 'center';
-          textVerticalAlign = d[1] > 0.8 ? 'bottom' : d[1] < -0.8 ? 'top' : 'middle';
-        }
+    if (label.__position !== 'start' && label.__position !== 'end') {
+      var rotation = -Math.atan2(tangent[1], tangent[0]);
+
+      if (toPos[0] < fromPos[0]) {
+        rotation = Math.PI + rotation;
+      }
+
+      label.attr('rotation', rotation);
+    }
+
+    var dy;
+
+    switch (label.__position) {
+      case 'insideStartTop':
+      case 'insideMiddleTop':
+      case 'insideEndTop':
+      case 'middle':
+        dy = -distanceY;
+        textVerticalAlign = 'bottom';
+        break;
+
+      case 'insideStartBottom':
+      case 'insideMiddleBottom':
+      case 'insideEndBottom':
+        dy = distanceY;
+        textVerticalAlign = 'top';
+        break;
+
+      default:
+        dy = 0;
+        textVerticalAlign = 'middle';
+    }
+
+    switch (label.__position) {
+      case 'end':
+        textPosition = [d[0] * distanceX + toPos[0], d[1] * distanceY + toPos[1]];
+        textAlign = d[0] > 0.8 ? 'left' : d[0] < -0.8 ? 'right' : 'center';
+        textVerticalAlign = d[1] > 0.8 ? 'top' : d[1] < -0.8 ? 'bottom' : 'middle';
+        break;
+
+      case 'start':
+        textPosition = [-d[0] * distanceX + fromPos[0], -d[1] * distanceY + fromPos[1]];
+        textAlign = d[0] > 0.8 ? 'right' : d[0] < -0.8 ? 'left' : 'center';
+        textVerticalAlign = d[1] > 0.8 ? 'bottom' : d[1] < -0.8 ? 'top' : 'middle';
+        break;
+
+      case 'insideStartTop':
+      case 'insideStart':
+      case 'insideStartBottom':
+        textPosition = [distanceX * dir + fromPos[0], fromPos[1] + dy];
+        textAlign = tangent[0] < 0 ? 'right' : 'left';
+        textOrigin = [-distanceX * dir, -dy];
+        break;
+
+      case 'insideMiddleTop':
+      case 'insideMiddle':
+      case 'insideMiddleBottom':
+      case 'middle':
+        textPosition = [cp[0], cp[1] + dy];
+        textAlign = 'center';
+        textOrigin = [0, -dy];
+        break;
+
+      case 'insideEndTop':
+      case 'insideEnd':
+      case 'insideEndBottom':
+        textPosition = [-distanceX * dir + toPos[0], toPos[1] + dy];
+        textAlign = tangent[0] >= 0 ? 'right' : 'left';
+        textOrigin = [distanceX * dir, -dy];
+        break;
+    }
 
     label.attr({
       style: {
@@ -203,7 +282,8 @@ function updateSymbolAndLabelBeforeLineUpdate() {
         textAlign: label.__textAlign || textAlign
       },
       position: textPosition,
-      scale: [invScale, invScale]
+      scale: [invScale, invScale],
+      origin: textOrigin
     });
   }
 }
@@ -347,6 +427,13 @@ lineProto._updateCommonStl = function (lineData, idx, seriesScope) {
     label.__verticalAlign = labelStyle.textVerticalAlign; // 'start', 'middle', 'end'
 
     label.__position = labelModel.get('position') || 'middle';
+    var distance = labelModel.get('distance');
+
+    if (!zrUtil.isArray(distance)) {
+      distance = [distance, distance];
+    }
+
+    label.__labelDistance = distance;
   }
 
   if (emphasisText != null) {

package/lib/chart/helper/LineDraw.js

@@ -134,9 +134,13 @@ lineDrawProto.incrementalPrepareUpdate = function (lineData) {
   this.group.removeAll();
 };
 
+function isEffectObject(el) {
+  return el.animators && el.animators.length > 0;
+}
+
 lineDrawProto.incrementalUpdate = function (taskParams, lineData) {
   function updateIncrementalAndHover(el) {
-    if (!el.isGroup) {
+    if (!el.isGroup && !isEffectObject(el)) {
       el.incremental = el.useHoverLayer = true;
     }
   }

package/lib/chart/helper/Symbol.js

@@ -257,7 +257,7 @@ symbolProto._updateCommon = function (data, idx, symbolSize, seriesScope) {
     });
   } else {
     symbolPath.setStyle({
-      opacity: null,
+      opacity: 1,
       shadowBlur: null,
       shadowOffsetX: null,
       shadowOffsetY: null,
@@ -267,7 +267,6 @@ symbolProto._updateCommon = function (data, idx, symbolSize, seriesScope) {
 
   var itemStyle = seriesScope && seriesScope.itemStyle;
   var hoverItemStyle = seriesScope && seriesScope.hoverItemStyle;
-  var symbolRotate = seriesScope && seriesScope.symbolRotate;
   var symbolOffset = seriesScope && seriesScope.symbolOffset;
   var labelModel = seriesScope && seriesScope.labelModel;
   var hoverLabelModel = seriesScope && seriesScope.hoverLabelModel;
@@ -280,7 +279,6 @@ symbolProto._updateCommon = function (data, idx, symbolSize, seriesScope) {
 
     itemStyle = itemModel.getModel(normalStyleAccessPath).getItemStyle(['color']);
     hoverItemStyle = itemModel.getModel(emphasisStyleAccessPath).getItemStyle();
-    symbolRotate = itemModel.getShallow('symbolRotate');
     symbolOffset = itemModel.getShallow('symbolOffset');
     labelModel = itemModel.getModel(normalLabelAccessPath);
     hoverLabelModel = itemModel.getModel(emphasisLabelAccessPath);
@@ -291,6 +289,7 @@ symbolProto._updateCommon = function (data, idx, symbolSize, seriesScope) {
   }
 
   var elStyle = symbolPath.style;
+  var symbolRotate = data.getItemVisual(idx, 'symbolRotate');
   symbolPath.attr('rotation', (symbolRotate || 0) * Math.PI / 180 || 0);
 
   if (symbolOffset) {

package/lib/chart/helper/createClipPathFromCoordSys.js

@@ -54,7 +54,10 @@ function createGridClipPath(cartesian, hasAnimation, seriesModel) {
   x -= lineWidth / 2;
   y -= lineWidth / 2;
   width += lineWidth;
-  height += lineWidth;
+  height += lineWidth; // fix: https://github.com/apache/incubator-echarts/issues/11369
+
+  x = Math.floor(x);
+  width = Math.round(width);
   var clipPath = new graphic.Rect({
     shape: {
       x: x,

package/lib/chart/helper/createListFromArray.js

@@ -40,7 +40,7 @@ var CoordinateSystem = require("../../CoordinateSystem");
 
 var _referHelper = require("../../model/referHelper");
 
-var getCoordSysDefineBySeries = _referHelper.getCoordSysDefineBySeries;
+var getCoordSysInfoBySeries = _referHelper.getCoordSysInfoBySeries;
 
 var Source = require("../../data/Source");
 
@@ -48,6 +48,10 @@ var _dataStackHelper = require("../../data/helper/dataStackHelper");
 
 var enableDataStack = _dataStackHelper.enableDataStack;
 
+var _sourceHelper = require("../../data/helper/sourceHelper");
+
+var makeSeriesEncodeForAxisCoordSys = _sourceHelper.makeSeriesEncodeForAxisCoordSys;
+
 /*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
@@ -72,6 +76,7 @@ var enableDataStack = _dataStackHelper.enableDataStack;
  * @param {module:echarts/model/Series} seriesModel
  * @param {Object} [opt]
  * @param {string} [opt.generateCoord]
+ * @param {boolean} [opt.useEncodeDefaulter]
  */
 function createListFromArray(source, seriesModel, opt) {
   opt = opt || {};
@@ -82,15 +87,15 @@ function createListFromArray(source, seriesModel, opt) {
 
   var coordSysName = seriesModel.get('coordinateSystem');
   var registeredCoordSys = CoordinateSystem.get(coordSysName);
-  var coordSysDefine = getCoordSysDefineBySeries(seriesModel);
+  var coordSysInfo = getCoordSysInfoBySeries(seriesModel);
   var coordSysDimDefs;
 
-  if (coordSysDefine) {
-    coordSysDimDefs = zrUtil.map(coordSysDefine.coordSysDims, function (dim) {
+  if (coordSysInfo) {
+    coordSysDimDefs = zrUtil.map(coordSysInfo.coordSysDims, function (dim) {
       var dimInfo = {
         name: dim
       };
-      var axisModel = coordSysDefine.axisMap.get(dim);
+      var axisModel = coordSysInfo.axisMap.get(dim);
 
       if (axisModel) {
         var axisType = axisModel.get('type');
@@ -108,13 +113,14 @@ function createListFromArray(source, seriesModel, opt) {
 
   var dimInfoList = createDimensions(source, {
     coordDimensions: coordSysDimDefs,
-    generateCoord: opt.generateCoord
+    generateCoord: opt.generateCoord,
+    encodeDefaulter: opt.useEncodeDefaulter ? zrUtil.curry(makeSeriesEncodeForAxisCoordSys, coordSysDimDefs, seriesModel) : null
   });
   var firstCategoryDimIndex;
   var hasNameEncode;
-  coordSysDefine && zrUtil.each(dimInfoList, function (dimInfo, dimIndex) {
+  coordSysInfo && zrUtil.each(dimInfoList, function (dimInfo, dimIndex) {
     var coordDim = dimInfo.coordDim;
-    var categoryAxisModel = coordSysDefine.categoryAxisMap.get(coordDim);
+    var categoryAxisModel = coordSysInfo.categoryAxisMap.get(coordDim);
 
     if (categoryAxisModel) {
       if (firstCategoryDimIndex == null) {

package/lib/chart/helper/createRenderPlanner.js

@@ -50,9 +50,12 @@ function _default() {
     var fields = inner(seriesModel);
     var pipelineContext = seriesModel.pipelineContext;
     var originalLarge = fields.large;
-    var originalProgressive = fields.progressiveRender;
-    var large = fields.large = pipelineContext.large;
-    var progressive = fields.progressiveRender = pipelineContext.progressiveRender;
+    var originalProgressive = fields.progressiveRender; // FIXME: if the planner works on a filtered series, `pipelineContext` does not
+    // exists. See #11611 . Probably we need to modify this structure, see the comment
+    // on `performRawSeries` in `Schedular.js`.
+
+    var large = fields.large = pipelineContext && pipelineContext.large;
+    var progressive = fields.progressiveRender = pipelineContext && pipelineContext.progressiveRender;
     return !!(originalLarge ^ large || originalProgressive ^ progressive) && 'reset';
   };
 }

package/lib/chart/helper/multipleGraphEdgeHelper.js

@@ -0,0 +1,258 @@
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+
+var zrUtil = require("zrender/lib/core/util");
+
+/*
+* Licensed to the Apache Software Foundation (ASF) under one
+* or more contributor license agreements.  See the NOTICE file
+* distributed with this work for additional information
+* regarding copyright ownership.  The ASF licenses this file
+* to you under the Apache License, Version 2.0 (the
+* "License"); you may not use this file except in compliance
+* with the License.  You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an
+* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+* KIND, either express or implied.  See the License for the
+* specific language governing permissions and limitations
+* under the License.
+*/
+var KEY_DELIMITER = '-->';
+/**
+ * params handler
+ * @param {module:echarts/model/SeriesModel} seriesModel
+ * @returns {*}
+ */
+
+var getAutoCurvenessParams = function (seriesModel) {
+  return seriesModel.get('autoCurveness') || null;
+};
+/**
+ * Generate a list of edge curvatures, 20 is the default
+ * @param {module:echarts/model/SeriesModel} seriesModel
+ * @param {number} appendLength
+ * @return  20 => [0, -0.2, 0.2, -0.4, 0.4, -0.6, 0.6, -0.8, 0.8, -1, 1, -1.2, 1.2, -1.4, 1.4, -1.6, 1.6, -1.8, 1.8, -2]
+ */
+
+
+var createCurveness = function (seriesModel, appendLength) {
+  var autoCurvenessParmas = getAutoCurvenessParams(seriesModel);
+  var length = 20;
+  var curvenessList = []; // handler the function set
+
+  if (typeof autoCurvenessParmas === 'number') {
+    length = autoCurvenessParmas;
+  } else if (zrUtil.isArray(autoCurvenessParmas)) {
+    seriesModel.__curvenessList = autoCurvenessParmas;
+    return;
+  } // append length
+
+
+  if (appendLength > length) {
+    length = appendLength;
+  } // make sure the length is even
+
+
+  var len = length % 2 ? length + 2 : length + 3;
+  curvenessList = [];
+
+  for (var i = 0; i < len; i++) {
+    curvenessList.push((i % 2 ? i + 1 : i) / 10 * (i % 2 ? -1 : 1));
+  }
+
+  seriesModel.__curvenessList = curvenessList;
+};
+/**
+ * Create different cache key data in the positive and negative directions, in order to set the curvature later
+ * @param {number|string|module:echarts/data/Graph.Node} n1
+ * @param {number|string|module:echarts/data/Graph.Node} n2
+ * @param {module:echarts/model/SeriesModel} seriesModel
+ * @returns {string} key
+ */
+
+
+var getKeyOfEdges = function (n1, n2, seriesModel) {
+  var source = [n1.id, n1.dataIndex].join('.');
+  var target = [n2.id, n2.dataIndex].join('.');
+  return [seriesModel.uid, source, target].join(KEY_DELIMITER);
+};
+/**
+ * get opposite key
+ * @param {string} key
+ * @returns {string}
+ */
+
+
+var getOppositeKey = function (key) {
+  var keys = key.split(KEY_DELIMITER);
+  return [keys[0], keys[2], keys[1]].join(KEY_DELIMITER);
+};
+/**
+ * get edgeMap with key
+ * @param edge
+ * @param {module:echarts/model/SeriesModel} seriesModel
+ */
+
+
+var getEdgeFromMap = function (edge, seriesModel) {
+  var key = getKeyOfEdges(edge.node1, edge.node2, seriesModel);
+  return seriesModel.__edgeMap[key];
+};
+/**
+ * calculate all cases total length
+ * @param edge
+ * @param seriesModel
+ * @returns {number}
+ */
+
+
+var getTotalLengthBetweenNodes = function (edge, seriesModel) {
+  var len = getEdgeMapLengthWithKey(getKeyOfEdges(edge.node1, edge.node2, seriesModel), seriesModel);
+  var lenV = getEdgeMapLengthWithKey(getKeyOfEdges(edge.node2, edge.node1, seriesModel), seriesModel);
+  return len + lenV;
+};
+/**
+ *
+ * @param key
+ */
+
+
+var getEdgeMapLengthWithKey = function (key, seriesModel) {
+  var edgeMap = seriesModel.__edgeMap;
+  return edgeMap[key] ? edgeMap[key].length : 0;
+};
+/**
+ * Count the number of edges between the same two points, used to obtain the curvature table and the parity of the edge
+ * @see /graph/GraphSeries.js@getInitialData
+ * @param {module:echarts/model/SeriesModel} seriesModel
+ */
+
+
+function initCurvenessList(seriesModel) {
+  if (!getAutoCurvenessParams(seriesModel)) {
+    return;
+  }
+
+  seriesModel.__curvenessList = [];
+  seriesModel.__edgeMap = {}; // calc the array of curveness List
+
+  createCurveness(seriesModel);
+}
+/**
+ * set edgeMap with key
+ * @param {number|string|module:echarts/data/Graph.Node} n1
+ * @param {number|string|module:echarts/data/Graph.Node} n2
+ * @param {module:echarts/model/SeriesModel} seriesModel
+ * @param {number} index
+ */
+
+
+function createEdgeMapForCurveness(n1, n2, seriesModel, index) {
+  if (!getAutoCurvenessParams(seriesModel)) {
+    return;
+  }
+
+  var key = getKeyOfEdges(n1, n2, seriesModel);
+  var edgeMap = seriesModel.__edgeMap;
+  var oppositeEdges = edgeMap[getOppositeKey(key)]; // set direction
+
+  if (edgeMap[key] && !oppositeEdges) {
+    edgeMap[key].isForward = true;
+  } else if (oppositeEdges && edgeMap[key]) {
+    oppositeEdges.isForward = true;
+    edgeMap[key].isForward = false;
+  }
+
+  edgeMap[key] = edgeMap[key] || [];
+  edgeMap[key].push(index);
+}
+/**
+ * get curvature for edge
+ * @param edge
+ * @param {module:echarts/model/SeriesModel} seriesModel
+ * @param index
+ */
+
+
+function getCurvenessForEdge(edge, seriesModel, index, needReverse) {
+  var autoCurvenessParams = getAutoCurvenessParams(seriesModel);
+  var isArrayParam = zrUtil.isArray(autoCurvenessParams);
+
+  if (!autoCurvenessParams) {
+    return null;
+  }
+
+  var edgeArray = getEdgeFromMap(edge, seriesModel);
+
+  if (!edgeArray) {
+    return null;
+  }
+
+  var edgeIndex = -1;
+
+  for (var i = 0; i < edgeArray.length; i++) {
+    if (edgeArray[i] === index) {
+      edgeIndex = i;
+      break;
+    }
+  } // if totalLen is Longer createCurveness
+
+
+  var totalLen = getTotalLengthBetweenNodes(edge, seriesModel);
+  createCurveness(seriesModel, totalLen);
+  edge.lineStyle = edge.lineStyle || {}; // if is opposite edge, must set curvenss to opposite number
+
+  var curKey = getKeyOfEdges(edge.node1, edge.node2, seriesModel);
+  var curvenessList = seriesModel.__curvenessList; // if pass array no need parity
+
+  var parityCorrection = isArrayParam ? 0 : totalLen % 2 ? 0 : 1;
+
+  if (!edgeArray.isForward) {
+    // the opposite edge show outside
+    var oppositeKey = getOppositeKey(curKey);
+    var len = getEdgeMapLengthWithKey(oppositeKey, seriesModel);
+    var resValue = curvenessList[edgeIndex + len + parityCorrection]; // isNeedReverse, simple, force type need reverse the curveness in the junction of the forword and the opposite
+
+    if (needReverse) {
+      // set as array may make the parity handle with the len of opposite
+      if (isArrayParam) {
+        if (autoCurvenessParams && autoCurvenessParams[0] === 0) {
+          return (len + parityCorrection) % 2 ? resValue : -resValue;
+        } else {
+          return ((len % 2 ? 0 : 1) + parityCorrection) % 2 ? resValue : -resValue;
+        }
+      } else {
+        return (len + parityCorrection) % 2 ? resValue : -resValue;
+      }
+    } else {
+      return curvenessList[edgeIndex + len + parityCorrection];
+    }
+  } else {
+    return curvenessList[parityCorrection + edgeIndex];
+  }
+}
+
+exports.initCurvenessList = initCurvenessList;
+exports.createEdgeMapForCurveness = createEdgeMapForCurveness;
+exports.getCurvenessForEdge = getCurvenessForEdge;

package/lib/chart/helper/whiskerBoxCommon.js

@@ -26,6 +26,10 @@ var _dimensionHelper = require("../../data/helper/dimensionHelper");
 
 var getDimensionTypeByAxis = _dimensionHelper.getDimensionTypeByAxis;
 
+var _sourceHelper = require("../../data/helper/sourceHelper");
+
+var makeSeriesEncodeForAxisCoordSys = _sourceHelper.makeSeriesEncodeForAxisCoordSys;
+
 /*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
@@ -64,7 +68,7 @@ var seriesModelMixin = {
     var xAxisType = xAxisModel.get('type');
     var yAxisType = yAxisModel.get('type');
     var addOrdinal; // FIXME
-    // 考虑时间轴
+    // Consider time axis.
 
     if (xAxisType === 'category') {
       option.layout = 'horizontal';
@@ -109,22 +113,24 @@ var seriesModelMixin = {
     }
 
     var defaultValueDimensions = this.defaultValueDimensions;
+    var coordDimensions = [{
+      name: baseAxisDim,
+      type: getDimensionTypeByAxis(baseAxisType),
+      ordinalMeta: ordinalMeta,
+      otherDims: {
+        tooltip: false,
+        itemName: 0
+      },
+      dimsDef: ['base']
+    }, {
+      name: otherAxisDim,
+      type: getDimensionTypeByAxis(otherAxisType),
+      dimsDef: defaultValueDimensions.slice()
+    }];
     return createListSimply(this, {
-      coordDimensions: [{
-        name: baseAxisDim,
-        type: getDimensionTypeByAxis(baseAxisType),
-        ordinalMeta: ordinalMeta,
-        otherDims: {
-          tooltip: false,
-          itemName: 0
-        },
-        dimsDef: ['base']
-      }, {
-        name: otherAxisDim,
-        type: getDimensionTypeByAxis(otherAxisType),
-        dimsDef: defaultValueDimensions.slice()
-      }],
-      dimensionsCount: defaultValueDimensions.length + 1
+      coordDimensions: coordDimensions,
+      dimensionsCount: defaultValueDimensions.length + 1,
+      encodeDefaulter: zrUtil.curry(makeSeriesEncodeForAxisCoordSys, coordDimensions, this)
     });
   },