echarts 4.0.1 → 4.1.0

package/lib/chart/line/LineSeries.js

@@ -6,6 +6,24 @@ var createListFromArray = require("../helper/createListFromArray");
 
 var SeriesModel = require("../../model/Series");
 
+/*
+* 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 _default = SeriesModel.extend({
   type: 'series.line',
   dependencies: ['grid', 'polar'],
@@ -14,9 +32,7 @@ var _default = SeriesModel.extend({
   },
   defaultOption: {
     zlevel: 0,
-    // 一级层叠
     z: 2,
-    // 二级层叠
     coordinateSystem: 'cartesian2d',
     legendHoverLink: true,
     hoverAnimation: true,
@@ -36,25 +52,30 @@ var _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,
     // Disabled if step is true
     smooth: false,
     smoothMonotone: null,
-    // 拐点图形类型
     symbol: 'emptyCircle',
-    // 拐点图形大小
     symbolSize: 4,
-    // 拐点图形旋转控制
     symbolRotate: null,
-    // 是否显示 symbol, 只有在 tooltip hover 的时候显示
     showSymbol: true,
-    // 标志图形默认只有主轴显示（随主轴标签间隔隐藏策略）
-    showAllSymbol: false,
-    // 是否连接断点
+    // `false`: follow the label interval strategy.
+    // `true`: show all symbols.
+    // `'auto'`: If possible, show all symbols, otherwise
+    //           follow the label interval strategy.
+    showAllSymbol: 'auto',
+    // Whether to connect break point.
     connectNulls: false,
-    // 数据过滤，'average', 'max', 'min', 'sum'
+    // Sampling for large data. Can be: 'average', 'max', 'min', 'sum'.
     sampling: 'none',
     animationEasing: 'linear',
     // Disable progressive

package/lib/chart/line/LineView.js

@@ -21,6 +21,33 @@ var Polygon = _poly.Polygon;
 
 var ChartView = require("../../view/Chart");
 
+var _number = require("../../util/number");
+
+var round = _number.round;
+
+var _helper = require("./helper");
+
+var prepareDataCoordInfo = _helper.prepareDataCoordInfo;
+var getStackedOnPoint = _helper.getStackedOnPoint;
+
+/*
+* 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.
+*/
 // FIXME step not support polar
 function isPointsSame(points1, points2) {
   if (points1.length !== points2.length) {
@@ -40,7 +67,7 @@ function isPointsSame(points1, points2) {
 }
 
 function getSmooth(smooth) {
-  return typeof smooth === 'number' ? smooth : smooth ? 0.3 : 0;
+  return typeof smooth === 'number' ? smooth : smooth ? 0.5 : 0;
 }
 
 function getAxisExtentWithGap(axis) {
@@ -56,84 +83,55 @@ 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
+  var points = [];
 
-    while (stackedOn && sign(stackedOn.get(valueDim, idx)) === sign(val)) {
-      stackedOnSameSign = stackedOn;
-      break;
-    }
+  for (var idx = 0, len = data.count(); idx < len; idx++) {
+    points.push(getStackedOnPoint(dataCoordInfo, coordSys, data, idx));
+  }
 
-    var stackedData = [];
-    stackedData[baseDataOffset] = data.get(baseAxis.dim, idx);
-    stackedData[1 - baseDataOffset] = stackedOnSameSign ? stackedOnSameSign.get(valueDim, idx, true) : valueStart;
-    return coordSys.dataToPoint(stackedData);
-  }, true);
+  return points;
 }
 
