Start again

vendors/echarts/src/chart/map/MapSeries.js

@@ -0,0 +1,190 @@
+define(function (require) {
+
+    var List = require('../../data/List');
+    var SeriesModel = require('../../model/Series');
+    var zrUtil = require('zrender/core/util');
+    var completeDimensions = require('../../data/helper/completeDimensions');
+
+    var formatUtil = require('../../util/format');
+    var encodeHTML = formatUtil.encodeHTML;
+    var addCommas = formatUtil.addCommas;
+
+    var dataSelectableMixin = require('../../component/helper/selectableMixin');
+
+    var geoCreator = require('../../coord/geo/geoCreator');
+
+    var MapSeries = SeriesModel.extend({
+
+        type: 'series.map',
+
+        /**
+         * Only first map series of same mapType will drawMap
+         * @type {boolean}
+         */
+        needsDrawMap: false,
+
+        /**
+         * Group of all map series with same mapType
+         * @type {boolean}
+         */
+        seriesGroup: [],
+
+        init: function (option) {
+
+            option = this._fillOption(option, option.map);
+            this.option = option;
+
+            MapSeries.superApply(this, 'init', arguments);
+
+            this.updateSelectedMap(option.data);
+        },
+
+        getInitialData: function (option) {
+            var dimensions = completeDimensions(['value'], option.data || []);
+
+            var list = new List(dimensions, this);
+
+            list.initData(option.data);
+
+            return list;
+        },
+
+        mergeOption: function (newOption) {
+            if (newOption.data) {
+                newOption = this._fillOption(newOption, this.option.map);
+            }
+
+            MapSeries.superCall(this, 'mergeOption', newOption);
+
+            this.updateSelectedMap(this.option.data);
+        },
+
+        _fillOption: function (option, mapName) {
+            // Shallow clone
+            option = zrUtil.extend({}, option);
+
+            option.data = geoCreator.getFilledRegions(option.data, mapName);
+
+            return option;
+        },
+
+        getRawValue: function (dataIndex) {
+            // Use value stored in data instead because it is calculated from multiple series
+            // FIXME Provide all value of multiple series ?
+            return this._data.get('value', dataIndex);
+        },
+
+        /**
+         * Get model of region
+         * @param  {string} name
+         * @return {module:echarts/model/Model}
+         */
+        getRegionModel: function (regionName) {
+            var data = this.getData();
+            return data.getItemModel(data.indexOfName(regionName));
+        },
+
+        /**
+         * Map tooltip formatter
+         *
+         * @param {number} dataIndex
+         */
+        formatTooltip: function (dataIndex) {
+            var data = this._data;
+            var formattedValue = addCommas(this.getRawValue(dataIndex));
+            var name = data.getName(dataIndex);
+
+            var seriesGroup = this.seriesGroup;
+            var seriesNames = [];
+            for (var i = 0; i < seriesGroup.length; i++) {
+                if (!isNaN(seriesGroup[i].getRawValue(dataIndex))) {
+                    seriesNames.push(
+                        encodeHTML(seriesGroup[i].name)
+                    );
+                }
+            }
+
+            return seriesNames.join(', ') + '<br />'
+                + name + ' : ' + formattedValue;
+        },
+
+        defaultOption: {
+            // 一级层叠
+            zlevel: 0,
+            // 二级层叠
+            z: 2,
+            coordinateSystem: 'geo',
+            // 各省的 map 暂时都用中文
+            map: 'china',
+
+            // 'center' | 'left' | 'right' | 'x%' | {number}
+            left: 'center',
+            // 'center' | 'top' | 'bottom' | 'x%' | {number}
+            top: 'center',
+            // right
+            // bottom
+            // width:
+            // height   // 自适应
+
+            // 数值合并方式，默认加和，可选为：
+            // 'sum' | 'average' | 'max' | 'min'
+            // mapValueCalculation: 'sum',
+            // 地图数值计算结果小数精度
+            // mapValuePrecision: 0,
+            // 显示图例颜色标识（系列标识的小圆点），图例开启时有效
+            showLegendSymbol: true,
+            // 选择模式，默认关闭，可选single，multiple
+            // selectedMode: false,
+            dataRangeHoverLink: true,
+            // 是否开启缩放及漫游模式
+            // roam: false,
+
+            // Default on center of map
+            center: null,
+
+            zoom: 1,
+
+            scaleLimit: null,
+
+            label: {
+                normal: {
+                    show: false,
+                    textStyle: {
+                        color: '#000'
+                    }
+                },
+                emphasis: {
+                    show: true,
+                    textStyle: {
+                        color: 'rgb(100,0,0)'
+                    }
+                }
+            },
+            // scaleLimit: null,
+            itemStyle: {
+                normal: {
+                    // color: 各异,
+                    borderWidth: 0.5,
+                    borderColor: '#444',
+                    areaColor: '#eee'
+                },
+                // 也是选中样式
+                emphasis: {
+                    areaColor: 'rgba(255,215, 0, 0.8)'
+                }
+            }
+        },
+
+        setZoom: function (zoom) {
+            this.option.zoom = zoom;
+        },
+
+        setCenter: function (center) {
+            this.option.center = center;
+        }
+    });
+
+    zrUtil.mixin(MapSeries, dataSelectableMixin);
+
+    return MapSeries;
+});

