markPoint

src/chart/helper/DataSymbol.js

@@ -22,6 +22,8 @@ define(function (require) {
 
         symbolEl.position = point;
 
+        symbolEl.z2 = 100;
+
         if (enableAnimation) {
 
             symbolEl.scale = [0.1, 0.1];

src/chart/line/Area.js

 define(function(require) {
     'use strict';
 
+    var smoothBezier = require('zrender/graphic/helper/smoothBezier');
+
     return require('zrender/graphic/Path').extend({
 
         type: 'ec-area',
@@ -17,7 +19,7 @@ define(function(require) {
 
             var i = 0;
             var len = points.length;
-            while (i < points.length) {
+            while (i < len) {
                 for (var k = i; k < len; k++) {
                     var p = points[k];
                     if (p == null || isNaN(p[0]) || isNaN(p[1])) {

src/chart/line/LineView.js

@@ -81,7 +81,9 @@ define(function(require) {
         type: 'line',
 
         init: function () {
-            this._dataSymbol = new DataSymbol();
+            var dataSymbol = new DataSymbol();
+            this.group.add(dataSymbol.group);
+            this._dataSymbol = dataSymbol;
         },
 
         render: function (seriesModel, ecModel) {
@@ -176,10 +178,6 @@ define(function(require) {
                 ));
             }
 
-            // Make sure symbols is on top of line
-            group.remove(dataSymbol.group);
-            group.add(dataSymbol.group);
-
             this._data = data;
 
             // Save the coordinate system and data for transition animation when data changed
@@ -209,7 +207,8 @@ define(function(require) {
                 shape: {
                     points: points
                 },
-                silent: true
+                silent: true,
+                z2: 10
             });
 
             var clipPath = this._createClipShape(coordSys, hasAnimation);
@@ -372,7 +371,7 @@ define(function(require) {
                         width: xExtent[1] - xExtent[0],
                         height: yExtent[1] - yExtent[0]
                     }
-                }, 1500, animation);
+                }, 1500);
             }
 
             return clipPath;

src/chart/pie/pieVisual.js

@@ -6,8 +6,10 @@ define(function (require) {
             var data = seriesModel.getData();
             var dataAll = seriesModel.getDataAll();
             data.each(function (idx) {
+                var itemModel = data.getItemModel(idx);
                 var rawIdx = data.getRawIndex(idx);
-                var color = colorList[rawIdx % colorList.length];
+                var color = itemModel.get('itemStyle.normal.color')
+                    || colorList[rawIdx % colorList.length];
                 // Legend use the visual info in data before processed
                 dataAll.setItemVisual(rawIdx, 'color', color);
                 data.setItemVisual(idx, 'color', color);

src/component/angleAxis.js

@@ -18,7 +18,6 @@ define(function(require) {
         };
     }
 
-
     require('../coord/polar/polarCreator');
 
     require('../echarts').extendComponentView({

src/component/markPoint.js

+define(function (require) {
+
+    var DataSymbol = require('../chart/helper/DataSymbol');
+
+    require('./marker/MarkPointModel');
+
+    require('../echarts').extendComponentView({
+
+        type: 'markPoint',
+
+        init: function () {
+            this._dataSymbolMap = {};
+        },
+
+        render: function (markPointModel, ecModel) {
+            var dataSymbolMap = this._dataSymbolMap;
+            for (var name in dataSymbolMap) {
+                dataSymbolMap[name].__keep = false;
+            }
+
+            ecModel.eachSeries(function (seriesModel) {
+                var mpModel = seriesModel.markPointModel;
+                mpModel && this._renderSeriesMP(seriesModel, mpModel);
+            }, this);
+
+            for (var name in dataSymbolMap) {
+                if (!dataSymbolMap[name].__keep) {
+                    dataSymbolMap[name].remove();
+                    this.group.remove(dataSymbolMap[name].group);
+                }
+            }
+        },
+
+        _renderSeriesMP: function (seriesModel, mpModel) {
+            var dataSymbolMap = this._dataSymbolMap;
+            var seriesName = seriesModel.name;
+            var dataSymbol = dataSymbolMap[seriesName];
+            if (!dataSymbol) {
+                dataSymbol = dataSymbolMap[seriesName] = new DataSymbol();
+                this.group.add(dataSymbol.group);
+            }
+
+            var seriesData = seriesModel.getData();
+            var data = mpModel.getData();
+
+            var coordSys = seriesModel.coordinateSystem;
+
+            // FIXME Put visual out
+            data.each(['x', 'y'], function (x, y, idx) {
+                var itemModel = data.getItemModel(idx);
+                var xPx = itemModel.getShallow('x');
+                var yPx = itemModel.getShallow('y');
+                var point = (xPx != null && yPx != null) ? [xPx, yPx] : coordSys.dataToPoint([x, y]);
+                data.setItemLayout(idx, point);
+
+                data.setItemVisual(idx, {
+                    symbolSize: itemModel.getShallow('symbolSize'),
+                    color: itemModel.get('itemStyle.normal.color')
+                        || seriesData.getVisual('color')
+                });
+            });
+
+            dataSymbol.updateData(data, true);
+
+            dataSymbol.__keep = true;
+        }
+    });
+});
\ No newline at end of file

src/component/marker/MarkPointModel.js

+define(function (require) {
+
+    var List = require('../../data/List');
+
+    var zrUtil = require('zrender/core/util');
+
+    // Default enable markpoint
+    var globalDefault = require('../../model/globalDefault');
+    globalDefault.markPoint = {};
+
+    var geoCoordDataTransform = function (item) {
+
+    }
+
+    var specialTypeCalculatorWithExtent = function (percent, data, mainAxisDim, valueAxisDim) {
+        var extent = data.getDataExtent(valueAxisDim);
+        var valueIndex = (valueAxisDim === 'radius' || valueAxisDim === 'x') ? 0 : 1;
+        var valueArr = [];
+        var min = extent[0];
+        var max = extent[1];
+        var val = (max - min) * percent + min;
+        valueArr[valueIndex] = val;
+        var dataIndex = data.indexOfNearest(valueAxisDim, val);
+        valueArr[1 - valueIndex] = data.get(mainAxisDim, dataIndex);
+        return valueArr;
+    };
+
+    var specialTypeCalculator = {
+        /**
+         * @method
+         * @param {module:echarts/data/List} data
+         * @param {string} mainAxisDim
+         * @param {string} valueAxisDim
+         */
+        min: zrUtil.curry(specialTypeCalculatorWithExtent, 0),
+        /**
+         * @method
+         * @param {module:echarts/data/List} data
+         * @param {string} mainAxisDim
+         * @param {string} valueAxisDim
+         */
+        max: zrUtil.curry(specialTypeCalculatorWithExtent, 1),
+        /**
+         * @method
+         * @param {module:echarts/data/List} data
+         * @param {string} mainAxisDim
+         * @param {string} valueAxisDim
+         */
+        average: zrUtil.curry(specialTypeCalculatorWithExtent, 0.5)
+    }
+
+    var dataTransform = function (data, mainAxisDim, valueAxisDim, item) {
+        // If not specify the position with pixel directly
+        if (isNaN(item.x) || isNaN(item.y)) {
+            // Special types, Compatible with 2.0
+            if (item.type && specialTypeCalculator[item.type]
+                && mainAxisDim && valueAxisDim) {
+                var value = specialTypeCalculator[item.type](
+                    data, mainAxisDim, valueAxisDim
+                );
+                value.push(+item.value);
+                item.value = value;
+            }
+            else if (!isNaN(item.value)) {
+                item.value = [
+                    item.xAxis || item.radiusAxis,
+                    item.yAxis || item.angleAxis,
+                    item.value
+                ];
+            }
+        }
+        return item;
+    };
+
+    // FIXME 公用？
+    var getAxesDimMap = function (ecModel, seriesModel) {
+        var coordSysType = seriesModel.get('coordinateSystem');
+        var mainAxisDim;
+        var valueAxisDim;
+        if (coordSysType === 'cartesian2d') {
+            var xAxisModel = ecModel.getComponent('xAxis', seriesModel.get('xAxisIndex'));
+            if (xAxisModel.type === 'category') {
+                mainAxisDim = 'y';
+                valueAxisDim = 'x';
+            }
+            else {
+                mainAxisDim = 'x';
+                valueAxisDim = 'y';
+            }
+        }
+        else if (coordSysType === 'polar') {
+            var polarModel = ecModel.getComponent(seriesModel.get('polarIndex'));
+            var radiusAxisModel = polarModel.findAxisModel('radiusAxis');
+            if (radiusAxisModel.type === 'category') {
+                mainAxisDim = 'radius';
+                valueAxisDim = 'angle';
+            }
+            else {
+                mainAxisDim = 'angle';
+                valueAxisDim = 'radius';
+            }
+        }
+        return {
+            main: mainAxisDim,
+            value: valueAxisDim
+        };
+    }
+
+    var MarkPointModel = require('../../echarts').extendSeriesModel({
+
+        type: 'markPoint',
+
+        dependencies: ['series', 'grid', 'polar'],
+        /**
+         * @overrite
+         */
+        init: function (option, parentModel, ecModel, dependentModels, idx, createdBySelf) {
+            this.mergeDefaultAndTheme(option, ecModel);
+            this.mergeOption(option, createdBySelf);
+        },
+
+        mergeOption: function (newOpt, createdBySelf) {
+            // If not created by self for each series
+            if (!createdBySelf) {
+                var ecModel = this.ecModel;
+                ecModel.eachSeries(function (seriesModel) {
+                    var markPointOpt = seriesModel.get('markPoint');
+                    if (markPointOpt && markPointOpt.data) {
+                        var mpModel = seriesModel.markPointModel;
+                        if (!mpModel) {
+                            mpModel = new MarkPointModel(
+                                markPointOpt, this, ecModel, [], 0, true
+                            );
+                        }
+                        else {
+                            // FIXME 后面 data transform 是否会对新的 merge 有影响
+                            mpModel.mergeOption(markPointOpt, true);
+                        }
+                        var seriesData = seriesModel.getData();
+                        var dimensions = seriesData.dimensions.slice();
+                        // Polar and cartesian with category axis may have dimensions inversed
+                        if (dimensions[0] === 'y' || dimensions[0] === 'angle') {
+                            dimensions.inverse();
+                        }
+                        var mpData = new List(dimensions, mpModel);
+
+                        // Dim of axis of calculating min, max
+                        var axesDims = getAxesDimMap(ecModel, seriesModel);
+                        mpData.initData(
+                            zrUtil.map(markPointOpt.data, zrUtil.curry(
+                                dataTransform, seriesData,
+                                axesDims.main, axesDims.value
+                            ))
+                        );
+                        mpModel.getData = function () {
+                            return mpData;
+                        }
+
+                        seriesModel.markPointModel = mpModel;
+                    }
+                    else {
+                        seriesModel.markPointModel = null;
+                    }
+                }, this);
+            }
+        },
+
+        restoreData: function () {
+            // FIXME dataZoom needs to know markPoint model
+        },
+
+        defaultOption: {
+            zlevel: 0,
+            z: 5,
+            clickable: true,
+            symbol: 'pin',         // 标注类型
+            symbolSize: 20,        // 标注大小
+            // symbolRotate: null, // 标注旋转控制
+            large: false,
+            effect: {
+                show: false,
+                loop: true,
+                // 运动周期，无单位，值越大越慢
+                period: 15,
+                // 可用为 scale | bounce
+                type: 'scale',
+                // 放大倍数，以markPoint点size为基准
+                scaleSize: 2,
+                // 跳动距离，单位px
+                bounceDistance: 10
+                // color: 'gold',
+                // shadowColor: 'rgba(255,215,0,0.8)',
+                // 炫光模糊
+                // shadowBlur: 0
+            },
+            itemStyle: {
+                normal: {
+                    // color: 各异，
+                    // 标注边线颜色，优先于color
+                    // borderColor: 各异,
+                    // 标注边线线宽，单位px，默认为1
+                    borderWidth: 2,
+                    label: {
+                        show: true,
+                        // 标签文本格式器，同Tooltip.formatter，不支持回调
+                        // formatter: null,
+                        // 可选为'left'|'right'|'top'|'bottom'
+                        position: 'inside'
+                        // 默认使用全局文本样式，详见TEXTSTYLE
+                        // textStyle: null
+                    }
+                },
+                emphasis: {
+                    // color: 各异
+                    label: {
+                        show: true
+                        // 标签文本格式器，同Tooltip.formatter，不支持回调
+                        // formatter: null,
+                        // position: 'inside'  // 'left'|'right'|'top'|'bottom'
+                        // textStyle: null     // 默认使用全局文本样式，详见TEXTSTYLE
+                    }
+                }
+            }
+        }
+    });
+
+    return MarkPointModel;
+});
\ No newline at end of file

src/coord/cartesian/AxisModel.js

@@ -33,15 +33,18 @@ define(function(require) {
         type: 'xAxis',
 
         init: function (axisOption, parentModel, ecModel) {
-            AxisModel.prototype.init.call(this);
 
-            axisOption.type = axisOption.type || 'category';
+            zrUtil.merge(axisOption, this.getDefaultOption(), false);
 
-            axisOption.position = axisOption.position || 'bottom';
+            mergeDefault(axisOption, ecModel);
+        },
 
-            axisOption.gridIndex = axisOption.gridIndex || 0;
+        defaultOption: {
+            type: 'category',
 
-            mergeDefault(axisOption, ecModel);
+            gridIndex: 0,
+
+            position: 'bottom'
         }
     });
 
@@ -51,15 +54,18 @@ define(function(require) {
         type: 'yAxis',
 
         init: function (axisOption, parentModel, ecModel) {
-            AxisModel.prototype.init.call(this);
 
-            axisOption.type = axisOption.type || 'value';
+            zrUtil.merge(axisOption, this.getDefaultOption(), false);
 
-            axisOption.position = axisOption.position || 'left';
+            mergeDefault(axisOption, ecModel);
+        },
 
-            axisOption.gridIndex = axisOption.gridIndex || 0;
+        defaultOption: {
+            type: 'value',
 
-            mergeDefault(axisOption, ecModel);
+            gridIndex: 0,
+
+            position: 'left'
         }
     });
 

src/coord/polar/PolarModel.js

@@ -15,6 +15,23 @@ define(function (require) {
          */
         coordinateSystem: null,
 
+        /**
+         * @param {string} axisType
+         * @return {module:echarts/coord/polar/AxisModel}
+         */
+        findAxisModel: function (axisType) {
+            var angleAxisModel;
+            var ecModel = this.ecModel;
+            ecModel.eachComponent(axisType, function (axisModel) {
+                if (ecModel.getComponent(
+                        'polar', axisModel.getShallow('polarIndex')
+                    ) === this) {
+                    angleAxisModel = axisModel;
+                }
+            }, this);
+            return angleAxisModel;
+        },
+
         defaultOption: {
 
             zlevel: 0,

src/coord/polar/polarCreator.js

@@ -10,29 +10,6 @@ define(function (require) {
     // 依赖 PolarModel 做预处理
     require('./PolarModel');
 
-    /**
-     * Retrieve angle axis or radius axis belongs to the given polar
-     * @param {string} axisType
-     * @param {number} polarIndex
-     * @param {module:echarts/model/Global} ecModel
-     * @param {module:echarts/ExtensionAPI} api
-     * @return {module:echarts/coord/polar/AxisModel}
-     * @inner
-     */
-    function retrieveAxisModelForPolar(axisType, polarIndex, ecModel, api) {
-        var axisModel;
-        ecModel.eachComponent(axisType, function (model) {
-            if (model.get('polarIndex') === polarIndex) {
-                if (axisModel) {
-                    // api.log('Polar ' + polarIndex + ' has more than one ' + axisType);
-                    return;
-                }
-                axisModel = model;
-            }
-        });
-        return axisModel;
-    }
-
     /**
      * Resize methods bound to the polar
      * @param {module:echarts/coord/polar/PolarModel} polarModel
@@ -134,8 +111,8 @@ define(function (require) {
                 var radiusAxis = polar.getRadiusAxis();
                 var angleAxis = polar.getAngleAxis();
 
-                var radiusAxisModel = retrieveAxisModelForPolar('radiusAxis', idx, ecModel, api);
-                var angleAxisModel = retrieveAxisModelForPolar('angleAxis', idx, ecModel, api);
+                var radiusAxisModel = polarModel.findAxisModel('radiusAxis');
+                var angleAxisModel = polarModel.findAxisModel('angleAxis');
 
                 setAxis(radiusAxis, radiusAxisModel);
                 setAxis(angleAxis, angleAxisModel);

src/data/List.js

@@ -28,9 +28,9 @@ define(function (require) {
      * @alias module:echarts/data/List
      *
      * @param {Array.<string>} dimensions
-     * @param {module:echarts/model/Model} seriesModel
+     * @param {module:echarts/model/Model} hostModel
      */
-    var List = function (dimensions, seriesModel) {
+    var List = function (dimensions, hostModel) {
 
         dimensions = dimensions || ['x', 'y'];
 
@@ -72,7 +72,7 @@ define(function (require) {
         /**
          * @type {module:echarts/model/Model}
          */
-        this.seriesModel = seriesModel;
+        this.hostModel = hostModel;
 
         /**
          * Indices stores the indices of data subset after filtered.
@@ -180,7 +180,7 @@ define(function (require) {
             // Each data item contains value and option
             if (data[idx] != null && data[idx].hasOwnProperty('value')) {
                 value = data[idx].value;
-                var model = new Model(data[idx], this.seriesModel);
+                var model = new Model(data[idx], this.hostModel);
                 var modelIdx = optionModels.length;
                 optionModelIndices[idx] = modelIdx;
                 optionModels.push(model);
@@ -360,10 +360,12 @@ define(function (require) {
     listProto.indexOf = function (dim, value) {
         var storage = this._storage;
         var dimData = storage[dim];
+        var indices = this.indices;
 
         if (dimData) {
-            for (var i = 0, len = dimData.length; i < len; i++) {
-                if (dimData[i] === value) {
+            for (var i = 0, len = indices.length; i < len; i++) {
+                var rawIndex = indices[i];
+                if (dimData[rawIndex] === value) {
                     return i;
                 }
             }
@@ -371,6 +373,33 @@ define(function (require) {
         return -1;
     };
 
+    /**
+     * Retreive the index of nearest value
+     * @param {number} idx
+     * @param {number} value
+     * @return {number}
+     */
+    listProto.indexOfNearest = function (dim, value) {
+        var storage = this._storage;
+        var dimData = storage[dim];
+        var indices = this.indices;
+
+        if (dimData) {
+            var minDist = Number.MAX_VALUE;
+            var nearestIdx = -1;
+            for (var i = 0, len = indices.length; i < len; i++) {
+                var rawIndex = indices[i];
+                var dist = Math.abs(dimData[rawIndex] - value);
+                if (dist <= minDist) {
+                    minDist = dist;
+                    nearestIdx = i;
+                }
+            }
+            return nearestIdx;
+        }
+        return -1;
+    }
+
     /**
      * Get raw data index
      * @param {number} idx
@@ -558,7 +587,7 @@ define(function (require) {
             // Use a temporary model proxy if value on idx is not an option.
             // FIXME Create a new one may cause memory leak
             model = temporaryModel;
-            model.parentModel = this.seriesModel;
+            model.parentModel = this.hostModel;
         }
         return model;
     };
@@ -678,7 +707,7 @@ define(function (require) {
         // Add data index and series index for indexing the data by element
         // Useful in tooltip
         el.dataIndex = idx;
-        el.seriesIndex = this.seriesModel.seriesIndex;
+        el.seriesIndex = this.hostModel.seriesIndex;
 
         this._graphicEls[idx] = el;
     };
@@ -711,7 +740,7 @@ define(function (require) {
         var dimensionInfoList = zrUtil.map(this.dimensions, function (dim) {
             return this._dimensionInfos[dim];
         }, this);
-        var list = new List(dimensionInfoList, this.seriesModel);
+        var list = new List(dimensionInfoList, this.hostModel);
         list.stackedOn = this.stackedOn;
 
         // FIXME

src/model/Model.js

@@ -89,12 +89,15 @@ define(function (require) {
 
         /**
          * @param {string} path
+         * @param {module:echarts/model/Model} [parentModel]
          * @return {module:echarts/model/Model}
          */
-        getModel: function (path) {
+        getModel: function (path, parentModel) {
             var obj = this.get(path);
-            var parentModel = this.parentModel;
-            return new Model(obj, parentModel && parentModel.getModel(path));
+            var thisParentModel = this.parentModel;
+            return new Model(
+                obj, parentModel || (thisParentModel && thisParentModel.getModel(path))
+            );
         },
 
         /**

src/visual/defaultColor.js

@@ -4,7 +4,9 @@ define(function (require) {
         ecModel.eachSeries(function (seriesModel) {
             var colorList = ecModel.get('color');
             var data = seriesModel.getData();
-            data.setVisual('color', colorList[seriesModel.seriesIndex]);
+            var color = seriesModel.get('itemStyle.normal.color') // Set in itemStyle
+                || colorList[seriesModel.seriesIndex];  // Default color
+            data.setVisual('color', color);
         });
     }
 });
\ No newline at end of file