-function createGridClipShape(cartesian, hasAnimation, seriesModel) {
+function createGridClipShape(cartesian, hasAnimation, forSymbol, seriesModel) {
   var xExtent = getAxisExtentWithGap(cartesian.getAxis('x'));
   var yExtent = getAxisExtentWithGap(cartesian.getAxis('y'));
   var isHorizontal = cartesian.getBaseAxis().isHorizontal();
   var x = Math.min(xExtent[0], xExtent[1]);
   var y = Math.min(yExtent[0], yExtent[1]);
   var width = Math.max(xExtent[0], xExtent[1]) - x;
-  var height = Math.max(yExtent[0], yExtent[1]) - y;
-  var lineWidth = seriesModel.get('lineStyle.width') || 2; // Expand clip shape to avoid clipping when line value exceeds axis
+  var height = Math.max(yExtent[0], yExtent[1]) - y; // Avoid float number rounding error for symbol on the edge of axis extent.
+  // See #7913 and `test/dataZoom-clip.html`.
+
+  if (forSymbol) {
+    x -= 0.5;
+    width += 0.5;
+    y -= 0.5;
+    height += 0.5;
+  } else {
+    var lineWidth = seriesModel.get('lineStyle.width') || 2; // Expand clip shape to avoid clipping when line value exceeds axis
 
-  var expandSize = seriesModel.get('clipOverflow') ? lineWidth / 2 : Math.max(width, height);
+    var expandSize = seriesModel.get('clipOverflow') ? lineWidth / 2 : Math.max(width, height);
 
-  if (isHorizontal) {
-    y -= expandSize;
-    height += expandSize * 2;
-  } else {
-    x -= expandSize;
-    width += expandSize * 2;
+    if (isHorizontal) {
+      y -= expandSize;
+      height += expandSize * 2;
+    } else {
+      x -= expandSize;
+      width += expandSize * 2;
+    }
   }
 
   var clipPath = new graphic.Rect({
@@ -158,18 +156,25 @@ function createGridClipShape(cartesian, hasAnimation, seriesModel) {
   return clipPath;
 }
 
-function createPolarClipShape(polar, hasAnimation, seriesModel) {
+function createPolarClipShape(polar, hasAnimation, forSymbol, seriesModel) {
   var angleAxis = polar.getAngleAxis();
   var radiusAxis = polar.getRadiusAxis();
-  var radiusExtent = radiusAxis.getExtent();
+  var radiusExtent = radiusAxis.getExtent().slice();
+  radiusExtent[0] > radiusExtent[1] && radiusExtent.reverse();
   var angleExtent = angleAxis.getExtent();
-  var RADIAN = Math.PI / 180;
+  var RADIAN = Math.PI / 180; // Avoid float number rounding error for symbol on the edge of axis extent.
+
+  if (forSymbol) {
+    radiusExtent[0] -= 0.5;
+    radiusExtent[1] += 0.5;
+  }
+
   var clipPath = new graphic.Sector({
     shape: {
-      cx: polar.cx,
-      cy: polar.cy,
-      r0: radiusExtent[0],
-      r: radiusExtent[1],
+      cx: round(polar.cx, 1),
+      cy: round(polar.cy, 1),
+      r0: round(radiusExtent[0], 1),
+      r: round(radiusExtent[1], 1),
       startAngle: -angleExtent[0] * RADIAN,
       endAngle: -angleExtent[1] * RADIAN,
       clockwise: angleAxis.inverse
@@ -188,8 +193,8 @@ function createPolarClipShape(polar, hasAnimation, seriesModel) {
   return clipPath;
 }
 
-function createClipShape(coordSys, hasAnimation, seriesModel) {
-  return coordSys.type === 'polar' ? createPolarClipShape(coordSys, hasAnimation, seriesModel) : createGridClipShape(coordSys, hasAnimation, seriesModel);
+function createClipShape(coordSys, hasAnimation, forSymbol, seriesModel) {
+  return coordSys.type === 'polar' ? createPolarClipShape(coordSys, hasAnimation, forSymbol, seriesModel) : createGridClipShape(coordSys, hasAnimation, forSymbol, seriesModel);
 }
 
 function turnPointsIntoStep(points, coordSys, stepTurnAt) {
@@ -243,17 +248,26 @@ function getVisualGradient(data, coordSys) {
     return;
   }
 
+  if (coordSys.type !== 'cartesian2d') {
+    return;
+  }
+
+  var coordDim;
   var visualMeta;
 
   for (var i = visualMetaList.length - 1; i >= 0; i--) {
-    // Can only be x or y
-    if (visualMetaList[i].dimension < 2) {
+    var dimIndex = visualMetaList[i].dimension;
+    var dimName = data.dimensions[dimIndex];
+    var dimInfo = data.getDimensionInfo(dimName);
+    coordDim = dimInfo && dimInfo.coordDim; // Can only be x or y
+
+    if (coordDim === 'x' || coordDim === 'y') {
       visualMeta = visualMetaList[i];
       break;
     }
   }
 
-  if (!visualMeta || coordSys.type !== 'cartesian2d') {
+  if (!visualMeta) {
     return;
   } // If the area to be rendered is bigger than area defined by LinearGradient,
   // the canvas spec prescribes that the color of the first stop and the last
@@ -263,9 +277,7 @@ function getVisualGradient(data, coordSys) {
   // LinearGradient to render `outerColors`.
 
 
-  var dimension = visualMeta.dimension;
-  var dimName = data.dimensions[dimension];
-  var axis = coordSys.getAxis(dimName); // dataToCoor mapping may not be linear, but must be monotonic.
+  var axis = coordSys.getAxis(coordDim); // dataToCoor mapping may not be linear, but must be monotonic.
 
   var colorStops = zrUtil.map(visualMeta.stops, function (stop) {
     return {
@@ -308,11 +320,68 @@ function getVisualGradient(data, coordSys) {
   // });
 
   var gradient = new graphic.LinearGradient(0, 0, 0, 0, colorStops, true);
-  gradient[dimName] = minCoord;
-  gradient[dimName + '2'] = maxCoord;
+  gradient[coordDim] = minCoord;
+  gradient[coordDim + '2'] = maxCoord;
   return gradient;
 }
 
+function getIsIgnoreFunc(seriesModel, data, coordSys) {
+  var showAllSymbol = seriesModel.get('showAllSymbol');
+  var isAuto = showAllSymbol === 'auto';
+
+  if (showAllSymbol && !isAuto) {
+    return;
+  }
+
+  var categoryAxis = coordSys.getAxesByScale('ordinal')[0];
+
+  if (!categoryAxis) {
+    return;
+  } // Note that category label interval strategy might bring some weird effect
+  // in some scenario: users may wonder why some of the symbols are not
+  // displayed. So we show all symbols as possible as we can.
+
+
+  if (isAuto // Simplify the logic, do not determine label overlap here.
+  && canShowAllSymbolForCategory(categoryAxis, data)) {
+    return;
+  } // Otherwise follow the label interval strategy on category axis.
+
+
+  var categoryDataDim = data.mapDimension(categoryAxis.dim);
+  var labelMap = {};
+  zrUtil.each(categoryAxis.getViewLabels(), function (labelItem) {
+    labelMap[labelItem.tickValue] = 1;
+  });
+  return function (dataIndex) {
+    return !labelMap.hasOwnProperty(data.get(categoryDataDim, dataIndex));
+  };
+}
+
+function canShowAllSymbolForCategory(categoryAxis, data) {
+  // In mose cases, line is monotonous on category axis, and the label size
+  // is close with each other. So we check the symbol size and some of the
+  // label size alone with the category axis to estimate whether all symbol
+  // can be shown without overlap.
+  var axisExtent = categoryAxis.getExtent();
+  var availSize = Math.abs(axisExtent[1] - axisExtent[0]) / categoryAxis.scale.count();
+  isNaN(availSize) && (availSize = 0); // 0/0 is NaN.
+  // Sampling some points, max 5.
+
+  var dataLen = data.count();
+  var step = Math.max(1, Math.round(dataLen / 5));
+
+  for (var dataIndex = 0; dataIndex < dataLen; dataIndex += step) {
+    if (SymbolClz.getSymbolSize(data, dataIndex // Only for cartesian, where `isHorizontal` exists.
+    )[categoryAxis.isHorizontal() ? 1 : 0] // Empirical number
+    * 1.5 > availSize) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
 var _default = ChartView.extend({
   type: 'line',
   init: function () {
@@ -328,7 +397,7 @@ var _default = ChartView.extend({
     var data = seriesModel.getData();
     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;
     var symbolDraw = this._symbolDraw;
@@ -337,12 +406,11 @@ var _default = ChartView.extend({
     var lineGroup = this._lineGroup;
     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');
-
-    var isSymbolIgnore = showSymbol && !isCoordSysPolar && !seriesModel.get('showAllSymbol') && this._getSymbolIgnoreFunc(data, coordSys); // Remove temporary symbols
-
+    var isIgnoreFunc = showSymbol && !isCoordSysPolar && getIsIgnoreFunc(seriesModel, data, coordSys); // Remove temporary symbols
 
     var oldData = this._data;
     oldData && oldData.eachItemGraphicEl(function (el, idx) {
@@ -361,7 +429,10 @@ var _default = ChartView.extend({
     var step = !isCoordSysPolar && seriesModel.get('step'); // Initialization animation or coordinate system changed
 
     if (!(polyline && prevCoordSys.type === coordSys.type && step === this._step)) {
-      showSymbol && symbolDraw.updateData(data, isSymbolIgnore);
+      showSymbol && symbolDraw.updateData(data, {
+        isIgnore: isIgnoreFunc,
+        clipShape: createClipShape(coordSys, false, true, seriesModel)
+      });
 
       if (step) {
         // TODO If stacked series is not step
@@ -375,7 +446,7 @@ var _default = ChartView.extend({
         polygon = this._newPolygon(points, stackedOnPoints, coordSys, hasAnimation);
       }
 
-      lineGroup.setClipPath(createClipShape(coordSys, true, seriesModel));
+      lineGroup.setClipPath(createClipShape(coordSys, true, false, seriesModel));
     } else {
       if (isAreaChart && !polygon) {
         // If areaStyle is added
@@ -387,10 +458,13 @@ var _default = ChartView.extend({
       } // Update clipPath
 
 
-      lineGroup.setClipPath(createClipShape(coordSys, false, seriesModel)); // Always update, or it is wrong in the case turning on legend
+      lineGroup.setClipPath(createClipShape(coordSys, false, false, seriesModel)); // Always update, or it is wrong in the case turning on legend
       // because points are not changed
 
-      showSymbol && symbolDraw.updateData(data, isSymbolIgnore); // Stop symbol animation and sync with line points
+      showSymbol && symbolDraw.updateData(data, {
+        isIgnore: isIgnoreFunc,
+        clipShape: createClipShape(coordSys, false, true, seriesModel)
+      }); // Stop symbol animation and sync with line points
       // FIXME performance?
 
       data.eachItemGraphicEl(function (el) {
@@ -400,7 +474,7 @@ var _default = ChartView.extend({
 
       if (!isPointsSame(this._stackedOnPoints, stackedOnPoints) || !isPointsSame(this._points, points)) {
         if (hasAnimation) {
-          this._updateAnimation(data, stackedOnPoints, coordSys, api, step);
+          this._updateAnimation(data, stackedOnPoints, coordSys, api, step, valueOrigin);
         } else {
           // Not do it in update with animation
           if (step) {
@@ -436,7 +510,7 @@ var _default = ChartView.extend({
     });
 
     if (polygon) {
-      var stackedOn = data.stackedOn;
+      var stackedOnSeries = data.getCalculationInfo('stackedOnSeries');
       var stackedOnSmooth = 0;
       polygon.useStyle(zrUtil.defaults(areaStyleModel.getAreaStyle(), {
         fill: visualColor,
@@ -444,8 +518,7 @@ var _default = ChartView.extend({
         lineJoin: 'bevel'
       }));
 
-      if (stackedOn) {
-        var stackedOnSeries = stackedOn.hostModel;
+      if (stackedOnSeries) {
         stackedOnSmooth = getSmooth(stackedOnSeries.get('smooth'));
       }
 
@@ -463,6 +536,7 @@ var _default = ChartView.extend({
     this._stackedOnPoints = stackedOnPoints;
     this._points = points;
     this._step = step;
+    this._valueOrigin = valueOrigin;
   },
   dispose: function () {},
   highlight: function (seriesModel, ecModel, api, payload) {
@@ -574,26 +648,15 @@ var _default = ChartView.extend({
     return polygon;
   },
 
-  /**
-   * @private
-   */
-  _getSymbolIgnoreFunc: function (data, coordSys) {
-    var categoryAxis = coordSys.getAxesByScale('ordinal')[0]; // `getLabelInterval` is provided by echarts/component/axis
-
-    if (categoryAxis && categoryAxis.isLabelIgnored) {
-      return zrUtil.bind(categoryAxis.isLabelIgnored, categoryAxis);
-    }
-  },
-
   /**
    * @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;
-    var diff = lineAnimationDiff(this._data, data, this._stackedOnPoints, stackedOnPoints, this._coordSys, coordSys);
+    var diff = lineAnimationDiff(this._data, data, this._stackedOnPoints, stackedOnPoints, this._coordSys, coordSys, this._valueOrigin, valueOrigin);
     var current = diff.current;
     var stackedOnCurrent = diff.stackedOnCurrent;
     var next = diff.next;

package/lib/chart/line/helper.js

@@ -0,0 +1,117 @@
+var _dataStackHelper = require("../../data/helper/dataStackHelper");
+
+var isDimensionStacked = _dataStackHelper.isDimensionStacked;
+
+var _util = require("zrender/lib/core/util");
+
+var map = _util.map;
+
+/*
+* 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.
+*/
+
+/**
+ * @param {Object} coordSys
+ * @param {module:echarts/data/List} data
+ * @param {string} valueOrigin lineSeries.option.areaStyle.origin
+ */
+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 dims = map(coordSys.dimensions, function (coordDim) {
+    return data.mapDimension(coordDim);
+  });
+  var stacked;
+  var stackResultDim = data.getCalculationInfo('stackResultDimension');
+
+  if (stacked |= isDimensionStacked(data, dims[0]
+  /*, dims[1]*/
+  )) {
+    // jshint ignore:line
+    dims[0] = stackResultDim;
+  }
+
+  if (stacked |= isDimensionStacked(data, dims[1]
+  /*, dims[0]*/
+  )) {
+    // jshint ignore:line
+    dims[1] = stackResultDim;
+  }
+
+  return {
+    dataDimsForPoint: dims,
+    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;
+}
+
+function getStackedOnPoint(dataCoordInfo, coordSys, data, idx) {
+  var value = NaN;
+
+  if (dataCoordInfo.stacked) {
+    value = data.get(data.getCalculationInfo('stackedOverDimension'), idx);
+  }
+
+  if (isNaN(value)) {
+    value = dataCoordInfo.valueStart;
+  }
+
+  var baseDataOffset = dataCoordInfo.baseDataOffset;
+  var stackedData = [];
+  stackedData[baseDataOffset] = data.get(dataCoordInfo.baseDim, idx);
+  stackedData[1 - baseDataOffset] = value;
+  return coordSys.dataToPoint(stackedData);
+}
+
+exports.prepareDataCoordInfo = prepareDataCoordInfo;
+exports.getStackedOnPoint = getStackedOnPoint;