vendors/echarts/src/chart/map/MapView.js

@@ -0,0 +1,132 @@
+define(function (require) {
+
+    // var zrUtil = require('zrender/core/util');
+    var graphic = require('../../util/graphic');
+
+    var MapDraw = require('../../component/helper/MapDraw');
+
+    require('../../echarts').extendChartView({
+
+        type: 'map',
+
+        render: function (mapModel, ecModel, api, payload) {
+            // Not render if it is an toggleSelect action from self
+            if (payload && payload.type === 'mapToggleSelect'
+                && payload.from === this.uid
+            ) {
+                return;
+            }
+
+            var group = this.group;
+            group.removeAll();
+            // Not update map if it is an roam action from self
+            if (!(payload && payload.type === 'geoRoam'
+                && payload.component === 'series'
+                && payload.name === mapModel.name)) {
+
+                if (mapModel.needsDrawMap) {
+                    var mapDraw = this._mapDraw || new MapDraw(api, true);
+                    group.add(mapDraw.group);
+
+                    mapDraw.draw(mapModel, ecModel, api, this, payload);
+
+                    this._mapDraw = mapDraw;
+                }
+                else {
+                    // Remove drawed map
+                    this._mapDraw && this._mapDraw.remove();
+                    this._mapDraw = null;
+                }
+            }
+            else {
+                var mapDraw = this._mapDraw;
+                mapDraw && group.add(mapDraw.group);
+            }
+
+            mapModel.get('showLegendSymbol') && ecModel.getComponent('legend')
+                && this._renderSymbols(mapModel, ecModel, api);
+        },
+
+        remove: function () {
+            this._mapDraw && this._mapDraw.remove();
+            this._mapDraw = null;
+            this.group.removeAll();
+        },
+
+        _renderSymbols: function (mapModel, ecModel, api) {
+            var data = mapModel.getData();
+            var group = this.group;
+
+            data.each('value', function (value, idx) {
+                if (isNaN(value)) {
+                    return;
+                }
+
+                var layout = data.getItemLayout(idx);
+
+                if (!layout || !layout.point) {
+                    // Not exists in map
+                    return;
+                }
+
+                var point = layout.point;
+                var offset = layout.offset;
+
+                var circle = new graphic.Circle({
+                    style: {
+                        fill: data.getVisual('color')
+                    },
+                    shape: {
+                        cx: point[0] + offset * 9,
+                        cy: point[1],
+                        r: 3
+                    },
+                    silent: true,
+                    z2: 10
+                });
+
+                // First data on the same region
+                if (!offset) {
+                    var labelText = data.getName(idx);
+
+                    var itemModel = data.getItemModel(idx);
+                    var labelModel = itemModel.getModel('label.normal');
+                    var hoverLabelModel = itemModel.getModel('label.emphasis');
+
+                    var textStyleModel = labelModel.getModel('textStyle');
+                    var hoverTextStyleModel = hoverLabelModel.getModel('textStyle');
+
+                    var polygonGroups = data.getItemGraphicEl(idx);
+                    circle.setStyle({
+                        textPosition: 'bottom'
+                    });
+
+                    var onEmphasis = function () {
+                        circle.setStyle({
+                            text: hoverLabelModel.get('show') ? labelText : '',
+                            textFill: hoverTextStyleModel.getTextColor(),
+                            textFont: hoverTextStyleModel.getFont()
+                        });
+                    };
+
+                    var onNormal = function () {
+                        circle.setStyle({
+                            text: labelModel.get('show') ? labelText : '',
+                            textFill: textStyleModel.getTextColor(),
+                            textFont: textStyleModel.getFont()
+                        });
+                    };
+
+                    polygonGroups.on('mouseover', onEmphasis)
+                        .on('mouseout', onNormal)
+                        .on('emphasis', onEmphasis)
+                        .on('normal', onNormal);
+
+                    onNormal();
+                }
+
+                group.add(circle);
+            });
+        }
+    });
+});

vendors/echarts/src/chart/map/backwardCompat.js

@@ -0,0 +1,86 @@
+define(function (require) {
+
+    var zrUtil = require('zrender/core/util');
+    var geoProps = [
+        'x', 'y', 'x2', 'y2', 'width', 'height', 'map', 'roam', 'center', 'zoom', 'scaleLimit', 'label', 'itemStyle'
+    ];
+
+    var geoCoordsMap = {};
+
+    function createGeoFromMap(mapSeriesOpt) {
+        var geoOpt = {};
+        zrUtil.each(geoProps, function (propName) {
+            if (mapSeriesOpt[propName] != null) {
+                geoOpt[propName] = mapSeriesOpt[propName];
+            }
+        });
+        return geoOpt;
+    }
+    return function (option) {
+        // Save geoCoord
+        var mapSeries = [];
+        zrUtil.each(option.series, function (seriesOpt) {
+            if (seriesOpt.type === 'map') {
+                mapSeries.push(seriesOpt);
+            }
+            zrUtil.extend(geoCoordsMap, seriesOpt.geoCoord);
+        });
+
+        var newCreatedGeoOptMap = {};
+        zrUtil.each(mapSeries, function (seriesOpt) {
+            seriesOpt.map = seriesOpt.map || seriesOpt.mapType;
+            // Put x, y, width, height, x2, y2 in the top level
+            zrUtil.defaults(seriesOpt, seriesOpt.mapLocation);
+            if (seriesOpt.markPoint) {
+                var markPoint = seriesOpt.markPoint;
+                // Convert name or geoCoord in markPoint to lng and lat
+                // For example
+                // { name: 'xxx', value: 10} Or
+                // { geoCoord: [lng, lat], value: 10} to
+                // { name: 'xxx', value: [lng, lat, 10]}
+                markPoint.data = zrUtil.map(markPoint.data, function (dataOpt) {
+                    if (!zrUtil.isArray(dataOpt.value)) {
+                        var geoCoord;
+                        if (dataOpt.geoCoord) {
+                            geoCoord = dataOpt.geoCoord;
+                        }
+                        else if (dataOpt.name) {
+                            geoCoord = geoCoordsMap[dataOpt.name];
+                        }
+                        var newValue = geoCoord ? [geoCoord[0], geoCoord[1]] : [NaN, NaN];
+                        if (dataOpt.value != null) {
+                            newValue.push(dataOpt.value);
+                        }
+                        dataOpt.value = newValue;
+                    }
+                    return dataOpt;
+                });
+                // Convert map series which only has markPoint without data to scatter series
+                // FIXME
+                if (!(seriesOpt.data && seriesOpt.data.length)) {
+                    if (!option.geo) {
+                        option.geo = [];
+                    }
+                    else if (!zrUtil.isArray(option.geo)) {
+                        option.geo = [option.geo];
+                    }
+
+                    // Use same geo if multiple map series has same map type
+                    var geoOpt = newCreatedGeoOptMap[seriesOpt.map];
+                    if (!geoOpt) {
+                        geoOpt = newCreatedGeoOptMap[seriesOpt.map] = createGeoFromMap(seriesOpt);
+                        option.geo.push(geoOpt);
+                    }
+
+                    var scatterSeries = seriesOpt.markPoint;
+                    scatterSeries.type = option.effect && option.effect.show ? 'effectScatter' : 'scatter';
+                    scatterSeries.coordinateSystem = 'geo';
+                    scatterSeries.geoIndex = zrUtil.indexOf(option.geo, geoOpt);
+                    scatterSeries.name = seriesOpt.name;
+
+                    option.series.splice(zrUtil.indexOf(option.series, seriesOpt), 1, scatterSeries);
+                }
+            }
+        });
+    };
+});

vendors/echarts/src/chart/map/mapDataStatistic.js

@@ -0,0 +1,80 @@
+define(function (require) {
+
+    var zrUtil = require('zrender/core/util');
+
+    // FIXME 公用？
+    /**
+     * @param {Array.<module:echarts/data/List>} datas
+     * @param {string} statisticsType 'average' 'sum'
+     * @inner
+     */
+    function dataStatistics(datas, statisticsType) {
+        var dataNameMap = {};
+        var dims = ['value'];
+
+        for (var i = 0; i < datas.length; i++) {
+            datas[i].each(dims, function (value, idx) {
+                var name = datas[i].getName(idx);
+                dataNameMap[name] = dataNameMap[name] || [];
+                if (!isNaN(value)) {
+                    dataNameMap[name].push(value);
+                }
+            });
+        }
+
+        return datas[0].map(dims, function (value, idx) {
+            var name = datas[0].getName(idx);
+            var sum = 0;
+            var min = Infinity;
+            var max = -Infinity;
+            var len = dataNameMap[name].length;
+            for (var i = 0; i < len; i++) {
+                min = Math.min(min, dataNameMap[name][i]);
+                max = Math.max(max, dataNameMap[name][i]);
+                sum += dataNameMap[name][i];
+            }
+            var result;
+            if (statisticsType === 'min') {
+                result = min;
+            }
+            else if (statisticsType === 'max') {
+                result = max;
+            }
+            else if (statisticsType === 'average') {
+                result = sum / len;
+            }
+            else {
+                result = sum;
+            }
+            return len === 0 ? NaN : result;
+        });
+    }
+
+    return function (ecModel) {
+        var seriesGroupByMapType = {};
+        ecModel.eachSeriesByType('map', function (seriesModel) {
+            var mapType = seriesModel.get('map');
+            seriesGroupByMapType[mapType] = seriesGroupByMapType[mapType] || [];
+            seriesGroupByMapType[mapType].push(seriesModel);
+        });
+
+        zrUtil.each(seriesGroupByMapType, function (seriesList, mapType) {
+            var data = dataStatistics(
+                zrUtil.map(seriesList, function (seriesModel) {
+                    return seriesModel.getData();
+                }),
+                seriesList[0].get('mapValueCalculation')
+            );
+
+            seriesList[0].seriesGroup = [];
+
+            seriesList[0].setData(data);
+
+            // FIXME Put where?
+            for (var i = 0; i < seriesList.length; i++) {
+                seriesList[i].seriesGroup = seriesList;
+                seriesList[i].needsDrawMap = i === 0;
+            }
+        });
+    };
+});

vendors/echarts/src/chart/map/mapSymbolLayout.js

@@ -0,0 +1,59 @@
+define(function (require) {
+
+    var zrUtil = require('zrender/core/util');
+
+    return function (ecModel) {
+
+        var processedMapType = {};
+
+        ecModel.eachSeriesByType('map', function (mapSeries) {
+            var mapType = mapSeries.get('map');
+            if (processedMapType[mapType]) {
+                return;
+            }
+
+            var mapSymbolOffsets = {};
+
+            zrUtil.each(mapSeries.seriesGroup, function (subMapSeries) {
+                var geo = subMapSeries.coordinateSystem;
+                var data = subMapSeries.getData();
+                if (subMapSeries.get('showLegendSymbol') && ecModel.getComponent('legend')) {
+                    data.each('value', function (value, idx) {
+                        var name = data.getName(idx);
+                        var region = geo.getRegion(name);
+
+                        // No region or no value
+                        // In MapSeries data regions will be filled with NaN
+                        // If they are not in the series.data array.
+                        // So here must validate if value is NaN
+                        if (!region || isNaN(value)) {
+                            return;
+                        }
+
+                        var offset = mapSymbolOffsets[name] || 0;
+
+                        var point = geo.dataToPoint(region.center);
+
+                        mapSymbolOffsets[name] = offset + 1;
+
+                        data.setItemLayout(idx, {
+                            point: point,
+                            offset: offset
+                        });
+                    });
+                }
+            });
+
+            // Show label of those region not has legendSymbol(which is offset 0)
+            var data = mapSeries.getData();
+            data.each(function (idx) {
+                var name = data.getName(idx);
+                var layout = data.getItemLayout(idx) || {};
+                layout.showLabel = !mapSymbolOffsets[name];
+                data.setItemLayout(idx, layout);
+            });
+
+            processedMapType[mapType] = true;
+        });
+    };
+});

vendors/echarts/src/chart/map/mapVisual.js

@@ -0,0 +1,17 @@
+define(function (require) {
+    return function (ecModel) {
+        ecModel.eachSeriesByType('map', function (seriesModel) {
+            var colorList = seriesModel.get('color');
+            var itemStyleModel = seriesModel.getModel('itemStyle.normal');
+
+            var areaColor = itemStyleModel.get('areaColor');
+            var color = itemStyleModel.get('color')
+                || colorList[seriesModel.seriesIndex % colorList.length];
+
+            seriesModel.getData().setVisual({
+                'areaColor': areaColor,
+                'color': color
+            });
+        });
+    };
+});