| (function(_global){ |
| var require, define; |
| (function () { |
| var mods = {}; |
| |
| define = function (id, deps, factory) { |
| mods[id] = { |
| id: id, |
| deps: deps, |
| factory: factory, |
| defined: 0, |
| exports: {}, |
| require: createRequire(id) |
| }; |
| }; |
| |
| require = createRequire(''); |
| |
| function normalize(id, baseId) { |
| if (!baseId) { |
| return id; |
| } |
| |
| if (id.indexOf('.') === 0) { |
| var basePath = baseId.split('/'); |
| var namePath = id.split('/'); |
| var baseLen = basePath.length - 1; |
| var nameLen = namePath.length; |
| var cutBaseTerms = 0; |
| var cutNameTerms = 0; |
| |
| pathLoop: for (var i = 0; i < nameLen; i++) { |
| switch (namePath[i]) { |
| case '..': |
| if (cutBaseTerms < baseLen) { |
| cutBaseTerms++; |
| cutNameTerms++; |
| } |
| else { |
| break pathLoop; |
| } |
| break; |
| case '.': |
| cutNameTerms++; |
| break; |
| default: |
| break pathLoop; |
| } |
| } |
| |
| basePath.length = baseLen - cutBaseTerms; |
| namePath = namePath.slice(cutNameTerms); |
| |
| return basePath.concat(namePath).join('/'); |
| } |
| |
| return id; |
| } |
| |
| function createRequire(baseId) { |
| var cacheMods = {}; |
| |
| function localRequire(id, callback) { |
| if (typeof id === 'string') { |
| var exports = cacheMods[id]; |
| if (!exports) { |
| exports = getModExports(normalize(id, baseId)); |
| cacheMods[id] = exports; |
| } |
| |
| return exports; |
| } |
| else if (id instanceof Array) { |
| callback = callback || function () {}; |
| callback.apply(this, getModsExports(id, callback, baseId)); |
| } |
| }; |
| |
| return localRequire; |
| } |
| |
| function getModsExports(ids, factory, baseId) { |
| var es = []; |
| var mod = mods[baseId]; |
| |
| for (var i = 0, l = Math.min(ids.length, factory.length); i < l; i++) { |
| var id = normalize(ids[i], baseId); |
| var arg; |
| switch (id) { |
| case 'require': |
| arg = (mod && mod.require) || require; |
| break; |
| case 'exports': |
| arg = mod.exports; |
| break; |
| case 'module': |
| arg = mod; |
| break; |
| default: |
| arg = getModExports(id); |
| } |
| es.push(arg); |
| } |
| |
| return es; |
| } |
| |
| function getModExports(id) { |
| var mod = mods[id]; |
| if (!mod) { |
| throw new Error('No ' + id); |
| } |
| |
| if (!mod.defined) { |
| var factory = mod.factory; |
| var factoryReturn = factory.apply( |
| this, |
| getModsExports(mod.deps || [], factory, id) |
| ); |
| if (typeof factoryReturn !== 'undefined') { |
| mod.exports = factoryReturn; |
| } |
| mod.defined = 1; |
| } |
| |
| return mod.exports; |
| } |
| }()); |
| define('echarts', ['echarts/echarts'], function (main) {return main;}); |
| define('echarts/echarts', [ |
| 'require', |
| './config', |
| 'zrender/tool/util', |
| 'zrender/tool/event', |
| 'zrender/tool/env', |
| 'zrender', |
| 'zrender/config', |
| './chart/island', |
| './component/toolbox', |
| './component', |
| './component/title', |
| './component/tooltip', |
| './component/legend', |
| './util/ecData', |
| './chart', |
| 'zrender/tool/color', |
| './component/timeline', |
| 'zrender/shape/Image', |
| 'zrender/loadingEffect/Bar', |
| 'zrender/loadingEffect/Bubble', |
| 'zrender/loadingEffect/DynamicLine', |
| 'zrender/loadingEffect/Ring', |
| 'zrender/loadingEffect/Spin', |
| 'zrender/loadingEffect/Whirling', |
| './theme/default' |
| ], function (require) { |
| var ecConfig = require('./config'); |
| var zrUtil = require('zrender/tool/util'); |
| var zrEvent = require('zrender/tool/event'); |
| var self = {}; |
| var _canvasSupported = require('zrender/tool/env').canvasSupported; |
| var _idBase = new Date() - 0; |
| var _instances = {}; |
| var DOM_ATTRIBUTE_KEY = '_echarts_instance_'; |
| self.version = '2.1.10'; |
| self.dependencies = { zrender: '2.0.6' }; |
| self.init = function (dom, theme) { |
| var zrender = require('zrender'); |
| if ((zrender.version || '1.0.3').replace('.', '') - 0 < self.dependencies.zrender.replace('.', '') - 0) { |
| console.error('ZRender ' + (zrender.version || '1.0.3-') + ' is too old for ECharts ' + self.version + '. Current version need ZRender ' + self.dependencies.zrender + '+'); |
| } |
| dom = dom instanceof Array ? dom[0] : dom; |
| var key = dom.getAttribute(DOM_ATTRIBUTE_KEY); |
| if (!key) { |
| key = _idBase++; |
| dom.setAttribute(DOM_ATTRIBUTE_KEY, key); |
| } |
| if (_instances[key]) { |
| _instances[key].dispose(); |
| } |
| _instances[key] = new Echarts(dom); |
| _instances[key].id = key; |
| _instances[key].canvasSupported = _canvasSupported; |
| _instances[key].setTheme(theme); |
| return _instances[key]; |
| }; |
| self.getInstanceById = function (key) { |
| return _instances[key]; |
| }; |
| function MessageCenter() { |
| zrEvent.Dispatcher.call(this); |
| } |
| zrUtil.merge(MessageCenter.prototype, zrEvent.Dispatcher.prototype, true); |
| function Echarts(dom) { |
| this._themeConfig = zrUtil.clone(ecConfig); |
| this.dom = dom; |
| this._connected = false; |
| this._status = { |
| dragIn: false, |
| dragOut: false, |
| needRefresh: false |
| }; |
| this._curEventType = false; |
| this._chartList = []; |
| this._messageCenter = new MessageCenter(); |
| this._messageCenterOutSide = new MessageCenter(); |
| this.resize = this.resize(); |
| this._init(); |
| } |
| var ZR_EVENT = require('zrender/config').EVENT; |
| var ZR_EVENT_LISTENS = [ |
| 'CLICK', |
| 'DBLCLICK', |
| 'MOUSEOVER', |
| 'MOUSEOUT', |
| 'DRAGSTART', |
| 'DRAGEND', |
| 'DRAGENTER', |
| 'DRAGOVER', |
| 'DRAGLEAVE', |
| 'DROP' |
| ]; |
| function callChartListMethodReverse(ecInstance, methodName, arg0, arg1, arg2) { |
| var chartList = ecInstance._chartList; |
| var len = chartList.length; |
| while (len--) { |
| var chart = chartList[len]; |
| if (typeof chart[methodName] === 'function') { |
| chart[methodName](arg0, arg1, arg2); |
| } |
| } |
| } |
| Echarts.prototype = { |
| _init: function () { |
| var self = this; |
| var _zr = require('zrender').init(this.dom); |
| this._zr = _zr; |
| this._messageCenter.dispatch = function (type, event, eventPackage, that) { |
| eventPackage = eventPackage || {}; |
| eventPackage.type = type; |
| eventPackage.event = event; |
| self._messageCenter.dispatchWithContext(type, eventPackage, that); |
| if (type != 'HOVER' && type != 'MOUSEOUT') { |
| setTimeout(function () { |
| self._messageCenterOutSide.dispatchWithContext(type, eventPackage, that); |
| }, 50); |
| } else { |
| self._messageCenterOutSide.dispatchWithContext(type, eventPackage, that); |
| } |
| }; |
| this._onevent = function (param) { |
| return self.__onevent(param); |
| }; |
| for (var e in ecConfig.EVENT) { |
| if (e != 'CLICK' && e != 'DBLCLICK' && e != 'HOVER' && e != 'MOUSEOUT' && e != 'MAP_ROAM') { |
| this._messageCenter.bind(ecConfig.EVENT[e], this._onevent, this); |
| } |
| } |
| var eventBehaviors = {}; |
| this._onzrevent = function (param) { |
| return self[eventBehaviors[param.type]](param); |
| }; |
| for (var i = 0, len = ZR_EVENT_LISTENS.length; i < len; i++) { |
| var eventName = ZR_EVENT_LISTENS[i]; |
| var eventValue = ZR_EVENT[eventName]; |
| eventBehaviors[eventValue] = '_on' + eventName.toLowerCase(); |
| _zr.on(eventValue, this._onzrevent); |
| } |
| this.chart = {}; |
| this.component = {}; |
| var Island = require('./chart/island'); |
| this._island = new Island(this._themeConfig, this._messageCenter, _zr, {}, this); |
| this.chart.island = this._island; |
| var Toolbox = require('./component/toolbox'); |
| this._toolbox = new Toolbox(this._themeConfig, this._messageCenter, _zr, {}, this); |
| this.component.toolbox = this._toolbox; |
| var componentLibrary = require('./component'); |
| componentLibrary.define('title', require('./component/title')); |
| componentLibrary.define('tooltip', require('./component/tooltip')); |
| componentLibrary.define('legend', require('./component/legend')); |
| if (_zr.getWidth() === 0 || _zr.getHeight() === 0) { |
| console.error('Dom’s width & height should be ready before init.'); |
| } |
| }, |
| __onevent: function (param) { |
| param.__echartsId = param.__echartsId || this.id; |
| var fromMyself = param.__echartsId === this.id; |
| if (!this._curEventType) { |
| this._curEventType = param.type; |
| } |
| switch (param.type) { |
| case ecConfig.EVENT.LEGEND_SELECTED: |
| this._onlegendSelected(param); |
| break; |
| case ecConfig.EVENT.DATA_ZOOM: |
| if (!fromMyself) { |
| var dz = this.component.dataZoom; |
| if (dz) { |
| dz.silence(true); |
| dz.absoluteZoom(param.zoom); |
| dz.silence(false); |
| } |
| } |
| this._ondataZoom(param); |
| break; |
| case ecConfig.EVENT.DATA_RANGE: |
| fromMyself && this._ondataRange(param); |
| break; |
| case ecConfig.EVENT.MAGIC_TYPE_CHANGED: |
| if (!fromMyself) { |
| var tb = this.component.toolbox; |
| if (tb) { |
| tb.silence(true); |
| tb.setMagicType(param.magicType); |
| tb.silence(false); |
| } |
| } |
| this._onmagicTypeChanged(param); |
| break; |
| case ecConfig.EVENT.DATA_VIEW_CHANGED: |
| fromMyself && this._ondataViewChanged(param); |
| break; |
| case ecConfig.EVENT.TOOLTIP_HOVER: |
| fromMyself && this._tooltipHover(param); |
| break; |
| case ecConfig.EVENT.RESTORE: |
| this._onrestore(); |
| break; |
| case ecConfig.EVENT.REFRESH: |
| fromMyself && this._onrefresh(param); |
| break; |
| case ecConfig.EVENT.TOOLTIP_IN_GRID: |
| case ecConfig.EVENT.TOOLTIP_OUT_GRID: |
| if (!fromMyself) { |
| var grid = this.component.grid; |
| if (grid) { |
| this._zr.trigger('mousemove', { |
| connectTrigger: true, |
| zrenderX: grid.getX() + param.x * grid.getWidth(), |
| zrenderY: grid.getY() + param.y * grid.getHeight() |
| }); |
| } |
| } else if (this._connected) { |
| var grid = this.component.grid; |
| if (grid) { |
| param.x = (param.event.zrenderX - grid.getX()) / grid.getWidth(); |
| param.y = (param.event.zrenderY - grid.getY()) / grid.getHeight(); |
| } |
| } |
| break; |
| } |
| if (this._connected && fromMyself && this._curEventType === param.type) { |
| for (var c in this._connected) { |
| this._connected[c].connectedEventHandler(param); |
| } |
| this._curEventType = null; |
| } |
| if (!fromMyself || !this._connected && fromMyself) { |
| this._curEventType = null; |
| } |
| }, |
| _onclick: function (param) { |
| callChartListMethodReverse(this, 'onclick', param); |
| if (param.target) { |
| var ecData = this._eventPackage(param.target); |
| if (ecData && ecData.seriesIndex != null) { |
| this._messageCenter.dispatch(ecConfig.EVENT.CLICK, param.event, ecData, this); |
| } |
| } |
| }, |
| _ondblclick: function (param) { |
| callChartListMethodReverse(this, 'ondblclick', param); |
| if (param.target) { |
| var ecData = this._eventPackage(param.target); |
| if (ecData && ecData.seriesIndex != null) { |
| this._messageCenter.dispatch(ecConfig.EVENT.DBLCLICK, param.event, ecData, this); |
| } |
| } |
| }, |
| _onmouseover: function (param) { |
| if (param.target) { |
| var ecData = this._eventPackage(param.target); |
| if (ecData && ecData.seriesIndex != null) { |
| this._messageCenter.dispatch(ecConfig.EVENT.HOVER, param.event, ecData, this); |
| } |
| } |
| }, |
| _onmouseout: function (param) { |
| if (param.target) { |
| var ecData = this._eventPackage(param.target); |
| if (ecData && ecData.seriesIndex != null) { |
| this._messageCenter.dispatch(ecConfig.EVENT.MOUSEOUT, param.event, ecData, this); |
| } |
| } |
| }, |
| _ondragstart: function (param) { |
| this._status = { |
| dragIn: false, |
| dragOut: false, |
| needRefresh: false |
| }; |
| callChartListMethodReverse(this, 'ondragstart', param); |
| }, |
| _ondragenter: function (param) { |
| callChartListMethodReverse(this, 'ondragenter', param); |
| }, |
| _ondragover: function (param) { |
| callChartListMethodReverse(this, 'ondragover', param); |
| }, |
| _ondragleave: function (param) { |
| callChartListMethodReverse(this, 'ondragleave', param); |
| }, |
| _ondrop: function (param) { |
| callChartListMethodReverse(this, 'ondrop', param, this._status); |
| this._island.ondrop(param, this._status); |
| }, |
| _ondragend: function (param) { |
| callChartListMethodReverse(this, 'ondragend', param, this._status); |
| this._timeline && this._timeline.ondragend(param, this._status); |
| this._island.ondragend(param, this._status); |
| if (this._status.needRefresh) { |
| this._syncBackupData(this._option); |
| var messageCenter = this._messageCenter; |
| messageCenter.dispatch(ecConfig.EVENT.DATA_CHANGED, param.event, this._eventPackage(param.target), this); |
| messageCenter.dispatch(ecConfig.EVENT.REFRESH, null, null, this); |
| } |
| }, |
| _onlegendSelected: function (param) { |
| this._status.needRefresh = false; |
| callChartListMethodReverse(this, 'onlegendSelected', param, this._status); |
| if (this._status.needRefresh) { |
| this._messageCenter.dispatch(ecConfig.EVENT.REFRESH, null, null, this); |
| } |
| }, |
| _ondataZoom: function (param) { |
| this._status.needRefresh = false; |
| callChartListMethodReverse(this, 'ondataZoom', param, this._status); |
| if (this._status.needRefresh) { |
| this._messageCenter.dispatch(ecConfig.EVENT.REFRESH, null, null, this); |
| } |
| }, |
| _ondataRange: function (param) { |
| this._clearEffect(); |
| this._status.needRefresh = false; |
| callChartListMethodReverse(this, 'ondataRange', param, this._status); |
| if (this._status.needRefresh) { |
| this._zr.refresh(); |
| } |
| }, |
| _onmagicTypeChanged: function () { |
| this._clearEffect(); |
| this._render(this._toolbox.getMagicOption()); |
| }, |
| _ondataViewChanged: function (param) { |
| this._syncBackupData(param.option); |
| this._messageCenter.dispatch(ecConfig.EVENT.DATA_CHANGED, null, param, this); |
| this._messageCenter.dispatch(ecConfig.EVENT.REFRESH, null, null, this); |
| }, |
| _tooltipHover: function (param) { |
| var tipShape = []; |
| callChartListMethodReverse(this, 'ontooltipHover', param, tipShape); |
| }, |
| _onrestore: function () { |
| this.restore(); |
| }, |
| _onrefresh: function (param) { |
| this._refreshInside = true; |
| this.refresh(param); |
| this._refreshInside = false; |
| }, |
| _syncBackupData: function (curOption) { |
| this.component.dataZoom && this.component.dataZoom.syncBackupData(curOption); |
| }, |
| _eventPackage: function (target) { |
| if (target) { |
| var ecData = require('./util/ecData'); |
| var seriesIndex = ecData.get(target, 'seriesIndex'); |
| var dataIndex = ecData.get(target, 'dataIndex'); |
| dataIndex = seriesIndex != -1 && this.component.dataZoom ? this.component.dataZoom.getRealDataIndex(seriesIndex, dataIndex) : dataIndex; |
| return { |
| seriesIndex: seriesIndex, |
| seriesName: (ecData.get(target, 'series') || {}).name, |
| dataIndex: dataIndex, |
| data: ecData.get(target, 'data'), |
| name: ecData.get(target, 'name'), |
| value: ecData.get(target, 'value'), |
| special: ecData.get(target, 'special') |
| }; |
| } |
| return; |
| }, |
| _render: function (magicOption) { |
| this._mergeGlobalConifg(magicOption); |
| var bgColor = magicOption.backgroundColor; |
| if (bgColor) { |
| if (!_canvasSupported && bgColor.indexOf('rgba') != -1) { |
| var cList = bgColor.split(','); |
| this.dom.style.filter = 'alpha(opacity=' + cList[3].substring(0, cList[3].lastIndexOf(')')) * 100 + ')'; |
| cList.length = 3; |
| cList[0] = cList[0].replace('a', ''); |
| this.dom.style.backgroundColor = cList.join(',') + ')'; |
| } else { |
| this.dom.style.backgroundColor = bgColor; |
| } |
| } |
| this._zr.clearAnimation(); |
| this._chartList = []; |
| var chartLibrary = require('./chart'); |
| var componentLibrary = require('./component'); |
| if (magicOption.xAxis || magicOption.yAxis) { |
| magicOption.grid = magicOption.grid || {}; |
| magicOption.dataZoom = magicOption.dataZoom || {}; |
| } |
| var componentList = [ |
| 'title', |
| 'legend', |
| 'tooltip', |
| 'dataRange', |
| 'roamController', |
| 'grid', |
| 'dataZoom', |
| 'xAxis', |
| 'yAxis', |
| 'polar' |
| ]; |
| var ComponentClass; |
| var componentType; |
| var component; |
| for (var i = 0, l = componentList.length; i < l; i++) { |
| componentType = componentList[i]; |
| component = this.component[componentType]; |
| if (magicOption[componentType]) { |
| if (component) { |
| component.refresh && component.refresh(magicOption); |
| } else { |
| ComponentClass = componentLibrary.get(/^[xy]Axis$/.test(componentType) ? 'axis' : componentType); |
| component = new ComponentClass(this._themeConfig, this._messageCenter, this._zr, magicOption, this, componentType); |
| this.component[componentType] = component; |
| } |
| this._chartList.push(component); |
| } else if (component) { |
| component.dispose(); |
| this.component[componentType] = null; |
| delete this.component[componentType]; |
| } |
| } |
| var ChartClass; |
| var chartType; |
| var chart; |
| var chartMap = {}; |
| for (var i = 0, l = magicOption.series.length; i < l; i++) { |
| chartType = magicOption.series[i].type; |
| if (!chartType) { |
| console.error('series[' + i + '] chart type has not been defined.'); |
| continue; |
| } |
| if (!chartMap[chartType]) { |
| chartMap[chartType] = true; |
| ChartClass = chartLibrary.get(chartType); |
| if (ChartClass) { |
| if (this.chart[chartType]) { |
| chart = this.chart[chartType]; |
| chart.refresh(magicOption); |
| } else { |
| chart = new ChartClass(this._themeConfig, this._messageCenter, this._zr, magicOption, this); |
| } |
| this._chartList.push(chart); |
| this.chart[chartType] = chart; |
| } else { |
| console.error(chartType + ' has not been required.'); |
| } |
| } |
| } |
| for (chartType in this.chart) { |
| if (chartType != ecConfig.CHART_TYPE_ISLAND && !chartMap[chartType]) { |
| this.chart[chartType].dispose(); |
| this.chart[chartType] = null; |
| delete this.chart[chartType]; |
| } |
| } |
| this.component.grid && this.component.grid.refixAxisShape(this.component); |
| this._island.refresh(magicOption); |
| this._toolbox.refresh(magicOption); |
| magicOption.animation && !magicOption.renderAsImage ? this._zr.refresh() : this._zr.render(); |
| var imgId = 'IMG' + this.id; |
| var img = document.getElementById(imgId); |
| if (magicOption.renderAsImage && _canvasSupported) { |
| if (img) { |
| img.src = this.getDataURL(magicOption.renderAsImage); |
| } else { |
| img = this.getImage(magicOption.renderAsImage); |
| img.id = imgId; |
| img.style.position = 'absolute'; |
| img.style.left = 0; |
| img.style.top = 0; |
| this.dom.firstChild.appendChild(img); |
| } |
| this.un(); |
| this._zr.un(); |
| this._disposeChartList(); |
| this._zr.clear(); |
| } else if (img) { |
| img.parentNode.removeChild(img); |
| } |
| img = null; |
| this._option = magicOption; |
| }, |
| restore: function () { |
| this._clearEffect(); |
| this._option = zrUtil.clone(this._optionRestore); |
| this._disposeChartList(); |
| this._island.clear(); |
| this._toolbox.reset(this._option, true); |
| this._render(this._option); |
| }, |
| refresh: function (param) { |
| this._clearEffect(); |
| param = param || {}; |
| var magicOption = param.option; |
| if (!this._refreshInside && magicOption) { |
| magicOption = this.getOption(); |
| zrUtil.merge(magicOption, param.option, true); |
| zrUtil.merge(this._optionRestore, param.option, true); |
| this._toolbox.reset(magicOption); |
| } |
| this._island.refresh(magicOption); |
| this._toolbox.refresh(magicOption); |
| this._zr.clearAnimation(); |
| for (var i = 0, l = this._chartList.length; i < l; i++) { |
| this._chartList[i].refresh && this._chartList[i].refresh(magicOption); |
| } |
| this.component.grid && this.component.grid.refixAxisShape(this.component); |
| this._zr.refresh(); |
| }, |
| _disposeChartList: function () { |
| this._clearEffect(); |
| this._zr.clearAnimation(); |
| var len = this._chartList.length; |
| while (len--) { |
| var chart = this._chartList[len]; |
| if (chart) { |
| var chartType = chart.type; |
| this.chart[chartType] && delete this.chart[chartType]; |
| this.component[chartType] && delete this.component[chartType]; |
| chart.dispose && chart.dispose(); |
| } |
| } |
| this._chartList = []; |
| }, |
| _mergeGlobalConifg: function (magicOption) { |
| var mergeList = [ |
| 'backgroundColor', |
| 'calculable', |
| 'calculableColor', |
| 'calculableHolderColor', |
| 'nameConnector', |
| 'valueConnector', |
| 'animation', |
| 'animationThreshold', |
| 'animationDuration', |
| 'animationEasing', |
| 'addDataAnimation', |
| 'symbolList', |
| 'DRAG_ENABLE_TIME' |
| ]; |
| var len = mergeList.length; |
| while (len--) { |
| var mergeItem = mergeList[len]; |
| if (magicOption[mergeItem] == null) { |
| magicOption[mergeItem] = this._themeConfig[mergeItem]; |
| } |
| } |
| var themeColor = magicOption.color; |
| if (!(themeColor && themeColor.length)) { |
| themeColor = this._themeConfig.color; |
| } |
| if (!_canvasSupported) { |
| magicOption.animation = false; |
| magicOption.addDataAnimation = false; |
| } |
| this._zr.getColor = function (idx) { |
| var zrColor = require('zrender/tool/color'); |
| return zrColor.getColor(idx, themeColor); |
| }; |
| }, |
| setOption: function (option, notMerge) { |
| if (!option.timeline) { |
| return this._setOption(option, notMerge); |
| } else { |
| return this._setTimelineOption(option); |
| } |
| }, |
| _setOption: function (option, notMerge) { |
| if (!notMerge && this._option) { |
| this._option = zrUtil.merge(this.getOption(), zrUtil.clone(option), true); |
| } else { |
| this._option = zrUtil.clone(option); |
| } |
| this._optionRestore = zrUtil.clone(this._option); |
| if (!this._option.series || this._option.series.length === 0) { |
| this._zr.clear(); |
| return; |
| } |
| if (this.component.dataZoom && (this._option.dataZoom || this._option.toolbox && this._option.toolbox.feature && this._option.toolbox.feature.dataZoom && this._option.toolbox.feature.dataZoom.show)) { |
| this.component.dataZoom.syncOption(this._option); |
| } |
| this._toolbox.reset(this._option); |
| this._render(this._option); |
| return this; |
| }, |
| getOption: function () { |
| var magicOption = zrUtil.clone(this._option); |
| var self = this; |
| function restoreOption(prop) { |
| var restoreSource = self._optionRestore[prop]; |
| if (restoreSource) { |
| if (restoreSource instanceof Array) { |
| var len = restoreSource.length; |
| while (len--) { |
| magicOption[prop][len].data = zrUtil.clone(restoreSource[len].data); |
| } |
| } else { |
| magicOption[prop].data = zrUtil.clone(restoreSource.data); |
| } |
| } |
| } |
| restoreOption('xAxis'); |
| restoreOption('yAxis'); |
| restoreOption('series'); |
| return magicOption; |
| }, |
| setSeries: function (series, notMerge) { |
| if (!notMerge) { |
| this.setOption({ series: series }); |
| } else { |
| this._option.series = series; |
| this.setOption(this._option, notMerge); |
| } |
| return this; |
| }, |
| getSeries: function () { |
| return this.getOption().series; |
| }, |
| _setTimelineOption: function (option) { |
| this._timeline && this._timeline.dispose(); |
| var Timeline = require('./component/timeline'); |
| var timeline = new Timeline(this._themeConfig, this._messageCenter, this._zr, option, this); |
| this._timeline = timeline; |
| this.component.timeline = this._timeline; |
| return this; |
| }, |
| addData: function (seriesIdx, data, isHead, dataGrow, additionData) { |
| var params = seriesIdx instanceof Array ? seriesIdx : [[ |
| seriesIdx, |
| data, |
| isHead, |
| dataGrow, |
| additionData |
| ]]; |
| var magicOption = this.getOption(); |
| var optionRestore = this._optionRestore; |
| for (var i = 0, l = params.length; i < l; i++) { |
| seriesIdx = params[i][0]; |
| data = params[i][1]; |
| isHead = params[i][2]; |
| dataGrow = params[i][3]; |
| additionData = params[i][4]; |
| var seriesItem = optionRestore.series[seriesIdx]; |
| var inMethod = isHead ? 'unshift' : 'push'; |
| var outMethod = isHead ? 'pop' : 'shift'; |
| if (seriesItem) { |
| var seriesItemData = seriesItem.data; |
| var mSeriesItemData = magicOption.series[seriesIdx].data; |
| seriesItemData[inMethod](data); |
| mSeriesItemData[inMethod](data); |
| if (!dataGrow) { |
| seriesItemData[outMethod](); |
| data = mSeriesItemData[outMethod](); |
| } |
| if (additionData != null) { |
| var legend; |
| var legendData; |
| if (seriesItem.type === ecConfig.CHART_TYPE_PIE && (legend = optionRestore.legend) && (legendData = legend.data)) { |
| var mLegendData = magicOption.legend.data; |
| legendData[inMethod](additionData); |
| mLegendData[inMethod](additionData); |
| if (!dataGrow) { |
| var legendDataIdx = zrUtil.indexOf(legendData, data.name); |
| legendDataIdx != -1 && legendData.splice(legendDataIdx, 1); |
| legendDataIdx = zrUtil.indexOf(mLegendData, data.name); |
| legendDataIdx != -1 && mLegendData.splice(legendDataIdx, 1); |
| } |
| } else if (optionRestore.xAxis != null && optionRestore.yAxis != null) { |
| var axisData; |
| var mAxisData; |
| var axisIdx = seriesItem.xAxisIndex || 0; |
| if (optionRestore.xAxis[axisIdx].type == null || optionRestore.xAxis[axisIdx].type === 'category') { |
| axisData = optionRestore.xAxis[axisIdx].data; |
| mAxisData = magicOption.xAxis[axisIdx].data; |
| axisData[inMethod](additionData); |
| mAxisData[inMethod](additionData); |
| if (!dataGrow) { |
| axisData[outMethod](); |
| mAxisData[outMethod](); |
| } |
| } |
| axisIdx = seriesItem.yAxisIndex || 0; |
| if (optionRestore.yAxis[axisIdx].type === 'category') { |
| axisData = optionRestore.yAxis[axisIdx].data; |
| mAxisData = magicOption.yAxis[axisIdx].data; |
| axisData[inMethod](additionData); |
| mAxisData[inMethod](additionData); |
| if (!dataGrow) { |
| axisData[outMethod](); |
| mAxisData[outMethod](); |
| } |
| } |
| } |
| } |
| this._option.series[seriesIdx].data = magicOption.series[seriesIdx].data; |
| } |
| } |
| this._zr.clearAnimation(); |
| var chartList = this._chartList; |
| for (var i = 0, l = chartList.length; i < l; i++) { |
| if (magicOption.addDataAnimation && chartList[i].addDataAnimation) { |
| chartList[i].addDataAnimation(params); |
| } |
| } |
| this.component.dataZoom && this.component.dataZoom.syncOption(magicOption); |
| this._option = magicOption; |
| var self = this; |
| setTimeout(function () { |
| if (!self._zr) { |
| return; |
| } |
| self._zr.clearAnimation(); |
| for (var i = 0, l = chartList.length; i < l; i++) { |
| chartList[i].motionlessOnce = magicOption.addDataAnimation && chartList[i].addDataAnimation; |
| } |
| self._messageCenter.dispatch(ecConfig.EVENT.REFRESH, null, { option: magicOption }, self); |
| }, magicOption.addDataAnimation ? 500 : 0); |
| return this; |
| }, |
| addMarkPoint: function (seriesIdx, markData) { |
| return this._addMark(seriesIdx, markData, 'markPoint'); |
| }, |
| addMarkLine: function (seriesIdx, markData) { |
| return this._addMark(seriesIdx, markData, 'markLine'); |
| }, |
| _addMark: function (seriesIdx, markData, markType) { |
| var series = this._option.series; |
| var seriesItem; |
| if (series && (seriesItem = series[seriesIdx])) { |
| var seriesR = this._optionRestore.series; |
| var seriesRItem = seriesR[seriesIdx]; |
| var markOpt = seriesItem[markType]; |
| var markOptR = seriesRItem[markType]; |
| markOpt = seriesItem[markType] = markOpt || { data: [] }; |
| markOptR = seriesRItem[markType] = markOptR || { data: [] }; |
| for (var key in markData) { |
| if (key === 'data') { |
| markOpt.data = markOpt.data.concat(markData.data); |
| markOptR.data = markOptR.data.concat(markData.data); |
| } else if (typeof markData[key] != 'object' || markOpt[key] == null) { |
| markOpt[key] = markOptR[key] = markData[key]; |
| } else { |
| zrUtil.merge(markOpt[key], markData[key], true); |
| zrUtil.merge(markOptR[key], markData[key], true); |
| } |
| } |
| var chart = this.chart[seriesItem.type]; |
| chart && chart.addMark(seriesIdx, markData, markType); |
| } |
| return this; |
| }, |
| delMarkPoint: function (seriesIdx, markName) { |
| return this._delMark(seriesIdx, markName, 'markPoint'); |
| }, |
| delMarkLine: function (seriesIdx, markName) { |
| return this._delMark(seriesIdx, markName, 'markLine'); |
| }, |
| _delMark: function (seriesIdx, markName, markType) { |
| var series = this._option.series; |
| var seriesItem; |
| var mark; |
| var dataArray; |
| if (!(series && (seriesItem = series[seriesIdx]) && (mark = seriesItem[markType]) && (dataArray = mark.data))) { |
| return this; |
| } |
| markName = markName.split(' > '); |
| var targetIndex = -1; |
| for (var i = 0, l = dataArray.length; i < l; i++) { |
| var dataItem = dataArray[i]; |
| if (dataItem instanceof Array) { |
| if (dataItem[0].name === markName[0] && dataItem[1].name === markName[1]) { |
| targetIndex = i; |
| break; |
| } |
| } else if (dataItem.name === markName[0]) { |
| targetIndex = i; |
| break; |
| } |
| } |
| if (targetIndex > -1) { |
| dataArray.splice(targetIndex, 1); |
| this._optionRestore.series[seriesIdx][markType].data.splice(targetIndex, 1); |
| var chart = this.chart[seriesItem.type]; |
| chart && chart.delMark(seriesIdx, markName.join(' > '), markType); |
| } |
| return this; |
| }, |
| getDom: function () { |
| return this.dom; |
| }, |
| getZrender: function () { |
| return this._zr; |
| }, |
| getDataURL: function (imgType) { |
| if (!_canvasSupported) { |
| return ''; |
| } |
| if (this._chartList.length === 0) { |
| var imgId = 'IMG' + this.id; |
| var img = document.getElementById(imgId); |
| if (img) { |
| return img.src; |
| } |
| } |
| var tooltip = this.component.tooltip; |
| tooltip && tooltip.hideTip(); |
| switch (imgType) { |
| case 'jpeg': |
| break; |
| default: |
| imgType = 'png'; |
| } |
| var bgColor = this._option.backgroundColor; |
| if (bgColor && bgColor.replace(' ', '') === 'rgba(0,0,0,0)') { |
| bgColor = '#fff'; |
| } |
| return this._zr.toDataURL('image/' + imgType, bgColor); |
| }, |
| getImage: function (imgType) { |
| var title = this._optionRestore.title; |
| var imgDom = document.createElement('img'); |
| imgDom.src = this.getDataURL(imgType); |
| imgDom.title = title && title.text || 'ECharts'; |
| return imgDom; |
| }, |
| getConnectedDataURL: function (imgType) { |
| if (!this.isConnected()) { |
| return this.getDataURL(imgType); |
| } |
| var tempDom = this.dom; |
| var imgList = { |
| 'self': { |
| img: this.getDataURL(imgType), |
| left: tempDom.offsetLeft, |
| top: tempDom.offsetTop, |
| right: tempDom.offsetLeft + tempDom.offsetWidth, |
| bottom: tempDom.offsetTop + tempDom.offsetHeight |
| } |
| }; |
| var minLeft = imgList.self.left; |
| var minTop = imgList.self.top; |
| var maxRight = imgList.self.right; |
| var maxBottom = imgList.self.bottom; |
| for (var c in this._connected) { |
| tempDom = this._connected[c].getDom(); |
| imgList[c] = { |
| img: this._connected[c].getDataURL(imgType), |
| left: tempDom.offsetLeft, |
| top: tempDom.offsetTop, |
| right: tempDom.offsetLeft + tempDom.offsetWidth, |
| bottom: tempDom.offsetTop + tempDom.offsetHeight |
| }; |
| minLeft = Math.min(minLeft, imgList[c].left); |
| minTop = Math.min(minTop, imgList[c].top); |
| maxRight = Math.max(maxRight, imgList[c].right); |
| maxBottom = Math.max(maxBottom, imgList[c].bottom); |
| } |
| var zrDom = document.createElement('div'); |
| zrDom.style.position = 'absolute'; |
| zrDom.style.left = '-4000px'; |
| zrDom.style.width = maxRight - minLeft + 'px'; |
| zrDom.style.height = maxBottom - minTop + 'px'; |
| document.body.appendChild(zrDom); |
| var zrImg = require('zrender').init(zrDom); |
| var ImageShape = require('zrender/shape/Image'); |
| for (var c in imgList) { |
| zrImg.addShape(new ImageShape({ |
| style: { |
| x: imgList[c].left - minLeft, |
| y: imgList[c].top - minTop, |
| image: imgList[c].img |
| } |
| })); |
| } |
| zrImg.render(); |
| var bgColor = this._option.backgroundColor; |
| if (bgColor && bgColor.replace(/ /g, '') === 'rgba(0,0,0,0)') { |
| bgColor = '#fff'; |
| } |
| var image = zrImg.toDataURL('image/png', bgColor); |
| setTimeout(function () { |
| zrImg.dispose(); |
| zrDom.parentNode.removeChild(zrDom); |
| zrDom = null; |
| }, 100); |
| return image; |
| }, |
| getConnectedImage: function (imgType) { |
| var title = this._optionRestore.title; |
| var imgDom = document.createElement('img'); |
| imgDom.src = this.getConnectedDataURL(imgType); |
| imgDom.title = title && title.text || 'ECharts'; |
| return imgDom; |
| }, |
| on: function (eventName, eventListener) { |
| this._messageCenterOutSide.bind(eventName, eventListener, this); |
| return this; |
| }, |
| un: function (eventName, eventListener) { |
| this._messageCenterOutSide.unbind(eventName, eventListener); |
| return this; |
| }, |
| connect: function (connectTarget) { |
| if (!connectTarget) { |
| return this; |
| } |
| if (!this._connected) { |
| this._connected = {}; |
| } |
| if (connectTarget instanceof Array) { |
| for (var i = 0, l = connectTarget.length; i < l; i++) { |
| this._connected[connectTarget[i].id] = connectTarget[i]; |
| } |
| } else { |
| this._connected[connectTarget.id] = connectTarget; |
| } |
| return this; |
| }, |
| disConnect: function (connectTarget) { |
| if (!connectTarget || !this._connected) { |
| return this; |
| } |
| if (connectTarget instanceof Array) { |
| for (var i = 0, l = connectTarget.length; i < l; i++) { |
| delete this._connected[connectTarget[i].id]; |
| } |
| } else { |
| delete this._connected[connectTarget.id]; |
| } |
| for (var k in this._connected) { |
| return k, this; |
| } |
| this._connected = false; |
| return this; |
| }, |
| connectedEventHandler: function (param) { |
| if (param.__echartsId != this.id) { |
| this._onevent(param); |
| } |
| }, |
| isConnected: function () { |
| return !!this._connected; |
| }, |
| showLoading: function (loadingOption) { |
| var effectList = { |
| bar: require('zrender/loadingEffect/Bar'), |
| bubble: require('zrender/loadingEffect/Bubble'), |
| dynamicLine: require('zrender/loadingEffect/DynamicLine'), |
| ring: require('zrender/loadingEffect/Ring'), |
| spin: require('zrender/loadingEffect/Spin'), |
| whirling: require('zrender/loadingEffect/Whirling') |
| }; |
| this._toolbox.hideDataView(); |
| loadingOption = loadingOption || {}; |
| var textStyle = loadingOption.textStyle || {}; |
| loadingOption.textStyle = textStyle; |
| var finalTextStyle = zrUtil.merge(zrUtil.clone(textStyle), this._themeConfig.textStyle); |
| textStyle.textFont = finalTextStyle.fontStyle + ' ' + finalTextStyle.fontWeight + ' ' + finalTextStyle.fontSize + 'px ' + finalTextStyle.fontFamily; |
| textStyle.text = loadingOption.text || this._themeConfig.loadingText; |
| if (loadingOption.x != null) { |
| textStyle.x = loadingOption.x; |
| } |
| if (loadingOption.y != null) { |
| textStyle.y = loadingOption.y; |
| } |
| loadingOption.effectOption = loadingOption.effectOption || {}; |
| loadingOption.effectOption.textStyle = textStyle; |
| var Effect = loadingOption.effect; |
| if (typeof Effect === 'string' || Effect == null) { |
| Effect = effectList[loadingOption.effect || 'spin']; |
| } |
| this._zr.showLoading(new Effect(loadingOption.effectOption)); |
| return this; |
| }, |
| hideLoading: function () { |
| this._zr.hideLoading(); |
| return this; |
| }, |
| setTheme: function (theme) { |
| if (theme) { |
| if (typeof theme === 'string') { |
| switch (theme) { |
| default: |
| theme = require('./theme/default'); |
| } |
| } else { |
| theme = theme || {}; |
| } |
| for (var key in this._themeConfig) { |
| delete this._themeConfig[key]; |
| } |
| for (var key in ecConfig) { |
| this._themeConfig[key] = zrUtil.clone(ecConfig[key]); |
| } |
| theme.color && (this._themeConfig.color = []); |
| theme.symbolList && (this._themeConfig.symbolList = []); |
| zrUtil.merge(this._themeConfig, zrUtil.clone(theme), true); |
| } |
| if (!_canvasSupported) { |
| this._themeConfig.textStyle.fontFamily = this._themeConfig.textStyle.fontFamily2; |
| } |
| this._timeline && this._timeline.setTheme(true); |
| this._optionRestore && this.restore(); |
| }, |
| resize: function () { |
| var self = this; |
| return function () { |
| self._clearEffect(); |
| self._zr.resize(); |
| if (self._option && self._option.renderAsImage && _canvasSupported) { |
| self._render(self._option); |
| return self; |
| } |
| self._zr.clearAnimation(); |
| self._island.resize(); |
| self._toolbox.resize(); |
| self._timeline && self._timeline.resize(); |
| for (var i = 0, l = self._chartList.length; i < l; i++) { |
| self._chartList[i].resize && self._chartList[i].resize(); |
| } |
| self.component.grid && self.component.grid.refixAxisShape(self.component); |
| self._zr.refresh(); |
| self._messageCenter.dispatch(ecConfig.EVENT.RESIZE, null, null, self); |
| return self; |
| }; |
| }, |
| _clearEffect: function () { |
| this._zr.modLayer(ecConfig.EFFECT_ZLEVEL, { motionBlur: false }); |
| this._zr.painter.clearLayer(ecConfig.EFFECT_ZLEVEL); |
| }, |
| clear: function () { |
| this._disposeChartList(); |
| this._zr.clear(); |
| this._option = {}; |
| this._optionRestore = {}; |
| this.dom.style.backgroundColor = null; |
| return this; |
| }, |
| dispose: function () { |
| var key = this.dom.getAttribute(DOM_ATTRIBUTE_KEY); |
| key && delete _instances[key]; |
| this._island.dispose(); |
| this._toolbox.dispose(); |
| this._timeline && this._timeline.dispose(); |
| this._messageCenter.unbind(); |
| this.clear(); |
| this._zr.dispose(); |
| this._zr = null; |
| } |
| }; |
| return self; |
| });define('echarts/config', [], function () { |
| var config = { |
| CHART_TYPE_LINE: 'line', |
| CHART_TYPE_BAR: 'bar', |
| CHART_TYPE_SCATTER: 'scatter', |
| CHART_TYPE_PIE: 'pie', |
| CHART_TYPE_RADAR: 'radar', |
| CHART_TYPE_MAP: 'map', |
| CHART_TYPE_K: 'k', |
| CHART_TYPE_ISLAND: 'island', |
| CHART_TYPE_FORCE: 'force', |
| CHART_TYPE_CHORD: 'chord', |
| CHART_TYPE_GAUGE: 'gauge', |
| CHART_TYPE_FUNNEL: 'funnel', |
| CHART_TYPE_EVENTRIVER: 'eventRiver', |
| COMPONENT_TYPE_TITLE: 'title', |
| COMPONENT_TYPE_LEGEND: 'legend', |
| COMPONENT_TYPE_DATARANGE: 'dataRange', |
| COMPONENT_TYPE_DATAVIEW: 'dataView', |
| COMPONENT_TYPE_DATAZOOM: 'dataZoom', |
| COMPONENT_TYPE_TOOLBOX: 'toolbox', |
| COMPONENT_TYPE_TOOLTIP: 'tooltip', |
| COMPONENT_TYPE_GRID: 'grid', |
| COMPONENT_TYPE_AXIS: 'axis', |
| COMPONENT_TYPE_POLAR: 'polar', |
| COMPONENT_TYPE_X_AXIS: 'xAxis', |
| COMPONENT_TYPE_Y_AXIS: 'yAxis', |
| COMPONENT_TYPE_AXIS_CATEGORY: 'categoryAxis', |
| COMPONENT_TYPE_AXIS_VALUE: 'valueAxis', |
| COMPONENT_TYPE_TIMELINE: 'timeline', |
| COMPONENT_TYPE_ROAMCONTROLLER: 'roamController', |
| backgroundColor: 'rgba(0,0,0,0)', |
| color: [ |
| '#ff7f50', |
| '#87cefa', |
| '#da70d6', |
| '#32cd32', |
| '#6495ed', |
| '#ff69b4', |
| '#ba55d3', |
| '#cd5c5c', |
| '#ffa500', |
| '#40e0d0', |
| '#1e90ff', |
| '#ff6347', |
| '#7b68ee', |
| '#00fa9a', |
| '#ffd700', |
| '#6699FF', |
| '#ff6666', |
| '#3cb371', |
| '#b8860b', |
| '#30e0e0' |
| ], |
| title: { |
| text: '', |
| subtext: '', |
| x: 'left', |
| y: 'top', |
| backgroundColor: 'rgba(0,0,0,0)', |
| borderColor: '#ccc', |
| borderWidth: 0, |
| padding: 5, |
| itemGap: 5, |
| textStyle: { |
| fontSize: 18, |
| fontWeight: 'bolder', |
| color: '#333' |
| }, |
| subtextStyle: { color: '#aaa' } |
| }, |
| legend: { |
| show: true, |
| orient: 'horizontal', |
| x: 'center', |
| y: 'top', |
| backgroundColor: 'rgba(0,0,0,0)', |
| borderColor: '#ccc', |
| borderWidth: 0, |
| padding: 5, |
| itemGap: 10, |
| itemWidth: 20, |
| itemHeight: 14, |
| textStyle: { color: '#333' }, |
| selectedMode: true |
| }, |
| dataRange: { |
| show: true, |
| orient: 'vertical', |
| x: 'left', |
| y: 'bottom', |
| backgroundColor: 'rgba(0,0,0,0)', |
| borderColor: '#ccc', |
| borderWidth: 0, |
| padding: 5, |
| itemGap: 10, |
| itemWidth: 20, |
| itemHeight: 14, |
| precision: 0, |
| splitNumber: 5, |
| calculable: false, |
| hoverLink: true, |
| realtime: true, |
| color: [ |
| '#006edd', |
| '#e0ffff' |
| ], |
| textStyle: { color: '#333' } |
| }, |
| toolbox: { |
| show: false, |
| orient: 'horizontal', |
| x: 'right', |
| y: 'top', |
| color: [ |
| '#1e90ff', |
| '#22bb22', |
| '#4b0082', |
| '#d2691e' |
| ], |
| disableColor: '#ddd', |
| effectiveColor: 'red', |
| backgroundColor: 'rgba(0,0,0,0)', |
| borderColor: '#ccc', |
| borderWidth: 0, |
| padding: 5, |
| itemGap: 10, |
| itemSize: 16, |
| showTitle: true, |
| feature: { |
| mark: { |
| show: false, |
| title: { |
| mark: '辅助线开关', |
| markUndo: '删除辅助线', |
| markClear: '清空辅助线' |
| }, |
| lineStyle: { |
| width: 1, |
| color: '#1e90ff', |
| type: 'dashed' |
| } |
| }, |
| dataZoom: { |
| show: false, |
| title: { |
| dataZoom: '区域缩放', |
| dataZoomReset: '区域缩放后退' |
| } |
| }, |
| dataView: { |
| show: false, |
| title: '数据视图', |
| readOnly: false, |
| lang: [ |
| '数据视图', |
| '关闭', |
| '刷新' |
| ] |
| }, |
| magicType: { |
| show: false, |
| title: { |
| line: '折线图切换', |
| bar: '柱形图切换', |
| stack: '堆积', |
| tiled: '平铺', |
| force: '力导向布局图切换', |
| chord: '和弦图切换', |
| pie: '饼图切换', |
| funnel: '漏斗图切换' |
| }, |
| type: [] |
| }, |
| restore: { |
| show: false, |
| title: '还原' |
| }, |
| saveAsImage: { |
| show: false, |
| title: '保存为图片', |
| type: 'png', |
| lang: ['点击保存'] |
| } |
| } |
| }, |
| tooltip: { |
| show: true, |
| showContent: true, |
| trigger: 'item', |
| islandFormatter: '{a} <br/>{b} : {c}', |
| showDelay: 20, |
| hideDelay: 100, |
| transitionDuration: 0.4, |
| enterable: false, |
| backgroundColor: 'rgba(0,0,0,0.7)', |
| borderColor: '#333', |
| borderRadius: 4, |
| borderWidth: 0, |
| padding: 5, |
| axisPointer: { |
| type: 'line', |
| lineStyle: { |
| color: '#48b', |
| width: 2, |
| type: 'solid' |
| }, |
| crossStyle: { |
| color: '#1e90ff', |
| width: 1, |
| type: 'dashed' |
| }, |
| shadowStyle: { |
| color: 'rgba(150,150,150,0.3)', |
| width: 'auto', |
| type: 'default' |
| } |
| }, |
| textStyle: { color: '#fff' } |
| }, |
| dataZoom: { |
| show: false, |
| orient: 'horizontal', |
| backgroundColor: 'rgba(0,0,0,0)', |
| dataBackgroundColor: '#eee', |
| fillerColor: 'rgba(144,197,237,0.2)', |
| handleColor: 'rgba(70,130,180,0.8)', |
| showDetail: true, |
| realtime: true |
| }, |
| grid: { |
| x: 80, |
| y: 60, |
| x2: 80, |
| y2: 60, |
| backgroundColor: 'rgba(0,0,0,0)', |
| borderWidth: 1, |
| borderColor: '#ccc' |
| }, |
| categoryAxis: { |
| show: true, |
| position: 'bottom', |
| name: '', |
| nameLocation: 'end', |
| nameTextStyle: {}, |
| boundaryGap: true, |
| axisLine: { |
| show: true, |
| onZero: true, |
| lineStyle: { |
| color: '#48b', |
| width: 2, |
| type: 'solid' |
| } |
| }, |
| axisTick: { |
| show: true, |
| interval: 'auto', |
| inside: false, |
| length: 5, |
| lineStyle: { |
| color: '#333', |
| width: 1 |
| } |
| }, |
| axisLabel: { |
| show: true, |
| interval: 'auto', |
| rotate: 0, |
| margin: 8, |
| textStyle: { color: '#333' } |
| }, |
| splitLine: { |
| show: true, |
| lineStyle: { |
| color: ['#ccc'], |
| width: 1, |
| type: 'solid' |
| } |
| }, |
| splitArea: { |
| show: false, |
| areaStyle: { |
| color: [ |
| 'rgba(250,250,250,0.3)', |
| 'rgba(200,200,200,0.3)' |
| ] |
| } |
| } |
| }, |
| valueAxis: { |
| show: true, |
| position: 'left', |
| name: '', |
| nameLocation: 'end', |
| nameTextStyle: {}, |
| boundaryGap: [ |
| 0, |
| 0 |
| ], |
| axisLine: { |
| show: true, |
| onZero: true, |
| lineStyle: { |
| color: '#48b', |
| width: 2, |
| type: 'solid' |
| } |
| }, |
| axisTick: { |
| show: false, |
| inside: false, |
| length: 5, |
| lineStyle: { |
| color: '#333', |
| width: 1 |
| } |
| }, |
| axisLabel: { |
| show: true, |
| rotate: 0, |
| margin: 8, |
| textStyle: { color: '#333' } |
| }, |
| splitLine: { |
| show: true, |
| lineStyle: { |
| color: ['#ccc'], |
| width: 1, |
| type: 'solid' |
| } |
| }, |
| splitArea: { |
| show: false, |
| areaStyle: { |
| color: [ |
| 'rgba(250,250,250,0.3)', |
| 'rgba(200,200,200,0.3)' |
| ] |
| } |
| } |
| }, |
| polar: { |
| center: [ |
| '50%', |
| '50%' |
| ], |
| radius: '75%', |
| startAngle: 90, |
| boundaryGap: [ |
| 0, |
| 0 |
| ], |
| splitNumber: 5, |
| name: { |
| show: true, |
| textStyle: { color: '#333' } |
| }, |
| axisLine: { |
| show: true, |
| lineStyle: { |
| color: '#ccc', |
| width: 1, |
| type: 'solid' |
| } |
| }, |
| axisLabel: { |
| show: false, |
| textStyle: { color: '#333' } |
| }, |
| splitArea: { |
| show: true, |
| areaStyle: { |
| color: [ |
| 'rgba(250,250,250,0.3)', |
| 'rgba(200,200,200,0.3)' |
| ] |
| } |
| }, |
| splitLine: { |
| show: true, |
| lineStyle: { |
| width: 1, |
| color: '#ccc' |
| } |
| }, |
| type: 'polygon' |
| }, |
| timeline: { |
| show: true, |
| type: 'time', |
| notMerge: false, |
| realtime: true, |
| x: 80, |
| x2: 80, |
| y2: 0, |
| height: 50, |
| backgroundColor: 'rgba(0,0,0,0)', |
| borderColor: '#ccc', |
| borderWidth: 0, |
| padding: 5, |
| controlPosition: 'left', |
| autoPlay: false, |
| loop: true, |
| playInterval: 2000, |
| lineStyle: { |
| width: 1, |
| color: '#666', |
| type: 'dashed' |
| }, |
| label: { |
| show: true, |
| interval: 'auto', |
| rotate: 0, |
| textStyle: { color: '#333' } |
| }, |
| checkpointStyle: { |
| symbol: 'auto', |
| symbolSize: 'auto', |
| color: 'auto', |
| borderColor: 'auto', |
| borderWidth: 'auto', |
| label: { |
| show: false, |
| textStyle: { color: 'auto' } |
| } |
| }, |
| controlStyle: { |
| normal: { color: '#333' }, |
| emphasis: { color: '#1e90ff' } |
| }, |
| symbol: 'emptyDiamond', |
| symbolSize: 4, |
| currentIndex: 0 |
| }, |
| roamController: { |
| show: true, |
| x: 'left', |
| y: 'top', |
| width: 80, |
| height: 120, |
| backgroundColor: 'rgba(0,0,0,0)', |
| borderColor: '#ccc', |
| borderWidth: 0, |
| padding: 5, |
| handleColor: '#6495ed', |
| fillerColor: '#fff', |
| step: 15, |
| mapTypeControl: null |
| }, |
| bar: { |
| clickable: true, |
| legendHoverLink: true, |
| xAxisIndex: 0, |
| yAxisIndex: 0, |
| barMinHeight: 0, |
| barGap: '30%', |
| barCategoryGap: '20%', |
| itemStyle: { |
| normal: { |
| barBorderColor: '#fff', |
| barBorderRadius: 0, |
| barBorderWidth: 0, |
| label: { show: false } |
| }, |
| emphasis: { |
| barBorderColor: '#fff', |
| barBorderRadius: 0, |
| barBorderWidth: 0, |
| label: { show: false } |
| } |
| } |
| }, |
| line: { |
| clickable: true, |
| legendHoverLink: true, |
| xAxisIndex: 0, |
| yAxisIndex: 0, |
| itemStyle: { |
| normal: { |
| label: { show: false }, |
| lineStyle: { |
| width: 2, |
| type: 'solid', |
| shadowColor: 'rgba(0,0,0,0)', |
| shadowBlur: 0, |
| shadowOffsetX: 0, |
| shadowOffsetY: 0 |
| } |
| }, |
| emphasis: { label: { show: false } } |
| }, |
| symbolSize: 2, |
| showAllSymbol: false |
| }, |
| k: { |
| clickable: true, |
| legendHoverLink: false, |
| xAxisIndex: 0, |
| yAxisIndex: 0, |
| itemStyle: { |
| normal: { |
| color: '#fff', |
| color0: '#00aa11', |
| lineStyle: { |
| width: 1, |
| color: '#ff3200', |
| color0: '#00aa11' |
| } |
| }, |
| emphasis: {} |
| } |
| }, |
| scatter: { |
| clickable: true, |
| legendHoverLink: true, |
| xAxisIndex: 0, |
| yAxisIndex: 0, |
| symbolSize: 4, |
| large: false, |
| largeThreshold: 2000, |
| itemStyle: { |
| normal: { |
| label: { |
| show: false, |
| formatter: function (a, b, c) { |
| if (typeof c[2] != 'undefined') { |
| return c[2]; |
| } else { |
| return c[0] + ' , ' + c[1]; |
| } |
| } |
| } |
| }, |
| emphasis: { |
| label: { |
| show: false, |
| formatter: function (a, b, c) { |
| if (typeof c[2] != 'undefined') { |
| return c[2]; |
| } else { |
| return c[0] + ' , ' + c[1]; |
| } |
| } |
| } |
| } |
| } |
| }, |
| radar: { |
| clickable: true, |
| legendHoverLink: true, |
| polarIndex: 0, |
| itemStyle: { |
| normal: { |
| label: { show: false }, |
| lineStyle: { |
| width: 2, |
| type: 'solid' |
| } |
| }, |
| emphasis: { label: { show: false } } |
| }, |
| symbolSize: 2 |
| }, |
| pie: { |
| clickable: true, |
| legendHoverLink: true, |
| center: [ |
| '50%', |
| '50%' |
| ], |
| radius: [ |
| 0, |
| '75%' |
| ], |
| clockWise: true, |
| startAngle: 90, |
| minAngle: 0, |
| selectedOffset: 10, |
| itemStyle: { |
| normal: { |
| borderColor: 'rgba(0,0,0,0)', |
| borderWidth: 1, |
| label: { |
| show: true, |
| position: 'outer' |
| }, |
| labelLine: { |
| show: true, |
| length: 20, |
| lineStyle: { |
| width: 1, |
| type: 'solid' |
| } |
| } |
| }, |
| emphasis: { |
| borderColor: 'rgba(0,0,0,0)', |
| borderWidth: 1, |
| label: { show: false }, |
| labelLine: { |
| show: false, |
| length: 20, |
| lineStyle: { |
| width: 1, |
| type: 'solid' |
| } |
| } |
| } |
| } |
| }, |
| map: { |
| mapType: 'china', |
| mapValuePrecision: 0, |
| showLegendSymbol: true, |
| dataRangeHoverLink: true, |
| hoverable: true, |
| clickable: true, |
| itemStyle: { |
| normal: { |
| borderColor: 'rgba(0,0,0,0)', |
| borderWidth: 1, |
| areaStyle: { color: '#ccc' }, |
| label: { |
| show: false, |
| textStyle: { color: 'rgb(139,69,19)' } |
| } |
| }, |
| emphasis: { |
| borderColor: 'rgba(0,0,0,0)', |
| borderWidth: 1, |
| areaStyle: { color: 'rgba(255,215,0,0.8)' }, |
| label: { |
| show: false, |
| textStyle: { color: 'rgb(100,0,0)' } |
| } |
| } |
| } |
| }, |
| force: { |
| center: [ |
| '50%', |
| '50%' |
| ], |
| size: '100%', |
| preventOverlap: false, |
| coolDown: 0.99, |
| minRadius: 10, |
| maxRadius: 20, |
| ratioScaling: false, |
| large: false, |
| useWorker: false, |
| steps: 1, |
| scaling: 1, |
| gravity: 1, |
| symbol: 'circle', |
| symbolSize: 0, |
| linkSymbol: null, |
| linkSymbolSize: [ |
| 10, |
| 15 |
| ], |
| draggable: true, |
| clickable: true, |
| roam: false, |
| itemStyle: { |
| normal: { |
| label: { |
| show: false, |
| position: 'inside' |
| }, |
| nodeStyle: { |
| brushType: 'both', |
| borderColor: '#5182ab', |
| borderWidth: 1 |
| }, |
| linkStyle: { |
| color: '#5182ab', |
| width: 1, |
| type: 'line' |
| } |
| }, |
| emphasis: { |
| label: { show: false }, |
| nodeStyle: {}, |
| linkStyle: { opacity: 0 } |
| } |
| } |
| }, |
| chord: { |
| clickable: true, |
| radius: [ |
| '65%', |
| '75%' |
| ], |
| center: [ |
| '50%', |
| '50%' |
| ], |
| padding: 2, |
| sort: 'none', |
| sortSub: 'none', |
| startAngle: 90, |
| clockWise: true, |
| ribbonType: true, |
| minRadius: 10, |
| maxRadius: 20, |
| symbol: 'circle', |
| showScale: false, |
| showScaleText: false, |
| itemStyle: { |
| normal: { |
| borderWidth: 0, |
| borderColor: '#000', |
| label: { |
| show: true, |
| rotate: false, |
| distance: 5 |
| }, |
| chordStyle: { |
| width: 1, |
| color: 'black', |
| borderWidth: 1, |
| borderColor: '#999', |
| opacity: 0.5 |
| } |
| }, |
| emphasis: { |
| borderWidth: 0, |
| borderColor: '#000', |
| chordStyle: { |
| width: 1, |
| color: 'black', |
| borderWidth: 1, |
| borderColor: '#999' |
| } |
| } |
| } |
| }, |
| gauge: { |
| center: [ |
| '50%', |
| '50%' |
| ], |
| legendHoverLink: true, |
| radius: '75%', |
| startAngle: 225, |
| endAngle: -45, |
| min: 0, |
| max: 100, |
| precision: 0, |
| splitNumber: 10, |
| axisLine: { |
| show: true, |
| lineStyle: { |
| color: [ |
| [ |
| 0.2, |
| '#228b22' |
| ], |
| [ |
| 0.8, |
| '#48b' |
| ], |
| [ |
| 1, |
| '#ff4500' |
| ] |
| ], |
| width: 30 |
| } |
| }, |
| axisTick: { |
| show: true, |
| splitNumber: 5, |
| length: 8, |
| lineStyle: { |
| color: '#eee', |
| width: 1, |
| type: 'solid' |
| } |
| }, |
| axisLabel: { |
| show: true, |
| textStyle: { color: 'auto' } |
| }, |
| splitLine: { |
| show: true, |
| length: 30, |
| lineStyle: { |
| color: '#eee', |
| width: 2, |
| type: 'solid' |
| } |
| }, |
| pointer: { |
| show: true, |
| length: '80%', |
| width: 8, |
| color: 'auto' |
| }, |
| title: { |
| show: true, |
| offsetCenter: [ |
| 0, |
| '-40%' |
| ], |
| textStyle: { |
| color: '#333', |
| fontSize: 15 |
| } |
| }, |
| detail: { |
| show: true, |
| backgroundColor: 'rgba(0,0,0,0)', |
| borderWidth: 0, |
| borderColor: '#ccc', |
| width: 100, |
| height: 40, |
| offsetCenter: [ |
| 0, |
| '40%' |
| ], |
| textStyle: { |
| color: 'auto', |
| fontSize: 30 |
| } |
| } |
| }, |
| funnel: { |
| clickable: true, |
| legendHoverLink: true, |
| x: 80, |
| y: 60, |
| x2: 80, |
| y2: 60, |
| min: 0, |
| max: 100, |
| minSize: '0%', |
| maxSize: '100%', |
| sort: 'descending', |
| gap: 0, |
| funnelAlign: 'center', |
| itemStyle: { |
| normal: { |
| borderColor: '#fff', |
| borderWidth: 1, |
| label: { |
| show: true, |
| position: 'outer' |
| }, |
| labelLine: { |
| show: true, |
| length: 10, |
| lineStyle: { |
| width: 1, |
| type: 'solid' |
| } |
| } |
| }, |
| emphasis: { |
| borderColor: 'rgba(0,0,0,0)', |
| borderWidth: 1, |
| label: { show: true }, |
| labelLine: { show: true } |
| } |
| } |
| }, |
| eventRiver: { |
| clickable: true, |
| legendHoverLink: true, |
| itemStyle: { |
| normal: { |
| borderColor: 'rgba(0,0,0,0)', |
| borderWidth: 1, |
| label: { |
| show: true, |
| position: 'inside', |
| formatter: '{b}' |
| } |
| }, |
| emphasis: { |
| borderColor: 'rgba(0,0,0,0)', |
| borderWidth: 1, |
| label: { show: true } |
| } |
| } |
| }, |
| island: { |
| r: 15, |
| calculateStep: 0.1 |
| }, |
| markPoint: { |
| clickable: true, |
| symbol: 'pin', |
| symbolSize: 10, |
| large: false, |
| effect: { |
| show: false, |
| loop: true, |
| period: 15, |
| scaleSize: 2 |
| }, |
| itemStyle: { |
| normal: { |
| borderWidth: 2, |
| label: { |
| show: true, |
| position: 'inside' |
| } |
| }, |
| emphasis: { label: { show: true } } |
| } |
| }, |
| markLine: { |
| clickable: true, |
| symbol: [ |
| 'circle', |
| 'arrow' |
| ], |
| symbolSize: [ |
| 2, |
| 4 |
| ], |
| large: false, |
| effect: { |
| show: false, |
| loop: true, |
| period: 15, |
| scaleSize: 2 |
| }, |
| itemStyle: { |
| normal: { |
| borderWidth: 1.5, |
| label: { |
| show: true, |
| position: 'end' |
| }, |
| lineStyle: { type: 'dashed' } |
| }, |
| emphasis: { |
| label: { show: false }, |
| lineStyle: {} |
| } |
| } |
| }, |
| textStyle: { |
| decoration: 'none', |
| fontFamily: 'Arial, Verdana, sans-serif', |
| fontFamily2: '微软雅黑', |
| fontSize: 12, |
| fontStyle: 'normal', |
| fontWeight: 'normal' |
| }, |
| EVENT: { |
| REFRESH: 'refresh', |
| RESTORE: 'restore', |
| RESIZE: 'resize', |
| CLICK: 'click', |
| DBLCLICK: 'dblclick', |
| HOVER: 'hover', |
| MOUSEOUT: 'mouseout', |
| DATA_CHANGED: 'dataChanged', |
| DATA_ZOOM: 'dataZoom', |
| DATA_RANGE: 'dataRange', |
| DATA_RANGE_HOVERLINK: 'dataRangeHoverLink', |
| LEGEND_SELECTED: 'legendSelected', |
| LEGEND_HOVERLINK: 'legendHoverLink', |
| MAP_SELECTED: 'mapSelected', |
| PIE_SELECTED: 'pieSelected', |
| MAGIC_TYPE_CHANGED: 'magicTypeChanged', |
| DATA_VIEW_CHANGED: 'dataViewChanged', |
| TIMELINE_CHANGED: 'timelineChanged', |
| MAP_ROAM: 'mapRoam', |
| FORCE_LAYOUT_END: 'forceLayoutEnd', |
| TOOLTIP_HOVER: 'tooltipHover', |
| TOOLTIP_IN_GRID: 'tooltipInGrid', |
| TOOLTIP_OUT_GRID: 'tooltipOutGrid', |
| ROAMCONTROLLER: 'roamController' |
| }, |
| DRAG_ENABLE_TIME: 120, |
| EFFECT_ZLEVEL: 7, |
| symbolList: [ |
| 'circle', |
| 'rectangle', |
| 'triangle', |
| 'diamond', |
| 'emptyCircle', |
| 'emptyRectangle', |
| 'emptyTriangle', |
| 'emptyDiamond' |
| ], |
| loadingText: 'Loading...', |
| calculable: false, |
| calculableColor: 'rgba(255,165,0,0.6)', |
| calculableHolderColor: '#ccc', |
| nameConnector: ' & ', |
| valueConnector: ': ', |
| animation: true, |
| addDataAnimation: true, |
| animationThreshold: 2000, |
| animationDuration: 2000, |
| animationEasing: 'ExponentialOut' |
| }; |
| return config; |
| });define('zrender/tool/util', [ |
| 'require', |
| '../dep/excanvas' |
| ], function (require) { |
| var BUILTIN_OBJECT = { |
| '[object Function]': 1, |
| '[object RegExp]': 1, |
| '[object Date]': 1, |
| '[object Error]': 1, |
| '[object CanvasGradient]': 1 |
| }; |
| function clone(source) { |
| if (typeof source == 'object' && source !== null) { |
| var result = source; |
| if (source instanceof Array) { |
| result = []; |
| for (var i = 0, len = source.length; i < len; i++) { |
| result[i] = clone(source[i]); |
| } |
| } else if (!BUILTIN_OBJECT[Object.prototype.toString.call(source)]) { |
| result = {}; |
| for (var key in source) { |
| if (source.hasOwnProperty(key)) { |
| result[key] = clone(source[key]); |
| } |
| } |
| } |
| return result; |
| } |
| return source; |
| } |
| function mergeItem(target, source, key, overwrite) { |
| if (source.hasOwnProperty(key)) { |
| if (typeof target[key] == 'object' && !BUILTIN_OBJECT[Object.prototype.toString.call(target[key])]) { |
| merge(target[key], source[key], overwrite); |
| } else if (overwrite || !(key in target)) { |
| target[key] = source[key]; |
| } |
| } |
| } |
| function merge(target, source, overwrite) { |
| for (var i in source) { |
| mergeItem(target, source, i, overwrite); |
| } |
| return target; |
| } |
| var _ctx; |
| function getContext() { |
| if (!_ctx) { |
| require('../dep/excanvas'); |
| if (window['G_vmlCanvasManager']) { |
| var _div = document.createElement('div'); |
| _div.style.position = 'absolute'; |
| _div.style.top = '-1000px'; |
| document.body.appendChild(_div); |
| _ctx = G_vmlCanvasManager.initElement(_div).getContext('2d'); |
| } else { |
| _ctx = document.createElement('canvas').getContext('2d'); |
| } |
| } |
| return _ctx; |
| } |
| var _canvas; |
| var _pixelCtx; |
| var _width; |
| var _height; |
| var _offsetX = 0; |
| var _offsetY = 0; |
| function getPixelContext() { |
| if (!_pixelCtx) { |
| _canvas = document.createElement('canvas'); |
| _width = _canvas.width; |
| _height = _canvas.height; |
| _pixelCtx = _canvas.getContext('2d'); |
| } |
| return _pixelCtx; |
| } |
| function adjustCanvasSize(x, y) { |
| var _v = 100; |
| var _flag; |
| if (x + _offsetX > _width) { |
| _width = x + _offsetX + _v; |
| _canvas.width = _width; |
| _flag = true; |
| } |
| if (y + _offsetY > _height) { |
| _height = y + _offsetY + _v; |
| _canvas.height = _height; |
| _flag = true; |
| } |
| if (x < -_offsetX) { |
| _offsetX = Math.ceil(-x / _v) * _v; |
| _width += _offsetX; |
| _canvas.width = _width; |
| _flag = true; |
| } |
| if (y < -_offsetY) { |
| _offsetY = Math.ceil(-y / _v) * _v; |
| _height += _offsetY; |
| _canvas.height = _height; |
| _flag = true; |
| } |
| if (_flag) { |
| _pixelCtx.translate(_offsetX, _offsetY); |
| } |
| } |
| function getPixelOffset() { |
| return { |
| x: _offsetX, |
| y: _offsetY |
| }; |
| } |
| function indexOf(array, value) { |
| if (array.indexOf) { |
| return array.indexOf(value); |
| } |
| for (var i = 0, len = array.length; i < len; i++) { |
| if (array[i] === value) { |
| return i; |
| } |
| } |
| return -1; |
| } |
| function inherits(clazz, baseClazz) { |
| var clazzPrototype = clazz.prototype; |
| function F() { |
| } |
| F.prototype = baseClazz.prototype; |
| clazz.prototype = new F(); |
| for (var prop in clazzPrototype) { |
| clazz.prototype[prop] = clazzPrototype[prop]; |
| } |
| clazz.constructor = clazz; |
| } |
| return { |
| inherits: inherits, |
| clone: clone, |
| merge: merge, |
| getContext: getContext, |
| getPixelContext: getPixelContext, |
| getPixelOffset: getPixelOffset, |
| adjustCanvasSize: adjustCanvasSize, |
| indexOf: indexOf |
| }; |
| });define('zrender/tool/event', [ |
| 'require', |
| '../mixin/Eventful' |
| ], function (require) { |
| 'use strict'; |
| var Eventful = require('../mixin/Eventful'); |
| function getX(e) { |
| return typeof e.zrenderX != 'undefined' && e.zrenderX || typeof e.offsetX != 'undefined' && e.offsetX || typeof e.layerX != 'undefined' && e.layerX || typeof e.clientX != 'undefined' && e.clientX; |
| } |
| function getY(e) { |
| return typeof e.zrenderY != 'undefined' && e.zrenderY || typeof e.offsetY != 'undefined' && e.offsetY || typeof e.layerY != 'undefined' && e.layerY || typeof e.clientY != 'undefined' && e.clientY; |
| } |
| function getDelta(e) { |
| return typeof e.zrenderDelta != 'undefined' && e.zrenderDelta || typeof e.wheelDelta != 'undefined' && e.wheelDelta || typeof e.detail != 'undefined' && -e.detail; |
| } |
| var stop = typeof window.addEventListener === 'function' ? function (e) { |
| e.preventDefault(); |
| e.stopPropagation(); |
| e.cancelBubble = true; |
| } : function (e) { |
| e.returnValue = false; |
| e.cancelBubble = true; |
| }; |
| return { |
| getX: getX, |
| getY: getY, |
| getDelta: getDelta, |
| stop: stop, |
| Dispatcher: Eventful |
| }; |
| });define('zrender/tool/env', [], function () { |
| function detect(ua) { |
| var os = this.os = {}; |
| var browser = this.browser = {}; |
| var webkit = ua.match(/Web[kK]it[\/]{0,1}([\d.]+)/); |
| var android = ua.match(/(Android);?[\s\/]+([\d.]+)?/); |
| var ipad = ua.match(/(iPad).*OS\s([\d_]+)/); |
| var ipod = ua.match(/(iPod)(.*OS\s([\d_]+))?/); |
| var iphone = !ipad && ua.match(/(iPhone\sOS)\s([\d_]+)/); |
| var webos = ua.match(/(webOS|hpwOS)[\s\/]([\d.]+)/); |
| var touchpad = webos && ua.match(/TouchPad/); |
| var kindle = ua.match(/Kindle\/([\d.]+)/); |
| var silk = ua.match(/Silk\/([\d._]+)/); |
| var blackberry = ua.match(/(BlackBerry).*Version\/([\d.]+)/); |
| var bb10 = ua.match(/(BB10).*Version\/([\d.]+)/); |
| var rimtabletos = ua.match(/(RIM\sTablet\sOS)\s([\d.]+)/); |
| var playbook = ua.match(/PlayBook/); |
| var chrome = ua.match(/Chrome\/([\d.]+)/) || ua.match(/CriOS\/([\d.]+)/); |
| var firefox = ua.match(/Firefox\/([\d.]+)/); |
| var ie = ua.match(/MSIE ([\d.]+)/); |
| var safari = webkit && ua.match(/Mobile\//) && !chrome; |
| var webview = ua.match(/(iPhone|iPod|iPad).*AppleWebKit(?!.*Safari)/) && !chrome; |
| var ie = ua.match(/MSIE\s([\d.]+)/); |
| if (browser.webkit = !!webkit) |
| browser.version = webkit[1]; |
| if (android) |
| os.android = true, os.version = android[2]; |
| if (iphone && !ipod) |
| os.ios = os.iphone = true, os.version = iphone[2].replace(/_/g, '.'); |
| if (ipad) |
| os.ios = os.ipad = true, os.version = ipad[2].replace(/_/g, '.'); |
| if (ipod) |
| os.ios = os.ipod = true, os.version = ipod[3] ? ipod[3].replace(/_/g, '.') : null; |
| if (webos) |
| os.webos = true, os.version = webos[2]; |
| if (touchpad) |
| os.touchpad = true; |
| if (blackberry) |
| os.blackberry = true, os.version = blackberry[2]; |
| if (bb10) |
| os.bb10 = true, os.version = bb10[2]; |
| if (rimtabletos) |
| os.rimtabletos = true, os.version = rimtabletos[2]; |
| if (playbook) |
| browser.playbook = true; |
| if (kindle) |
| os.kindle = true, os.version = kindle[1]; |
| if (silk) |
| browser.silk = true, browser.version = silk[1]; |
| if (!silk && os.android && ua.match(/Kindle Fire/)) |
| browser.silk = true; |
| if (chrome) |
| browser.chrome = true, browser.version = chrome[1]; |
| if (firefox) |
| browser.firefox = true, browser.version = firefox[1]; |
| if (ie) |
| browser.ie = true, browser.version = ie[1]; |
| if (safari && (ua.match(/Safari/) || !!os.ios)) |
| browser.safari = true; |
| if (webview) |
| browser.webview = true; |
| if (ie) |
| browser.ie = true, browser.version = ie[1]; |
| os.tablet = !!(ipad || playbook || android && !ua.match(/Mobile/) || firefox && ua.match(/Tablet/) || ie && !ua.match(/Phone/) && ua.match(/Touch/)); |
| os.phone = !!(!os.tablet && !os.ipod && (android || iphone || webos || blackberry || bb10 || chrome && ua.match(/Android/) || chrome && ua.match(/CriOS\/([\d.]+)/) || firefox && ua.match(/Mobile/) || ie && ua.match(/Touch/))); |
| return { |
| browser: browser, |
| os: os, |
| canvasSupported: document.createElement('canvas').getContext ? true : false |
| }; |
| } |
| return detect(navigator.userAgent); |
| });define('zrender', ['zrender/zrender'], function (main) {return main;}); |
| define('zrender/zrender', [ |
| 'require', |
| './dep/excanvas', |
| './tool/util', |
| './tool/log', |
| './tool/guid', |
| './Handler', |
| './Painter', |
| './Storage', |
| './animation/Animation', |
| './tool/env' |
| ], function (require) { |
| require('./dep/excanvas'); |
| var util = require('./tool/util'); |
| var log = require('./tool/log'); |
| var guid = require('./tool/guid'); |
| var Handler = require('./Handler'); |
| var Painter = require('./Painter'); |
| var Storage = require('./Storage'); |
| var Animation = require('./animation/Animation'); |
| var _instances = {}; |
| var zrender = {}; |
| zrender.version = '2.0.6'; |
| zrender.init = function (dom) { |
| var zr = new ZRender(guid(), dom); |
| _instances[zr.id] = zr; |
| return zr; |
| }; |
| zrender.dispose = function (zr) { |
| if (zr) { |
| zr.dispose(); |
| } else { |
| for (var key in _instances) { |
| _instances[key].dispose(); |
| } |
| _instances = {}; |
| } |
| return zrender; |
| }; |
| zrender.getInstance = function (id) { |
| return _instances[id]; |
| }; |
| zrender.delInstance = function (id) { |
| delete _instances[id]; |
| return zrender; |
| }; |
| function getFrameCallback(zrInstance) { |
| return function () { |
| var animatingElements = zrInstance.animatingElements; |
| for (var i = 0, l = animatingElements.length; i < l; i++) { |
| zrInstance.storage.mod(animatingElements[i].id); |
| } |
| if (animatingElements.length || zrInstance._needsRefreshNextFrame) { |
| zrInstance.refresh(); |
| } |
| }; |
| } |
| var ZRender = function (id, dom) { |
| this.id = id; |
| this.env = require('./tool/env'); |
| this.storage = new Storage(); |
| this.painter = new Painter(dom, this.storage); |
| this.handler = new Handler(dom, this.storage, this.painter); |
| this.animatingElements = []; |
| this.animation = new Animation({ stage: { update: getFrameCallback(this) } }); |
| this.animation.start(); |
| var self = this; |
| this.painter.refreshNextFrame = function () { |
| self.refreshNextFrame(); |
| }; |
| this._needsRefreshNextFrame = false; |
| }; |
| ZRender.prototype.getId = function () { |
| return this.id; |
| }; |
| ZRender.prototype.addShape = function (shape) { |
| this.storage.addRoot(shape); |
| return this; |
| }; |
| ZRender.prototype.addGroup = function (group) { |
| this.storage.addRoot(group); |
| return this; |
| }; |
| ZRender.prototype.delShape = function (shapeId) { |
| this.storage.delRoot(shapeId); |
| return this; |
| }; |
| ZRender.prototype.delGroup = function (groupId) { |
| this.storage.delRoot(groupId); |
| return this; |
| }; |
| ZRender.prototype.modShape = function (shapeId, shape) { |
| this.storage.mod(shapeId, shape); |
| return this; |
| }; |
| ZRender.prototype.modGroup = function (groupId, group) { |
| this.storage.mod(groupId, group); |
| return this; |
| }; |
| ZRender.prototype.modLayer = function (zLevel, config) { |
| this.painter.modLayer(zLevel, config); |
| return this; |
| }; |
| ZRender.prototype.addHoverShape = function (shape) { |
| this.storage.addHover(shape); |
| return this; |
| }; |
| ZRender.prototype.render = function (callback) { |
| this.painter.render(callback); |
| this._needsRefreshNextFrame = false; |
| return this; |
| }; |
| ZRender.prototype.refresh = function (callback) { |
| this.painter.refresh(callback); |
| this._needsRefreshNextFrame = false; |
| return this; |
| }; |
| ZRender.prototype.refreshNextFrame = function () { |
| this._needsRefreshNextFrame = true; |
| return this; |
| }; |
| ZRender.prototype.refreshHover = function (callback) { |
| this.painter.refreshHover(callback); |
| return this; |
| }; |
| ZRender.prototype.refreshShapes = function (shapeList, callback) { |
| this.painter.refreshShapes(shapeList, callback); |
| return this; |
| }; |
| ZRender.prototype.resize = function () { |
| this.painter.resize(); |
| return this; |
| }; |
| ZRender.prototype.animate = function (el, path, loop) { |
| if (typeof el === 'string') { |
| el = this.storage.get(el); |
| } |
| if (el) { |
| var target; |
| if (path) { |
| var pathSplitted = path.split('.'); |
| var prop = el; |
| for (var i = 0, l = pathSplitted.length; i < l; i++) { |
| if (!prop) { |
| continue; |
| } |
| prop = prop[pathSplitted[i]]; |
| } |
| if (prop) { |
| target = prop; |
| } |
| } else { |
| target = el; |
| } |
| if (!target) { |
| log('Property "' + path + '" is not existed in element ' + el.id); |
| return; |
| } |
| var animatingElements = this.animatingElements; |
| if (typeof el.__aniCount === 'undefined') { |
| el.__aniCount = 0; |
| } |
| if (el.__aniCount === 0) { |
| animatingElements.push(el); |
| } |
| el.__aniCount++; |
| return this.animation.animate(target, { loop: loop }).done(function () { |
| el.__aniCount--; |
| if (el.__aniCount === 0) { |
| var idx = util.indexOf(animatingElements, el); |
| animatingElements.splice(idx, 1); |
| } |
| }); |
| } else { |
| log('Element not existed'); |
| } |
| }; |
| ZRender.prototype.clearAnimation = function () { |
| this.animation.clear(); |
| }; |
| ZRender.prototype.showLoading = function (loadingEffect) { |
| this.painter.showLoading(loadingEffect); |
| return this; |
| }; |
| ZRender.prototype.hideLoading = function () { |
| this.painter.hideLoading(); |
| return this; |
| }; |
| ZRender.prototype.getWidth = function () { |
| return this.painter.getWidth(); |
| }; |
| ZRender.prototype.getHeight = function () { |
| return this.painter.getHeight(); |
| }; |
| ZRender.prototype.toDataURL = function (type, backgroundColor, args) { |
| return this.painter.toDataURL(type, backgroundColor, args); |
| }; |
| ZRender.prototype.shapeToImage = function (e, width, height) { |
| var id = guid(); |
| return this.painter.shapeToImage(id, e, width, height); |
| }; |
| ZRender.prototype.on = function (eventName, eventHandler) { |
| this.handler.on(eventName, eventHandler); |
| return this; |
| }; |
| ZRender.prototype.un = function (eventName, eventHandler) { |
| this.handler.un(eventName, eventHandler); |
| return this; |
| }; |
| ZRender.prototype.trigger = function (eventName, event) { |
| this.handler.trigger(eventName, event); |
| return this; |
| }; |
| ZRender.prototype.clear = function () { |
| this.storage.delRoot(); |
| this.painter.clear(); |
| return this; |
| }; |
| ZRender.prototype.dispose = function () { |
| this.animation.stop(); |
| this.clear(); |
| this.storage.dispose(); |
| this.painter.dispose(); |
| this.handler.dispose(); |
| this.animation = this.animatingElements = this.storage = this.painter = this.handler = null; |
| zrender.delInstance(this.id); |
| }; |
| return zrender; |
| });define('zrender/config', [], function () { |
| var config = { |
| EVENT: { |
| RESIZE: 'resize', |
| CLICK: 'click', |
| DBLCLICK: 'dblclick', |
| MOUSEWHEEL: 'mousewheel', |
| MOUSEMOVE: 'mousemove', |
| MOUSEOVER: 'mouseover', |
| MOUSEOUT: 'mouseout', |
| MOUSEDOWN: 'mousedown', |
| MOUSEUP: 'mouseup', |
| GLOBALOUT: 'globalout', |
| DRAGSTART: 'dragstart', |
| DRAGEND: 'dragend', |
| DRAGENTER: 'dragenter', |
| DRAGOVER: 'dragover', |
| DRAGLEAVE: 'dragleave', |
| DROP: 'drop', |
| touchClickDelay: 300 |
| }, |
| catchBrushException: false, |
| debugMode: 0 |
| }; |
| return config; |
| });define('echarts/chart/island', [ |
| 'require', |
| '../component/base', |
| './base', |
| 'zrender/shape/Circle', |
| '../config', |
| '../util/ecData', |
| 'zrender/tool/util', |
| 'zrender/tool/event', |
| 'zrender/tool/color', |
| '../util/accMath', |
| '../chart' |
| ], function (require) { |
| var ComponentBase = require('../component/base'); |
| var ChartBase = require('./base'); |
| var CircleShape = require('zrender/shape/Circle'); |
| var ecConfig = require('../config'); |
| var ecData = require('../util/ecData'); |
| var zrUtil = require('zrender/tool/util'); |
| var zrEvent = require('zrender/tool/event'); |
| function Island(ecTheme, messageCenter, zr, option, myChart) { |
| ComponentBase.call(this, ecTheme, messageCenter, zr, {}, myChart); |
| ChartBase.call(this); |
| this._nameConnector; |
| this._valueConnector; |
| this._zrHeight = this.zr.getHeight(); |
| this._zrWidth = this.zr.getWidth(); |
| var self = this; |
| self.shapeHandler.onmousewheel = function (param) { |
| var shape = param.target; |
| var event = param.event; |
| var delta = zrEvent.getDelta(event); |
| delta = delta > 0 ? -1 : 1; |
| shape.style.r -= delta; |
| shape.style.r = shape.style.r < 5 ? 5 : shape.style.r; |
| var value = ecData.get(shape, 'value'); |
| var dvalue = value * self.option.island.calculateStep; |
| if (dvalue > 1) { |
| value = Math.round(value - dvalue * delta); |
| } else { |
| value = (value - dvalue * delta).toFixed(2) - 0; |
| } |
| var name = ecData.get(shape, 'name'); |
| shape.style.text = name + ':' + value; |
| ecData.set(shape, 'value', value); |
| ecData.set(shape, 'name', name); |
| self.zr.modShape(shape.id); |
| self.zr.refresh(); |
| zrEvent.stop(event); |
| }; |
| } |
| Island.prototype = { |
| type: ecConfig.CHART_TYPE_ISLAND, |
| _combine: function (tarShape, srcShape) { |
| var zrColor = require('zrender/tool/color'); |
| var accMath = require('../util/accMath'); |
| var value = accMath.accAdd(ecData.get(tarShape, 'value'), ecData.get(srcShape, 'value')); |
| var name = ecData.get(tarShape, 'name') + this._nameConnector + ecData.get(srcShape, 'name'); |
| tarShape.style.text = name + this._valueConnector + value; |
| ecData.set(tarShape, 'value', value); |
| ecData.set(tarShape, 'name', name); |
| tarShape.style.r = this.option.island.r; |
| tarShape.style.color = zrColor.mix(tarShape.style.color, srcShape.style.color); |
| }, |
| refresh: function (newOption) { |
| if (newOption) { |
| newOption.island = this.reformOption(newOption.island); |
| this.option = newOption; |
| this._nameConnector = this.option.nameConnector; |
| this._valueConnector = this.option.valueConnector; |
| } |
| }, |
| getOption: function () { |
| return this.option; |
| }, |
| resize: function () { |
| var newWidth = this.zr.getWidth(); |
| var newHieght = this.zr.getHeight(); |
| var xScale = newWidth / (this._zrWidth || newWidth); |
| var yScale = newHieght / (this._zrHeight || newHieght); |
| if (xScale === 1 && yScale === 1) { |
| return; |
| } |
| this._zrWidth = newWidth; |
| this._zrHeight = newHieght; |
| for (var i = 0, l = this.shapeList.length; i < l; i++) { |
| this.zr.modShape(this.shapeList[i].id, { |
| style: { |
| x: Math.round(this.shapeList[i].style.x * xScale), |
| y: Math.round(this.shapeList[i].style.y * yScale) |
| } |
| }); |
| } |
| }, |
| add: function (shape) { |
| var name = ecData.get(shape, 'name'); |
| var value = ecData.get(shape, 'value'); |
| var seriesName = ecData.get(shape, 'series') != null ? ecData.get(shape, 'series').name : ''; |
| var font = this.getFont(this.option.island.textStyle); |
| var islandShape = { |
| zlevel: this._zlevelBase, |
| style: { |
| x: shape.style.x, |
| y: shape.style.y, |
| r: this.option.island.r, |
| color: shape.style.color || shape.style.strokeColor, |
| text: name + this._valueConnector + value, |
| textFont: font |
| }, |
| draggable: true, |
| hoverable: true, |
| onmousewheel: this.shapeHandler.onmousewheel, |
| _type: 'island' |
| }; |
| if (islandShape.style.color === '#fff') { |
| islandShape.style.color = shape.style.strokeColor; |
| } |
| this.setCalculable(islandShape); |
| islandShape.dragEnableTime = 0; |
| ecData.pack(islandShape, { name: seriesName }, -1, value, -1, name); |
| islandShape = new CircleShape(islandShape); |
| this.shapeList.push(islandShape); |
| this.zr.addShape(islandShape); |
| }, |
| del: function (shape) { |
| this.zr.delShape(shape.id); |
| var newShapeList = []; |
| for (var i = 0, l = this.shapeList.length; i < l; i++) { |
| if (this.shapeList[i].id != shape.id) { |
| newShapeList.push(this.shapeList[i]); |
| } |
| } |
| this.shapeList = newShapeList; |
| }, |
| ondrop: function (param, status) { |
| if (!this.isDrop || !param.target) { |
| return; |
| } |
| var target = param.target; |
| var dragged = param.dragged; |
| this._combine(target, dragged); |
| this.zr.modShape(target.id); |
| status.dragIn = true; |
| this.isDrop = false; |
| return; |
| }, |
| ondragend: function (param, status) { |
| var target = param.target; |
| if (!this.isDragend) { |
| if (!status.dragIn) { |
| target.style.x = zrEvent.getX(param.event); |
| target.style.y = zrEvent.getY(param.event); |
| this.add(target); |
| status.needRefresh = true; |
| } |
| } else { |
| if (status.dragIn) { |
| this.del(target); |
| status.needRefresh = true; |
| } |
| } |
| this.isDragend = false; |
| return; |
| } |
| }; |
| zrUtil.inherits(Island, ChartBase); |
| zrUtil.inherits(Island, ComponentBase); |
| require('../chart').define('island', Island); |
| return Island; |
| });define('echarts/component/toolbox', [ |
| 'require', |
| './base', |
| 'zrender/shape/Line', |
| 'zrender/shape/Image', |
| 'zrender/shape/Rectangle', |
| '../util/shape/Icon', |
| '../config', |
| 'zrender/tool/util', |
| 'zrender/config', |
| 'zrender/tool/event', |
| './dataView', |
| '../component' |
| ], function (require) { |
| var Base = require('./base'); |
| var LineShape = require('zrender/shape/Line'); |
| var ImageShape = require('zrender/shape/Image'); |
| var RectangleShape = require('zrender/shape/Rectangle'); |
| var IconShape = require('../util/shape/Icon'); |
| var ecConfig = require('../config'); |
| var zrUtil = require('zrender/tool/util'); |
| var zrConfig = require('zrender/config'); |
| var zrEvent = require('zrender/tool/event'); |
| var _MAGICTYPE_STACK = 'stack'; |
| var _MAGICTYPE_TILED = 'tiled'; |
| function Toolbox(ecTheme, messageCenter, zr, option, myChart) { |
| Base.call(this, ecTheme, messageCenter, zr, option, myChart); |
| this.dom = myChart.dom; |
| this._magicType = {}; |
| this._magicMap = {}; |
| this._isSilence = false; |
| this._iconList; |
| this._iconShapeMap = {}; |
| this._featureTitle = {}; |
| this._featureIcon = {}; |
| this._featureColor = {}; |
| this._featureOption = {}; |
| this._enableColor = 'red'; |
| this._disableColor = '#ccc'; |
| this._markShapeList = []; |
| var self = this; |
| self._onMark = function (param) { |
| self.__onMark(param); |
| }; |
| self._onMarkUndo = function (param) { |
| self.__onMarkUndo(param); |
| }; |
| self._onMarkClear = function (param) { |
| self.__onMarkClear(param); |
| }; |
| self._onDataZoom = function (param) { |
| self.__onDataZoom(param); |
| }; |
| self._onDataZoomReset = function (param) { |
| self.__onDataZoomReset(param); |
| }; |
| self._onDataView = function (param) { |
| self.__onDataView(param); |
| }; |
| self._onRestore = function (param) { |
| self.__onRestore(param); |
| }; |
| self._onSaveAsImage = function (param) { |
| self.__onSaveAsImage(param); |
| }; |
| self._onMagicType = function (param) { |
| self.__onMagicType(param); |
| }; |
| self._onCustomHandler = function (param) { |
| self.__onCustomHandler(param); |
| }; |
| self._onmousemove = function (param) { |
| return self.__onmousemove(param); |
| }; |
| self._onmousedown = function (param) { |
| return self.__onmousedown(param); |
| }; |
| self._onmouseup = function (param) { |
| return self.__onmouseup(param); |
| }; |
| self._onclick = function (param) { |
| return self.__onclick(param); |
| }; |
| } |
| Toolbox.prototype = { |
| type: ecConfig.COMPONENT_TYPE_TOOLBOX, |
| _buildShape: function () { |
| this._iconList = []; |
| var toolboxOption = this.option.toolbox; |
| this._enableColor = toolboxOption.effectiveColor; |
| this._disableColor = toolboxOption.disableColor; |
| var feature = toolboxOption.feature; |
| var iconName = []; |
| for (var key in feature) { |
| if (feature[key].show) { |
| switch (key) { |
| case 'mark': |
| iconName.push({ |
| key: key, |
| name: 'mark' |
| }); |
| iconName.push({ |
| key: key, |
| name: 'markUndo' |
| }); |
| iconName.push({ |
| key: key, |
| name: 'markClear' |
| }); |
| break; |
| case 'magicType': |
| for (var i = 0, l = feature[key].type.length; i < l; i++) { |
| feature[key].title[feature[key].type[i] + 'Chart'] = feature[key].title[feature[key].type[i]]; |
| if (feature[key].option) { |
| feature[key].option[feature[key].type[i] + 'Chart'] = feature[key].option[feature[key].type[i]]; |
| } |
| iconName.push({ |
| key: key, |
| name: feature[key].type[i] + 'Chart' |
| }); |
| } |
| break; |
| case 'dataZoom': |
| iconName.push({ |
| key: key, |
| name: 'dataZoom' |
| }); |
| iconName.push({ |
| key: key, |
| name: 'dataZoomReset' |
| }); |
| break; |
| case 'saveAsImage': |
| if (this.canvasSupported) { |
| iconName.push({ |
| key: key, |
| name: 'saveAsImage' |
| }); |
| } |
| break; |
| default: |
| iconName.push({ |
| key: key, |
| name: key |
| }); |
| break; |
| } |
| } |
| } |
| if (iconName.length > 0) { |
| var name; |
| var key; |
| for (var i = 0, l = iconName.length; i < l; i++) { |
| name = iconName[i].name; |
| key = iconName[i].key; |
| this._iconList.push(name); |
| this._featureTitle[name] = feature[key].title[name] || feature[key].title; |
| if (feature[key].icon) { |
| this._featureIcon[name] = feature[key].icon[name] || feature[key].icon; |
| } |
| if (feature[key].color) { |
| this._featureColor[name] = feature[key].color[name] || feature[key].color; |
| } |
| if (feature[key].option) { |
| this._featureOption[name] = feature[key].option[name] || feature[key].option; |
| } |
| } |
| this._itemGroupLocation = this._getItemGroupLocation(); |
| this._buildBackground(); |
| this._buildItem(); |
| for (var i = 0, l = this.shapeList.length; i < l; i++) { |
| this.zr.addShape(this.shapeList[i]); |
| } |
| if (this._iconShapeMap['mark']) { |
| this._iconDisable(this._iconShapeMap['markUndo']); |
| this._iconDisable(this._iconShapeMap['markClear']); |
| } |
| if (this._iconShapeMap['dataZoomReset'] && this._zoomQueue.length === 0) { |
| this._iconDisable(this._iconShapeMap['dataZoomReset']); |
| } |
| } |
| }, |
| _buildItem: function () { |
| var toolboxOption = this.option.toolbox; |
| var iconLength = this._iconList.length; |
| var lastX = this._itemGroupLocation.x; |
| var lastY = this._itemGroupLocation.y; |
| var itemSize = toolboxOption.itemSize; |
| var itemGap = toolboxOption.itemGap; |
| var itemShape; |
| var color = toolboxOption.color instanceof Array ? toolboxOption.color : [toolboxOption.color]; |
| var textFont = this.getFont(toolboxOption.textStyle); |
| var textPosition; |
| var textAlign; |
| var textBaseline; |
| if (toolboxOption.orient === 'horizontal') { |
| textPosition = this._itemGroupLocation.y / this.zr.getHeight() < 0.5 ? 'bottom' : 'top'; |
| textAlign = this._itemGroupLocation.x / this.zr.getWidth() < 0.5 ? 'left' : 'right'; |
| textBaseline = this._itemGroupLocation.y / this.zr.getHeight() < 0.5 ? 'top' : 'bottom'; |
| } else { |
| textPosition = this._itemGroupLocation.x / this.zr.getWidth() < 0.5 ? 'right' : 'left'; |
| } |
| this._iconShapeMap = {}; |
| var self = this; |
| for (var i = 0; i < iconLength; i++) { |
| itemShape = { |
| type: 'icon', |
| zlevel: this._zlevelBase, |
| style: { |
| x: lastX, |
| y: lastY, |
| width: itemSize, |
| height: itemSize, |
| iconType: this._iconList[i], |
| lineWidth: 1, |
| strokeColor: this._featureColor[this._iconList[i]] || color[i % color.length], |
| brushType: 'stroke' |
| }, |
| highlightStyle: { |
| lineWidth: 1, |
| text: toolboxOption.showTitle ? this._featureTitle[this._iconList[i]] : undefined, |
| textFont: textFont, |
| textPosition: textPosition, |
| strokeColor: this._featureColor[this._iconList[i]] || color[i % color.length] |
| }, |
| hoverable: true, |
| clickable: true |
| }; |
| if (this._featureIcon[this._iconList[i]]) { |
| itemShape.style.image = this._featureIcon[this._iconList[i]].replace(new RegExp('^image:\\/\\/'), ''); |
| itemShape.style.opacity = 0.8; |
| itemShape.highlightStyle.opacity = 1; |
| itemShape.type = 'image'; |
| } |
| if (toolboxOption.orient === 'horizontal') { |
| if (i === 0 && textAlign === 'left') { |
| itemShape.highlightStyle.textPosition = 'specific'; |
| itemShape.highlightStyle.textAlign = textAlign; |
| itemShape.highlightStyle.textBaseline = textBaseline; |
| itemShape.highlightStyle.textX = lastX; |
| itemShape.highlightStyle.textY = textBaseline === 'top' ? lastY + itemSize + 10 : lastY - 10; |
| } |
| if (i === iconLength - 1 && textAlign === 'right') { |
| itemShape.highlightStyle.textPosition = 'specific'; |
| itemShape.highlightStyle.textAlign = textAlign; |
| itemShape.highlightStyle.textBaseline = textBaseline; |
| itemShape.highlightStyle.textX = lastX + itemSize; |
| itemShape.highlightStyle.textY = textBaseline === 'top' ? lastY + itemSize + 10 : lastY - 10; |
| } |
| } |
| switch (this._iconList[i]) { |
| case 'mark': |
| itemShape.onclick = self._onMark; |
| break; |
| case 'markUndo': |
| itemShape.onclick = self._onMarkUndo; |
| break; |
| case 'markClear': |
| itemShape.onclick = self._onMarkClear; |
| break; |
| case 'dataZoom': |
| itemShape.onclick = self._onDataZoom; |
| break; |
| case 'dataZoomReset': |
| itemShape.onclick = self._onDataZoomReset; |
| break; |
| case 'dataView': |
| if (!this._dataView) { |
| var DataView = require('./dataView'); |
| this._dataView = new DataView(this.ecTheme, this.messageCenter, this.zr, this.option, this.myChart); |
| } |
| itemShape.onclick = self._onDataView; |
| break; |
| case 'restore': |
| itemShape.onclick = self._onRestore; |
| break; |
| case 'saveAsImage': |
| itemShape.onclick = self._onSaveAsImage; |
| break; |
| default: |
| if (this._iconList[i].match('Chart')) { |
| itemShape._name = this._iconList[i].replace('Chart', ''); |
| itemShape.onclick = self._onMagicType; |
| } else { |
| itemShape.onclick = self._onCustomHandler; |
| } |
| break; |
| } |
| if (itemShape.type === 'icon') { |
| itemShape = new IconShape(itemShape); |
| } else if (itemShape.type === 'image') { |
| itemShape = new ImageShape(itemShape); |
| } |
| this.shapeList.push(itemShape); |
| this._iconShapeMap[this._iconList[i]] = itemShape; |
| if (toolboxOption.orient === 'horizontal') { |
| lastX += itemSize + itemGap; |
| } else { |
| lastY += itemSize + itemGap; |
| } |
| } |
| }, |
| _buildBackground: function () { |
| var toolboxOption = this.option.toolbox; |
| var padding = this.reformCssArray(this.option.toolbox.padding); |
| this.shapeList.push(new RectangleShape({ |
| zlevel: this._zlevelBase, |
| hoverable: false, |
| style: { |
| x: this._itemGroupLocation.x - padding[3], |
| y: this._itemGroupLocation.y - padding[0], |
| width: this._itemGroupLocation.width + padding[3] + padding[1], |
| height: this._itemGroupLocation.height + padding[0] + padding[2], |
| brushType: toolboxOption.borderWidth === 0 ? 'fill' : 'both', |
| color: toolboxOption.backgroundColor, |
| strokeColor: toolboxOption.borderColor, |
| lineWidth: toolboxOption.borderWidth |
| } |
| })); |
| }, |
| _getItemGroupLocation: function () { |
| var toolboxOption = this.option.toolbox; |
| var padding = this.reformCssArray(this.option.toolbox.padding); |
| var iconLength = this._iconList.length; |
| var itemGap = toolboxOption.itemGap; |
| var itemSize = toolboxOption.itemSize; |
| var totalWidth = 0; |
| var totalHeight = 0; |
| if (toolboxOption.orient === 'horizontal') { |
| totalWidth = (itemSize + itemGap) * iconLength - itemGap; |
| totalHeight = itemSize; |
| } else { |
| totalHeight = (itemSize + itemGap) * iconLength - itemGap; |
| totalWidth = itemSize; |
| } |
| var x; |
| var zrWidth = this.zr.getWidth(); |
| switch (toolboxOption.x) { |
| case 'center': |
| x = Math.floor((zrWidth - totalWidth) / 2); |
| break; |
| case 'left': |
| x = padding[3] + toolboxOption.borderWidth; |
| break; |
| case 'right': |
| x = zrWidth - totalWidth - padding[1] - toolboxOption.borderWidth; |
| break; |
| default: |
| x = toolboxOption.x - 0; |
| x = isNaN(x) ? 0 : x; |
| break; |
| } |
| var y; |
| var zrHeight = this.zr.getHeight(); |
| switch (toolboxOption.y) { |
| case 'top': |
| y = padding[0] + toolboxOption.borderWidth; |
| break; |
| case 'bottom': |
| y = zrHeight - totalHeight - padding[2] - toolboxOption.borderWidth; |
| break; |
| case 'center': |
| y = Math.floor((zrHeight - totalHeight) / 2); |
| break; |
| default: |
| y = toolboxOption.y - 0; |
| y = isNaN(y) ? 0 : y; |
| break; |
| } |
| return { |
| x: x, |
| y: y, |
| width: totalWidth, |
| height: totalHeight |
| }; |
| }, |
| __onmousemove: function (param) { |
| if (this._marking) { |
| this._markShape.style.xEnd = zrEvent.getX(param.event); |
| this._markShape.style.yEnd = zrEvent.getY(param.event); |
| this.zr.addHoverShape(this._markShape); |
| } |
| if (this._zooming) { |
| this._zoomShape.style.width = zrEvent.getX(param.event) - this._zoomShape.style.x; |
| this._zoomShape.style.height = zrEvent.getY(param.event) - this._zoomShape.style.y; |
| this.zr.addHoverShape(this._zoomShape); |
| this.dom.style.cursor = 'crosshair'; |
| } |
| if (this._zoomStart && (this.dom.style.cursor != 'pointer' && this.dom.style.cursor != 'move')) { |
| this.dom.style.cursor = 'crosshair'; |
| } |
| }, |
| __onmousedown: function (param) { |
| if (param.target) { |
| return; |
| } |
| this._zooming = true; |
| var x = zrEvent.getX(param.event); |
| var y = zrEvent.getY(param.event); |
| var zoomOption = this.option.dataZoom || {}; |
| this._zoomShape = new RectangleShape({ |
| zlevel: this._zlevelBase, |
| style: { |
| x: x, |
| y: y, |
| width: 1, |
| height: 1, |
| brushType: 'both' |
| }, |
| highlightStyle: { |
| lineWidth: 2, |
| color: zoomOption.fillerColor || ecConfig.dataZoom.fillerColor, |
| strokeColor: zoomOption.handleColor || ecConfig.dataZoom.handleColor, |
| brushType: 'both' |
| } |
| }); |
| this.zr.addHoverShape(this._zoomShape); |
| return true; |
| }, |
| __onmouseup: function () { |
| if (!this._zoomShape || Math.abs(this._zoomShape.style.width) < 10 || Math.abs(this._zoomShape.style.height) < 10) { |
| this._zooming = false; |
| return true; |
| } |
| if (this._zooming && this.component.dataZoom) { |
| this._zooming = false; |
| var zoom = this.component.dataZoom.rectZoom(this._zoomShape.style); |
| if (zoom) { |
| this._zoomQueue.push({ |
| start: zoom.start, |
| end: zoom.end, |
| start2: zoom.start2, |
| end2: zoom.end2 |
| }); |
| this._iconEnable(this._iconShapeMap['dataZoomReset']); |
| this.zr.refresh(); |
| } |
| } |
| return true; |
| }, |
| __onclick: function (param) { |
| if (param.target) { |
| return; |
| } |
| if (this._marking) { |
| this._marking = false; |
| this._markShapeList.push(this._markShape); |
| this._iconEnable(this._iconShapeMap['markUndo']); |
| this._iconEnable(this._iconShapeMap['markClear']); |
| this.zr.addShape(this._markShape); |
| this.zr.refresh(); |
| } else if (this._markStart) { |
| this._marking = true; |
| var x = zrEvent.getX(param.event); |
| var y = zrEvent.getY(param.event); |
| this._markShape = new LineShape({ |
| zlevel: this._zlevelBase, |
| style: { |
| xStart: x, |
| yStart: y, |
| xEnd: x, |
| yEnd: y, |
| lineWidth: this.query(this.option, 'toolbox.feature.mark.lineStyle.width'), |
| strokeColor: this.query(this.option, 'toolbox.feature.mark.lineStyle.color'), |
| lineType: this.query(this.option, 'toolbox.feature.mark.lineStyle.type') |
| } |
| }); |
| this.zr.addHoverShape(this._markShape); |
| } |
| }, |
| __onMark: function (param) { |
| var target = param.target; |
| if (this._marking || this._markStart) { |
| this._resetMark(); |
| this.zr.refresh(); |
| } else { |
| this._resetZoom(); |
| this.zr.modShape(target.id, { style: { strokeColor: this._enableColor } }); |
| this.zr.refresh(); |
| this._markStart = true; |
| var self = this; |
| setTimeout(function () { |
| self.zr && self.zr.on(zrConfig.EVENT.CLICK, self._onclick) && self.zr.on(zrConfig.EVENT.MOUSEMOVE, self._onmousemove); |
| }, 10); |
| } |
| return true; |
| }, |
| __onMarkUndo: function () { |
| if (this._marking) { |
| this._marking = false; |
| } else { |
| var len = this._markShapeList.length; |
| if (len >= 1) { |
| var target = this._markShapeList[len - 1]; |
| this.zr.delShape(target.id); |
| this.zr.refresh(); |
| this._markShapeList.pop(); |
| if (len === 1) { |
| this._iconDisable(this._iconShapeMap['markUndo']); |
| this._iconDisable(this._iconShapeMap['markClear']); |
| } |
| } |
| } |
| return true; |
| }, |
| __onMarkClear: function () { |
| if (this._marking) { |
| this._marking = false; |
| } |
| var len = this._markShapeList.length; |
| if (len > 0) { |
| while (len--) { |
| this.zr.delShape(this._markShapeList.pop().id); |
| } |
| this._iconDisable(this._iconShapeMap['markUndo']); |
| this._iconDisable(this._iconShapeMap['markClear']); |
| this.zr.refresh(); |
| } |
| return true; |
| }, |
| __onDataZoom: function (param) { |
| var target = param.target; |
| if (this._zooming || this._zoomStart) { |
| this._resetZoom(); |
| this.zr.refresh(); |
| this.dom.style.cursor = 'default'; |
| } else { |
| this._resetMark(); |
| this.zr.modShape(target.id, { style: { strokeColor: this._enableColor } }); |
| this.zr.refresh(); |
| this._zoomStart = true; |
| var self = this; |
| setTimeout(function () { |
| self.zr && self.zr.on(zrConfig.EVENT.MOUSEDOWN, self._onmousedown) && self.zr.on(zrConfig.EVENT.MOUSEUP, self._onmouseup) && self.zr.on(zrConfig.EVENT.MOUSEMOVE, self._onmousemove); |
| }, 10); |
| this.dom.style.cursor = 'crosshair'; |
| } |
| return true; |
| }, |
| __onDataZoomReset: function () { |
| if (this._zooming) { |
| this._zooming = false; |
| } |
| this._zoomQueue.pop(); |
| if (this._zoomQueue.length > 0) { |
| this.component.dataZoom.absoluteZoom(this._zoomQueue[this._zoomQueue.length - 1]); |
| } else { |
| this.component.dataZoom.rectZoom(); |
| this._iconDisable(this._iconShapeMap['dataZoomReset']); |
| this.zr.refresh(); |
| } |
| return true; |
| }, |
| _resetMark: function () { |
| this._marking = false; |
| if (this._markStart) { |
| this._markStart = false; |
| if (this._iconShapeMap['mark']) { |
| this.zr.modShape(this._iconShapeMap['mark'].id, { style: { strokeColor: this._iconShapeMap['mark'].highlightStyle.strokeColor } }); |
| } |
| this.zr.un(zrConfig.EVENT.CLICK, this._onclick); |
| this.zr.un(zrConfig.EVENT.MOUSEMOVE, this._onmousemove); |
| } |
| }, |
| _resetZoom: function () { |
| this._zooming = false; |
| if (this._zoomStart) { |
| this._zoomStart = false; |
| if (this._iconShapeMap['dataZoom']) { |
| this.zr.modShape(this._iconShapeMap['dataZoom'].id, { style: { strokeColor: this._iconShapeMap['dataZoom'].highlightStyle.strokeColor } }); |
| } |
| this.zr.un(zrConfig.EVENT.MOUSEDOWN, this._onmousedown); |
| this.zr.un(zrConfig.EVENT.MOUSEUP, this._onmouseup); |
| this.zr.un(zrConfig.EVENT.MOUSEMOVE, this._onmousemove); |
| } |
| }, |
| _iconDisable: function (target) { |
| if (target.type != 'image') { |
| this.zr.modShape(target.id, { |
| hoverable: false, |
| clickable: false, |
| style: { strokeColor: this._disableColor } |
| }); |
| } else { |
| this.zr.modShape(target.id, { |
| hoverable: false, |
| clickable: false, |
| style: { opacity: 0.3 } |
| }); |
| } |
| }, |
| _iconEnable: function (target) { |
| if (target.type != 'image') { |
| this.zr.modShape(target.id, { |
| hoverable: true, |
| clickable: true, |
| style: { strokeColor: target.highlightStyle.strokeColor } |
| }); |
| } else { |
| this.zr.modShape(target.id, { |
| hoverable: true, |
| clickable: true, |
| style: { opacity: 0.8 } |
| }); |
| } |
| }, |
| __onDataView: function () { |
| this._dataView.show(this.option); |
| return true; |
| }, |
| __onRestore: function () { |
| this._resetMark(); |
| this._resetZoom(); |
| this.messageCenter.dispatch(ecConfig.EVENT.RESTORE, null, null, this.myChart); |
| return true; |
| }, |
| __onSaveAsImage: function () { |
| var saveOption = this.option.toolbox.feature.saveAsImage; |
| var imgType = saveOption.type || 'png'; |
| if (imgType != 'png' && imgType != 'jpeg') { |
| imgType = 'png'; |
| } |
| var image; |
| if (!this.myChart.isConnected()) { |
| image = this.zr.toDataURL('image/' + imgType, this.option.backgroundColor && this.option.backgroundColor.replace(' ', '') === 'rgba(0,0,0,0)' ? '#fff' : this.option.backgroundColor); |
| } else { |
| image = this.myChart.getConnectedDataURL(imgType); |
| } |
| var downloadDiv = document.createElement('div'); |
| downloadDiv.id = '__echarts_download_wrap__'; |
| downloadDiv.style.cssText = 'position:fixed;' + 'z-index:99999;' + 'display:block;' + 'top:0;left:0;' + 'background-color:rgba(33,33,33,0.5);' + 'text-align:center;' + 'width:100%;' + 'height:100%;' + 'line-height:' + document.documentElement.clientHeight + 'px;'; |
| var downloadLink = document.createElement('a'); |
| downloadLink.href = image; |
| downloadLink.setAttribute('download', (saveOption.name ? saveOption.name : this.option.title && (this.option.title.text || this.option.title.subtext) ? this.option.title.text || this.option.title.subtext : 'ECharts') + '.' + imgType); |
| downloadLink.innerHTML = '<img style="vertical-align:middle" src="' + image + '" title="' + (!!(window.attachEvent && navigator.userAgent.indexOf('Opera') === -1) ? '右键->图片另存为' : saveOption.lang ? saveOption.lang[0] : '点击保存') + '"/>'; |
| downloadDiv.appendChild(downloadLink); |
| document.body.appendChild(downloadDiv); |
| downloadLink = null; |
| downloadDiv = null; |
| setTimeout(function () { |
| var _d = document.getElementById('__echarts_download_wrap__'); |
| if (_d) { |
| _d.onclick = function () { |
| var d = document.getElementById('__echarts_download_wrap__'); |
| d.onclick = null; |
| d.innerHTML = ''; |
| document.body.removeChild(d); |
| d = null; |
| }; |
| _d = null; |
| } |
| }, 500); |
| return; |
| }, |
| __onMagicType: function (param) { |
| this._resetMark(); |
| var itemName = param.target._name; |
| if (!this._magicType[itemName]) { |
| this._magicType[itemName] = true; |
| if (itemName === ecConfig.CHART_TYPE_LINE) { |
| this._magicType[ecConfig.CHART_TYPE_BAR] = false; |
| } else if (itemName === ecConfig.CHART_TYPE_BAR) { |
| this._magicType[ecConfig.CHART_TYPE_LINE] = false; |
| } |
| if (itemName === ecConfig.CHART_TYPE_PIE) { |
| this._magicType[ecConfig.CHART_TYPE_FUNNEL] = false; |
| } else if (itemName === ecConfig.CHART_TYPE_FUNNEL) { |
| this._magicType[ecConfig.CHART_TYPE_PIE] = false; |
| } |
| if (itemName === ecConfig.CHART_TYPE_FORCE) { |
| this._magicType[ecConfig.CHART_TYPE_CHORD] = false; |
| } else if (itemName === ecConfig.CHART_TYPE_CHORD) { |
| this._magicType[ecConfig.CHART_TYPE_FORCE] = false; |
| } |
| if (itemName === _MAGICTYPE_STACK) { |
| this._magicType[_MAGICTYPE_TILED] = false; |
| } else if (itemName === _MAGICTYPE_TILED) { |
| this._magicType[_MAGICTYPE_STACK] = false; |
| } |
| this.messageCenter.dispatch(ecConfig.EVENT.MAGIC_TYPE_CHANGED, param.event, { magicType: this._magicType }, this.myChart); |
| } |
| return true; |
| }, |
| setMagicType: function (magicType) { |
| this._resetMark(); |
| this._magicType = magicType; |
| !this._isSilence && this.messageCenter.dispatch(ecConfig.EVENT.MAGIC_TYPE_CHANGED, null, { magicType: this._magicType }, this.myChart); |
| }, |
| __onCustomHandler: function (param) { |
| var target = param.target.style.iconType; |
| var featureHandler = this.option.toolbox.feature[target].onclick; |
| if (typeof featureHandler === 'function') { |
| featureHandler.call(this, this.option); |
| } |
| }, |
| reset: function (newOption, isRestore) { |
| isRestore && this.clear(); |
| if (this.query(newOption, 'toolbox.show') && this.query(newOption, 'toolbox.feature.magicType.show')) { |
| var magicType = newOption.toolbox.feature.magicType.type; |
| var len = magicType.length; |
| this._magicMap = {}; |
| while (len--) { |
| this._magicMap[magicType[len]] = true; |
| } |
| len = newOption.series.length; |
| var oriType; |
| var axis; |
| while (len--) { |
| oriType = newOption.series[len].type; |
| if (this._magicMap[oriType]) { |
| axis = newOption.xAxis instanceof Array ? newOption.xAxis[newOption.series[len].xAxisIndex || 0] : newOption.xAxis; |
| if (axis && (axis.type || 'category') === 'category') { |
| axis.__boundaryGap = axis.boundaryGap != null ? axis.boundaryGap : true; |
| } |
| axis = newOption.yAxis instanceof Array ? newOption.yAxis[newOption.series[len].yAxisIndex || 0] : newOption.yAxis; |
| if (axis && axis.type === 'category') { |
| axis.__boundaryGap = axis.boundaryGap != null ? axis.boundaryGap : true; |
| } |
| newOption.series[len].__type = oriType; |
| newOption.series[len].__itemStyle = zrUtil.clone(newOption.series[len].itemStyle || {}); |
| } |
| if (this._magicMap[_MAGICTYPE_STACK] || this._magicMap[_MAGICTYPE_TILED]) { |
| newOption.series[len].__stack = newOption.series[len].stack; |
| } |
| } |
| } |
| this._magicType = isRestore ? {} : this._magicType || {}; |
| for (var itemName in this._magicType) { |
| if (this._magicType[itemName]) { |
| this.option = newOption; |
| this.getMagicOption(); |
| break; |
| } |
| } |
| var zoomOption = newOption.dataZoom; |
| if (zoomOption && zoomOption.show) { |
| var start = zoomOption.start != null && zoomOption.start >= 0 && zoomOption.start <= 100 ? zoomOption.start : 0; |
| var end = zoomOption.end != null && zoomOption.end >= 0 && zoomOption.end <= 100 ? zoomOption.end : 100; |
| if (start > end) { |
| start = start + end; |
| end = start - end; |
| start = start - end; |
| } |
| this._zoomQueue = [{ |
| start: start, |
| end: end, |
| start2: 0, |
| end2: 100 |
| }]; |
| } else { |
| this._zoomQueue = []; |
| } |
| }, |
| getMagicOption: function () { |
| var axis; |
| var chartType; |
| if (this._magicType[ecConfig.CHART_TYPE_LINE] || this._magicType[ecConfig.CHART_TYPE_BAR]) { |
| var boundaryGap = this._magicType[ecConfig.CHART_TYPE_LINE] ? false : true; |
| for (var i = 0, l = this.option.series.length; i < l; i++) { |
| chartType = this.option.series[i].type; |
| if (chartType == ecConfig.CHART_TYPE_LINE || chartType == ecConfig.CHART_TYPE_BAR) { |
| axis = this.option.xAxis instanceof Array ? this.option.xAxis[this.option.series[i].xAxisIndex || 0] : this.option.xAxis; |
| if (axis && (axis.type || 'category') === 'category') { |
| axis.boundaryGap = boundaryGap ? true : axis.__boundaryGap; |
| } |
| axis = this.option.yAxis instanceof Array ? this.option.yAxis[this.option.series[i].yAxisIndex || 0] : this.option.yAxis; |
| if (axis && axis.type === 'category') { |
| axis.boundaryGap = boundaryGap ? true : axis.__boundaryGap; |
| } |
| } |
| } |
| this._defaultMagic(ecConfig.CHART_TYPE_LINE, ecConfig.CHART_TYPE_BAR); |
| } |
| this._defaultMagic(ecConfig.CHART_TYPE_CHORD, ecConfig.CHART_TYPE_FORCE); |
| this._defaultMagic(ecConfig.CHART_TYPE_PIE, ecConfig.CHART_TYPE_FUNNEL); |
| if (this._magicType[_MAGICTYPE_STACK] || this._magicType[_MAGICTYPE_TILED]) { |
| for (var i = 0, l = this.option.series.length; i < l; i++) { |
| if (this._magicType[_MAGICTYPE_STACK]) { |
| this.option.series[i].stack = '_ECHARTS_STACK_KENER_2014_'; |
| chartType = _MAGICTYPE_STACK; |
| } else if (this._magicType[_MAGICTYPE_TILED]) { |
| this.option.series[i].stack = null; |
| chartType = _MAGICTYPE_TILED; |
| } |
| if (this._featureOption[chartType + 'Chart']) { |
| zrUtil.merge(this.option.series[i], this._featureOption[chartType + 'Chart'] || {}, true); |
| } |
| } |
| } |
| return this.option; |
| }, |
| _defaultMagic: function (cType1, cType2) { |
| if (this._magicType[cType1] || this._magicType[cType2]) { |
| for (var i = 0, l = this.option.series.length; i < l; i++) { |
| var chartType = this.option.series[i].type; |
| if (chartType == cType1 || chartType == cType2) { |
| this.option.series[i].type = this._magicType[cType1] ? cType1 : cType2; |
| this.option.series[i].itemStyle = zrUtil.clone(this.option.series[i].__itemStyle); |
| chartType = this.option.series[i].type; |
| if (this._featureOption[chartType + 'Chart']) { |
| zrUtil.merge(this.option.series[i], this._featureOption[chartType + 'Chart'] || {}, true); |
| } |
| } |
| } |
| } |
| }, |
| silence: function (s) { |
| this._isSilence = s; |
| }, |
| resize: function () { |
| this._resetMark(); |
| this.clear(); |
| if (this.option && this.option.toolbox && this.option.toolbox.show) { |
| this._buildShape(); |
| } |
| if (this._dataView) { |
| this._dataView.resize(); |
| } |
| }, |
| hideDataView: function () { |
| if (this._dataView) { |
| this._dataView.hide(); |
| } |
| }, |
| clear: function (notMark) { |
| if (this.zr) { |
| this.zr.delShape(this.shapeList); |
| this.shapeList = []; |
| if (!notMark) { |
| this.zr.delShape(this._markShapeList); |
| this._markShapeList = []; |
| } |
| } |
| }, |
| onbeforDispose: function () { |
| if (this._dataView) { |
| this._dataView.dispose(); |
| this._dataView = null; |
| } |
| this._markShapeList = null; |
| }, |
| refresh: function (newOption) { |
| if (newOption) { |
| this._resetMark(); |
| this._resetZoom(); |
| newOption.toolbox = this.reformOption(newOption.toolbox); |
| this.option = newOption; |
| this.clear(true); |
| if (newOption.toolbox.show) { |
| this._buildShape(); |
| } |
| this.hideDataView(); |
| } |
| } |
| }; |
| zrUtil.inherits(Toolbox, Base); |
| require('../component').define('toolbox', Toolbox); |
| return Toolbox; |
| });define('echarts/component', [], function () { |
| var self = {}; |
| var _componentLibrary = {}; |
| self.define = function (name, clazz) { |
| _componentLibrary[name] = clazz; |
| return self; |
| }; |
| self.get = function (name) { |
| return _componentLibrary[name]; |
| }; |
| return self; |
| });define('echarts/component/title', [ |
| 'require', |
| './base', |
| 'zrender/shape/Text', |
| 'zrender/shape/Rectangle', |
| '../config', |
| 'zrender/tool/util', |
| 'zrender/tool/area', |
| 'zrender/tool/color', |
| '../component' |
| ], function (require) { |
| var Base = require('./base'); |
| var TextShape = require('zrender/shape/Text'); |
| var RectangleShape = require('zrender/shape/Rectangle'); |
| var ecConfig = require('../config'); |
| var zrUtil = require('zrender/tool/util'); |
| var zrArea = require('zrender/tool/area'); |
| var zrColor = require('zrender/tool/color'); |
| function Title(ecTheme, messageCenter, zr, option, myChart) { |
| Base.call(this, ecTheme, messageCenter, zr, option, myChart); |
| this.refresh(option); |
| } |
| Title.prototype = { |
| type: ecConfig.COMPONENT_TYPE_TITLE, |
| _buildShape: function () { |
| this._itemGroupLocation = this._getItemGroupLocation(); |
| this._buildBackground(); |
| this._buildItem(); |
| for (var i = 0, l = this.shapeList.length; i < l; i++) { |
| this.zr.addShape(this.shapeList[i]); |
| } |
| }, |
| _buildItem: function () { |
| var text = this.titleOption.text; |
| var link = this.titleOption.link; |
| var target = this.titleOption.target; |
| var subtext = this.titleOption.subtext; |
| var sublink = this.titleOption.sublink; |
| var subtarget = this.titleOption.subtarget; |
| var font = this.getFont(this.titleOption.textStyle); |
| var subfont = this.getFont(this.titleOption.subtextStyle); |
| var x = this._itemGroupLocation.x; |
| var y = this._itemGroupLocation.y; |
| var width = this._itemGroupLocation.width; |
| var height = this._itemGroupLocation.height; |
| var textShape = { |
| zlevel: this._zlevelBase, |
| style: { |
| y: y, |
| color: this.titleOption.textStyle.color, |
| text: text, |
| textFont: font, |
| textBaseline: 'top' |
| }, |
| highlightStyle: { |
| color: zrColor.lift(this.titleOption.textStyle.color, 1), |
| brushType: 'fill' |
| }, |
| hoverable: false |
| }; |
| if (link) { |
| textShape.hoverable = true; |
| textShape.clickable = true; |
| textShape.onclick = function () { |
| if (!target || target != 'self') { |
| window.open(link); |
| } else { |
| window.location = link; |
| } |
| }; |
| } |
| var subtextShape = { |
| zlevel: this._zlevelBase, |
| style: { |
| y: y + height, |
| color: this.titleOption.subtextStyle.color, |
| text: subtext, |
| textFont: subfont, |
| textBaseline: 'bottom' |
| }, |
| highlightStyle: { |
| color: zrColor.lift(this.titleOption.subtextStyle.color, 1), |
| brushType: 'fill' |
| }, |
| hoverable: false |
| }; |
| if (sublink) { |
| subtextShape.hoverable = true; |
| subtextShape.clickable = true; |
| subtextShape.onclick = function () { |
| if (!subtarget || subtarget != 'self') { |
| window.open(sublink); |
| } else { |
| window.location = sublink; |
| } |
| }; |
| } |
| switch (this.titleOption.x) { |
| case 'center': |
| textShape.style.x = subtextShape.style.x = x + width / 2; |
| textShape.style.textAlign = subtextShape.style.textAlign = 'center'; |
| break; |
| case 'left': |
| textShape.style.x = subtextShape.style.x = x; |
| textShape.style.textAlign = subtextShape.style.textAlign = 'left'; |
| break; |
| case 'right': |
| textShape.style.x = subtextShape.style.x = x + width; |
| textShape.style.textAlign = subtextShape.style.textAlign = 'right'; |
| break; |
| default: |
| x = this.titleOption.x - 0; |
| x = isNaN(x) ? 0 : x; |
| textShape.style.x = subtextShape.style.x = x; |
| break; |
| } |
| if (this.titleOption.textAlign) { |
| textShape.style.textAlign = subtextShape.style.textAlign = this.titleOption.textAlign; |
| } |
| this.shapeList.push(new TextShape(textShape)); |
| subtext !== '' && this.shapeList.push(new TextShape(subtextShape)); |
| }, |
| _buildBackground: function () { |
| var padding = this.reformCssArray(this.titleOption.padding); |
| this.shapeList.push(new RectangleShape({ |
| zlevel: this._zlevelBase, |
| hoverable: false, |
| style: { |
| x: this._itemGroupLocation.x - padding[3], |
| y: this._itemGroupLocation.y - padding[0], |
| width: this._itemGroupLocation.width + padding[3] + padding[1], |
| height: this._itemGroupLocation.height + padding[0] + padding[2], |
| brushType: this.titleOption.borderWidth === 0 ? 'fill' : 'both', |
| color: this.titleOption.backgroundColor, |
| strokeColor: this.titleOption.borderColor, |
| lineWidth: this.titleOption.borderWidth |
| } |
| })); |
| }, |
| _getItemGroupLocation: function () { |
| var padding = this.reformCssArray(this.titleOption.padding); |
| var text = this.titleOption.text; |
| var subtext = this.titleOption.subtext; |
| var font = this.getFont(this.titleOption.textStyle); |
| var subfont = this.getFont(this.titleOption.subtextStyle); |
| var totalWidth = Math.max(zrArea.getTextWidth(text, font), zrArea.getTextWidth(subtext, subfont)); |
| var totalHeight = zrArea.getTextHeight(text, font) + (subtext === '' ? 0 : this.titleOption.itemGap + zrArea.getTextHeight(subtext, subfont)); |
| var x; |
| var zrWidth = this.zr.getWidth(); |
| switch (this.titleOption.x) { |
| case 'center': |
| x = Math.floor((zrWidth - totalWidth) / 2); |
| break; |
| case 'left': |
| x = padding[3] + this.titleOption.borderWidth; |
| break; |
| case 'right': |
| x = zrWidth - totalWidth - padding[1] - this.titleOption.borderWidth; |
| break; |
| default: |
| x = this.titleOption.x - 0; |
| x = isNaN(x) ? 0 : x; |
| break; |
| } |
| var y; |
| var zrHeight = this.zr.getHeight(); |
| switch (this.titleOption.y) { |
| case 'top': |
| y = padding[0] + this.titleOption.borderWidth; |
| break; |
| case 'bottom': |
| y = zrHeight - totalHeight - padding[2] - this.titleOption.borderWidth; |
| break; |
| case 'center': |
| y = Math.floor((zrHeight - totalHeight) / 2); |
| break; |
| default: |
| y = this.titleOption.y - 0; |
| y = isNaN(y) ? 0 : y; |
| break; |
| } |
| return { |
| x: x, |
| y: y, |
| width: totalWidth, |
| height: totalHeight |
| }; |
| }, |
| refresh: function (newOption) { |
| if (newOption) { |
| this.option = newOption; |
| this.option.title = this.reformOption(this.option.title); |
| this.titleOption = this.option.title; |
| this.titleOption.textStyle = zrUtil.merge(this.titleOption.textStyle, this.ecTheme.textStyle); |
| this.titleOption.subtextStyle = zrUtil.merge(this.titleOption.subtextStyle, this.ecTheme.textStyle); |
| } |
| this.clear(); |
| this._buildShape(); |
| } |
| }; |
| zrUtil.inherits(Title, Base); |
| require('../component').define('title', Title); |
| return Title; |
| });define('echarts/component/tooltip', [ |
| 'require', |
| './base', |
| '../util/shape/Cross', |
| 'zrender/shape/Line', |
| 'zrender/shape/Rectangle', |
| '../config', |
| '../util/ecData', |
| 'zrender/config', |
| 'zrender/tool/event', |
| 'zrender/tool/area', |
| 'zrender/tool/color', |
| 'zrender/tool/util', |
| 'zrender/shape/Base', |
| '../component' |
| ], function (require) { |
| var Base = require('./base'); |
| var CrossShape = require('../util/shape/Cross'); |
| var LineShape = require('zrender/shape/Line'); |
| var RectangleShape = require('zrender/shape/Rectangle'); |
| var rectangleInstance = new RectangleShape({}); |
| var ecConfig = require('../config'); |
| var ecData = require('../util/ecData'); |
| var zrConfig = require('zrender/config'); |
| var zrEvent = require('zrender/tool/event'); |
| var zrArea = require('zrender/tool/area'); |
| var zrColor = require('zrender/tool/color'); |
| var zrUtil = require('zrender/tool/util'); |
| var zrShapeBase = require('zrender/shape/Base'); |
| function Tooltip(ecTheme, messageCenter, zr, option, myChart) { |
| Base.call(this, ecTheme, messageCenter, zr, option, myChart); |
| this.dom = myChart.dom; |
| var self = this; |
| self._onmousemove = function (param) { |
| return self.__onmousemove(param); |
| }; |
| self._onglobalout = function (param) { |
| return self.__onglobalout(param); |
| }; |
| this.zr.on(zrConfig.EVENT.MOUSEMOVE, self._onmousemove); |
| this.zr.on(zrConfig.EVENT.GLOBALOUT, self._onglobalout); |
| self._hide = function (param) { |
| return self.__hide(param); |
| }; |
| self._tryShow = function (param) { |
| return self.__tryShow(param); |
| }; |
| self._refixed = function (param) { |
| return self.__refixed(param); |
| }; |
| self._setContent = function (ticket, res) { |
| return self.__setContent(ticket, res); |
| }; |
| this._tDom = this._tDom || document.createElement('div'); |
| this._tDom.onselectstart = function () { |
| return false; |
| }; |
| this._tDom.onmouseover = function () { |
| self._mousein = true; |
| }; |
| this._tDom.onmouseout = function () { |
| self._mousein = false; |
| }; |
| this._tDom.style.position = 'absolute'; |
| this.hasAppend = false; |
| this._axisLineShape && this.zr.delShape(this._axisLineShape.id); |
| this._axisLineShape = new LineShape({ |
| zlevel: this._zlevelBase, |
| invisible: true, |
| hoverable: false |
| }); |
| this.shapeList.push(this._axisLineShape); |
| this.zr.addShape(this._axisLineShape); |
| this._axisShadowShape && this.zr.delShape(this._axisShadowShape.id); |
| this._axisShadowShape = new LineShape({ |
| zlevel: 1, |
| invisible: true, |
| hoverable: false |
| }); |
| this.shapeList.push(this._axisShadowShape); |
| this.zr.addShape(this._axisShadowShape); |
| this._axisCrossShape && this.zr.delShape(this._axisCrossShape.id); |
| this._axisCrossShape = new CrossShape({ |
| zlevel: this._zlevelBase, |
| invisible: true, |
| hoverable: false |
| }); |
| this.shapeList.push(this._axisCrossShape); |
| this.zr.addShape(this._axisCrossShape); |
| this.showing = false; |
| this.refresh(option); |
| } |
| Tooltip.prototype = { |
| type: ecConfig.COMPONENT_TYPE_TOOLTIP, |
| _gCssText: 'position:absolute;display:block;border-style:solid;white-space:nowrap;', |
| _style: function (opt) { |
| if (!opt) { |
| return ''; |
| } |
| var cssText = []; |
| if (opt.transitionDuration) { |
| var transitionText = 'left ' + opt.transitionDuration + 's,' + 'top ' + opt.transitionDuration + 's'; |
| cssText.push('transition:' + transitionText); |
| cssText.push('-moz-transition:' + transitionText); |
| cssText.push('-webkit-transition:' + transitionText); |
| cssText.push('-o-transition:' + transitionText); |
| } |
| if (opt.backgroundColor) { |
| cssText.push('background-Color:' + zrColor.toHex(opt.backgroundColor)); |
| cssText.push('filter:alpha(opacity=70)'); |
| cssText.push('background-Color:' + opt.backgroundColor); |
| } |
| if (opt.borderWidth != null) { |
| cssText.push('border-width:' + opt.borderWidth + 'px'); |
| } |
| if (opt.borderColor != null) { |
| cssText.push('border-color:' + opt.borderColor); |
| } |
| if (opt.borderRadius != null) { |
| cssText.push('border-radius:' + opt.borderRadius + 'px'); |
| cssText.push('-moz-border-radius:' + opt.borderRadius + 'px'); |
| cssText.push('-webkit-border-radius:' + opt.borderRadius + 'px'); |
| cssText.push('-o-border-radius:' + opt.borderRadius + 'px'); |
| } |
| var textStyle = opt.textStyle; |
| if (textStyle) { |
| textStyle.color && cssText.push('color:' + textStyle.color); |
| textStyle.decoration && cssText.push('text-decoration:' + textStyle.decoration); |
| textStyle.align && cssText.push('text-align:' + textStyle.align); |
| textStyle.fontFamily && cssText.push('font-family:' + textStyle.fontFamily); |
| textStyle.fontSize && cssText.push('font-size:' + textStyle.fontSize + 'px'); |
| textStyle.fontSize && cssText.push('line-height:' + Math.round(textStyle.fontSize * 3 / 2) + 'px'); |
| textStyle.fontStyle && cssText.push('font-style:' + textStyle.fontStyle); |
| textStyle.fontWeight && cssText.push('font-weight:' + textStyle.fontWeight); |
| } |
| var padding = opt.padding; |
| if (padding != null) { |
| padding = this.reformCssArray(padding); |
| cssText.push('padding:' + padding[0] + 'px ' + padding[1] + 'px ' + padding[2] + 'px ' + padding[3] + 'px'); |
| } |
| cssText = cssText.join(';') + ';'; |
| return cssText; |
| }, |
| __hide: function () { |
| this._lastDataIndex = -1; |
| this._lastSeriesIndex = -1; |
| this._lastItemTriggerId = -1; |
| if (this._tDom) { |
| this._tDom.style.display = 'none'; |
| } |
| var needRefresh = false; |
| if (!this._axisLineShape.invisible) { |
| this._axisLineShape.invisible = true; |
| this.zr.modShape(this._axisLineShape.id); |
| needRefresh = true; |
| } |
| if (!this._axisShadowShape.invisible) { |
| this._axisShadowShape.invisible = true; |
| this.zr.modShape(this._axisShadowShape.id); |
| needRefresh = true; |
| } |
| if (!this._axisCrossShape.invisible) { |
| this._axisCrossShape.invisible = true; |
| this.zr.modShape(this._axisCrossShape.id); |
| needRefresh = true; |
| } |
| if (this._lastTipShape && this._lastTipShape.tipShape.length > 0) { |
| this.zr.delShape(this._lastTipShape.tipShape); |
| this._lastTipShape = false; |
| this.shapeList.length = 2; |
| } |
| needRefresh && this.zr.refresh(); |
| this.showing = false; |
| }, |
| _show: function (position, x, y, specialCssText) { |
| var domHeight = this._tDom.offsetHeight; |
| var domWidth = this._tDom.offsetWidth; |
| if (position) { |
| if (typeof position === 'function') { |
| position = position([ |
| x, |
| y |
| ]); |
| } |
| if (position instanceof Array) { |
| x = position[0]; |
| y = position[1]; |
| } |
| } |
| if (x + domWidth > this._zrWidth) { |
| x -= domWidth + 40; |
| } |
| if (y + domHeight > this._zrHeight) { |
| y -= domHeight - 20; |
| } |
| if (y < 20) { |
| y = 0; |
| } |
| this._tDom.style.cssText = this._gCssText + this._defaultCssText + (specialCssText ? specialCssText : '') + 'left:' + x + 'px;top:' + y + 'px;'; |
| if (domHeight < 10 || domWidth < 10) { |
| setTimeout(this._refixed, 20); |
| } |
| this.showing = true; |
| }, |
| __refixed: function () { |
| if (this._tDom) { |
| var cssText = ''; |
| var domHeight = this._tDom.offsetHeight; |
| var domWidth = this._tDom.offsetWidth; |
| if (this._tDom.offsetLeft + domWidth > this._zrWidth) { |
| cssText += 'left:' + (this._zrWidth - domWidth - 20) + 'px;'; |
| } |
| if (this._tDom.offsetTop + domHeight > this._zrHeight) { |
| cssText += 'top:' + (this._zrHeight - domHeight - 10) + 'px;'; |
| } |
| if (cssText !== '') { |
| this._tDom.style.cssText += cssText; |
| } |
| } |
| }, |
| __tryShow: function () { |
| var needShow; |
| var trigger; |
| if (!this._curTarget) { |
| this._findPolarTrigger() || this._findAxisTrigger(); |
| } else { |
| if (this._curTarget._type === 'island' && this.option.tooltip.show) { |
| this._showItemTrigger(); |
| return; |
| } |
| var serie = ecData.get(this._curTarget, 'series'); |
| var data = ecData.get(this._curTarget, 'data'); |
| needShow = this.deepQuery([ |
| data, |
| serie, |
| this.option |
| ], 'tooltip.show'); |
| if (serie == null || data == null || !needShow) { |
| clearTimeout(this._hidingTicket); |
| clearTimeout(this._showingTicket); |
| this._hidingTicket = setTimeout(this._hide, this._hideDelay); |
| } else { |
| trigger = this.deepQuery([ |
| data, |
| serie, |
| this.option |
| ], 'tooltip.trigger'); |
| trigger === 'axis' ? this._showAxisTrigger(serie.xAxisIndex, serie.yAxisIndex, ecData.get(this._curTarget, 'dataIndex')) : this._showItemTrigger(); |
| } |
| } |
| }, |
| _findAxisTrigger: function () { |
| if (!this.component.xAxis || !this.component.yAxis) { |
| this._hidingTicket = setTimeout(this._hide, this._hideDelay); |
| return; |
| } |
| var series = this.option.series; |
| var xAxisIndex; |
| var yAxisIndex; |
| for (var i = 0, l = series.length; i < l; i++) { |
| if (this.deepQuery([ |
| series[i], |
| this.option |
| ], 'tooltip.trigger') === 'axis') { |
| xAxisIndex = series[i].xAxisIndex || 0; |
| yAxisIndex = series[i].yAxisIndex || 0; |
| if (this.component.xAxis.getAxis(xAxisIndex) && this.component.xAxis.getAxis(xAxisIndex).type === ecConfig.COMPONENT_TYPE_AXIS_CATEGORY) { |
| this._showAxisTrigger(xAxisIndex, yAxisIndex, this._getNearestDataIndex('x', this.component.xAxis.getAxis(xAxisIndex))); |
| return; |
| } else if (this.component.yAxis.getAxis(yAxisIndex) && this.component.yAxis.getAxis(yAxisIndex).type === ecConfig.COMPONENT_TYPE_AXIS_CATEGORY) { |
| this._showAxisTrigger(xAxisIndex, yAxisIndex, this._getNearestDataIndex('y', this.component.yAxis.getAxis(yAxisIndex))); |
| return; |
| } else { |
| this._showAxisTrigger(xAxisIndex, yAxisIndex, -1); |
| return; |
| } |
| } |
| } |
| if (this.option.tooltip.axisPointer.type === 'cross') { |
| this._showAxisTrigger(-1, -1, -1); |
| } |
| }, |
| _findPolarTrigger: function () { |
| if (!this.component.polar) { |
| return false; |
| } |
| var x = zrEvent.getX(this._event); |
| var y = zrEvent.getY(this._event); |
| var polarIndex = this.component.polar.getNearestIndex([ |
| x, |
| y |
| ]); |
| var valueIndex; |
| if (polarIndex) { |
| valueIndex = polarIndex.valueIndex; |
| polarIndex = polarIndex.polarIndex; |
| } else { |
| polarIndex = -1; |
| } |
| if (polarIndex != -1) { |
| return this._showPolarTrigger(polarIndex, valueIndex); |
| } |
| return false; |
| }, |
| _getNearestDataIndex: function (direction, categoryAxis) { |
| var dataIndex = -1; |
| var x = zrEvent.getX(this._event); |
| var y = zrEvent.getY(this._event); |
| if (direction === 'x') { |
| var left; |
| var right; |
| var xEnd = this.component.grid.getXend(); |
| var curCoord = categoryAxis.getCoordByIndex(dataIndex); |
| while (curCoord < xEnd) { |
| right = curCoord; |
| if (curCoord <= x) { |
| left = curCoord; |
| } else { |
| break; |
| } |
| curCoord = categoryAxis.getCoordByIndex(++dataIndex); |
| } |
| if (dataIndex <= 0) { |
| dataIndex = 0; |
| } else if (x - left <= right - x) { |
| dataIndex -= 1; |
| } else { |
| if (categoryAxis.getNameByIndex(dataIndex) == null) { |
| dataIndex -= 1; |
| } |
| } |
| return dataIndex; |
| } else { |
| var top; |
| var bottom; |
| var yStart = this.component.grid.getY(); |
| var curCoord = categoryAxis.getCoordByIndex(dataIndex); |
| while (curCoord > yStart) { |
| top = curCoord; |
| if (curCoord >= y) { |
| bottom = curCoord; |
| } else { |
| break; |
| } |
| curCoord = categoryAxis.getCoordByIndex(++dataIndex); |
| } |
| if (dataIndex <= 0) { |
| dataIndex = 0; |
| } else if (y - top >= bottom - y) { |
| dataIndex -= 1; |
| } else { |
| if (categoryAxis.getNameByIndex(dataIndex) == null) { |
| dataIndex -= 1; |
| } |
| } |
| return dataIndex; |
| } |
| return -1; |
| }, |
| _showAxisTrigger: function (xAxisIndex, yAxisIndex, dataIndex) { |
| !this._event.connectTrigger && this.messageCenter.dispatch(ecConfig.EVENT.TOOLTIP_IN_GRID, this._event, null, this.myChart); |
| if (this.component.xAxis == null || this.component.yAxis == null || xAxisIndex == null || yAxisIndex == null) { |
| clearTimeout(this._hidingTicket); |
| clearTimeout(this._showingTicket); |
| this._hidingTicket = setTimeout(this._hide, this._hideDelay); |
| return; |
| } |
| var series = this.option.series; |
| var seriesArray = []; |
| var seriesIndex = []; |
| var categoryAxis; |
| var formatter; |
| var position; |
| var showContent; |
| var specialCssText = ''; |
| if (this.option.tooltip.trigger === 'axis') { |
| if (!this.option.tooltip.show) { |
| return; |
| } |
| formatter = this.option.tooltip.formatter; |
| position = this.option.tooltip.position; |
| } |
| var axisLayout = xAxisIndex != -1 && this.component.xAxis.getAxis(xAxisIndex).type === ecConfig.COMPONENT_TYPE_AXIS_CATEGORY ? 'xAxis' : yAxisIndex != -1 && this.component.yAxis.getAxis(yAxisIndex).type === ecConfig.COMPONENT_TYPE_AXIS_CATEGORY ? 'yAxis' : false; |
| var x; |
| var y; |
| if (axisLayout) { |
| var axisIndex = axisLayout == 'xAxis' ? xAxisIndex : yAxisIndex; |
| categoryAxis = this.component[axisLayout].getAxis(axisIndex); |
| for (var i = 0, l = series.length; i < l; i++) { |
| if (!this._isSelected(series[i].name)) { |
| continue; |
| } |
| if (series[i][axisLayout + 'Index'] === axisIndex && this.deepQuery([ |
| series[i], |
| this.option |
| ], 'tooltip.trigger') === 'axis') { |
| showContent = this.query(series[i], 'tooltip.showContent') || showContent; |
| formatter = this.query(series[i], 'tooltip.formatter') || formatter; |
| position = this.query(series[i], 'tooltip.position') || position; |
| specialCssText += this._style(this.query(series[i], 'tooltip')); |
| if (series[i].stack != null && axisLayout == 'xAxis') { |
| seriesArray.unshift(series[i]); |
| seriesIndex.unshift(i); |
| } else { |
| seriesArray.push(series[i]); |
| seriesIndex.push(i); |
| } |
| } |
| } |
| this.messageCenter.dispatch(ecConfig.EVENT.TOOLTIP_HOVER, this._event, { |
| seriesIndex: seriesIndex, |
| dataIndex: dataIndex |
| }, this.myChart); |
| var rect; |
| if (axisLayout == 'xAxis') { |
| x = this.subPixelOptimize(categoryAxis.getCoordByIndex(dataIndex), this._axisLineWidth); |
| y = zrEvent.getY(this._event); |
| rect = [ |
| x, |
| this.component.grid.getY(), |
| x, |
| this.component.grid.getYend() |
| ]; |
| } else { |
| x = zrEvent.getX(this._event); |
| y = this.subPixelOptimize(categoryAxis.getCoordByIndex(dataIndex), this._axisLineWidth); |
| rect = [ |
| this.component.grid.getX(), |
| y, |
| this.component.grid.getXend(), |
| y |
| ]; |
| } |
| this._styleAxisPointer(seriesArray, rect[0], rect[1], rect[2], rect[3], categoryAxis.getGap(), x, y); |
| } else { |
| x = zrEvent.getX(this._event); |
| y = zrEvent.getY(this._event); |
| this._styleAxisPointer(series, this.component.grid.getX(), y, this.component.grid.getXend(), y, 0, x, y); |
| if (dataIndex >= 0) { |
| this._showItemTrigger(true); |
| } else { |
| clearTimeout(this._hidingTicket); |
| clearTimeout(this._showingTicket); |
| this._tDom.style.display = 'none'; |
| } |
| } |
| if (seriesArray.length > 0) { |
| if (this._lastDataIndex != dataIndex || this._lastSeriesIndex != seriesIndex[0]) { |
| this._lastDataIndex = dataIndex; |
| this._lastSeriesIndex = seriesIndex[0]; |
| var data; |
| var value; |
| if (typeof formatter === 'function') { |
| var params = []; |
| for (var i = 0, l = seriesArray.length; i < l; i++) { |
| data = seriesArray[i].data[dataIndex]; |
| value = data != null ? data.value != null ? data.value : data : '-'; |
| params.push({ |
| seriesIndex: seriesIndex[i], |
| seriesName: seriesArray[i].name || '', |
| series: seriesArray[i], |
| dataIndex: dataIndex, |
| data: data, |
| name: categoryAxis.getNameByIndex(dataIndex), |
| value: value, |
| 0: seriesArray[i].name || '', |
| 1: categoryAxis.getNameByIndex(dataIndex), |
| 2: value, |
| 3: data |
| }); |
| } |
| this._curTicket = 'axis:' + dataIndex; |
| this._tDom.innerHTML = formatter.call(this.myChart, params, this._curTicket, this._setContent); |
| } else if (typeof formatter === 'string') { |
| this._curTicket = NaN; |
| formatter = formatter.replace('{a}', '{a0}').replace('{b}', '{b0}').replace('{c}', '{c0}'); |
| for (var i = 0, l = seriesArray.length; i < l; i++) { |
| formatter = formatter.replace('{a' + i + '}', this._encodeHTML(seriesArray[i].name || '')); |
| formatter = formatter.replace('{b' + i + '}', this._encodeHTML(categoryAxis.getNameByIndex(dataIndex))); |
| data = seriesArray[i].data[dataIndex]; |
| data = data != null ? data.value != null ? data.value : data : '-'; |
| formatter = formatter.replace('{c' + i + '}', data instanceof Array ? data : this.numAddCommas(data)); |
| } |
| this._tDom.innerHTML = formatter; |
| } else { |
| this._curTicket = NaN; |
| formatter = this._encodeHTML(categoryAxis.getNameByIndex(dataIndex)); |
| for (var i = 0, l = seriesArray.length; i < l; i++) { |
| formatter += '<br/>' + this._encodeHTML(seriesArray[i].name || '') + ' : '; |
| data = seriesArray[i].data[dataIndex]; |
| data = data != null ? data.value != null ? data.value : data : '-'; |
| formatter += data instanceof Array ? data : this.numAddCommas(data); |
| } |
| this._tDom.innerHTML = formatter; |
| } |
| } |
| if (showContent === false || !this.option.tooltip.showContent) { |
| return; |
| } |
| if (!this.hasAppend) { |
| this._tDom.style.left = this._zrWidth / 2 + 'px'; |
| this._tDom.style.top = this._zrHeight / 2 + 'px'; |
| this.dom.firstChild.appendChild(this._tDom); |
| this.hasAppend = true; |
| } |
| this._show(position, x + 10, y + 10, specialCssText); |
| } |
| }, |
| _showPolarTrigger: function (polarIndex, dataIndex) { |
| if (this.component.polar == null || polarIndex == null || dataIndex == null || dataIndex < 0) { |
| return false; |
| } |
| var series = this.option.series; |
| var seriesArray = []; |
| var seriesIndex = []; |
| var formatter; |
| var position; |
| var showContent; |
| var specialCssText = ''; |
| if (this.option.tooltip.trigger === 'axis') { |
| if (!this.option.tooltip.show) { |
| return false; |
| } |
| formatter = this.option.tooltip.formatter; |
| position = this.option.tooltip.position; |
| } |
| var indicatorName = this.option.polar[polarIndex].indicator[dataIndex].text; |
| for (var i = 0, l = series.length; i < l; i++) { |
| if (!this._isSelected(series[i].name)) { |
| continue; |
| } |
| if (series[i].polarIndex === polarIndex && this.deepQuery([ |
| series[i], |
| this.option |
| ], 'tooltip.trigger') === 'axis') { |
| showContent = this.query(series[i], 'tooltip.showContent') || showContent; |
| formatter = this.query(series[i], 'tooltip.formatter') || formatter; |
| position = this.query(series[i], 'tooltip.position') || position; |
| specialCssText += this._style(this.query(series[i], 'tooltip')); |
| seriesArray.push(series[i]); |
| seriesIndex.push(i); |
| } |
| } |
| if (seriesArray.length > 0) { |
| var polarData; |
| var data; |
| var value; |
| var params = []; |
| for (var i = 0, l = seriesArray.length; i < l; i++) { |
| polarData = seriesArray[i].data; |
| for (var j = 0, k = polarData.length; j < k; j++) { |
| data = polarData[j]; |
| if (!this._isSelected(data.name)) { |
| continue; |
| } |
| data = data != null ? data : { |
| name: '', |
| value: { dataIndex: '-' } |
| }; |
| value = data.value[dataIndex].value != null ? data.value[dataIndex].value : data.value[dataIndex]; |
| params.push({ |
| seriesIndex: seriesIndex[i], |
| seriesName: seriesArray[i].name || '', |
| series: seriesArray[i], |
| dataIndex: dataIndex, |
| data: data, |
| name: data.name, |
| indicator: indicatorName, |
| value: value, |
| 0: seriesArray[i].name || '', |
| 1: data.name, |
| 2: value, |
| 3: indicatorName |
| }); |
| } |
| } |
| if (params.length <= 0) { |
| return; |
| } |
| if (this._lastDataIndex != dataIndex || this._lastSeriesIndex != seriesIndex[0]) { |
| this._lastDataIndex = dataIndex; |
| this._lastSeriesIndex = seriesIndex[0]; |
| if (typeof formatter === 'function') { |
| this._curTicket = 'axis:' + dataIndex; |
| this._tDom.innerHTML = formatter.call(this.myChart, params, this._curTicket, this._setContent); |
| } else if (typeof formatter === 'string') { |
| formatter = formatter.replace('{a}', '{a0}').replace('{b}', '{b0}').replace('{c}', '{c0}').replace('{d}', '{d0}'); |
| for (var i = 0, l = params.length; i < l; i++) { |
| formatter = formatter.replace('{a' + i + '}', this._encodeHTML(params[i].seriesName)); |
| formatter = formatter.replace('{b' + i + '}', this._encodeHTML(params[i].name)); |
| formatter = formatter.replace('{c' + i + '}', this.numAddCommas(params[i].value)); |
| formatter = formatter.replace('{d' + i + '}', this._encodeHTML(params[i].indicator)); |
| } |
| this._tDom.innerHTML = formatter; |
| } else { |
| formatter = this._encodeHTML(params[0].name) + '<br/>' + this._encodeHTML(params[0].indicator) + ' : ' + this.numAddCommas(params[0].value); |
| for (var i = 1, l = params.length; i < l; i++) { |
| formatter += '<br/>' + this._encodeHTML(params[i].name) + '<br/>'; |
| formatter += this._encodeHTML(params[i].indicator) + ' : ' + this.numAddCommas(params[i].value); |
| } |
| this._tDom.innerHTML = formatter; |
| } |
| } |
| if (showContent === false || !this.option.tooltip.showContent) { |
| return; |
| } |
| if (!this.hasAppend) { |
| this._tDom.style.left = this._zrWidth / 2 + 'px'; |
| this._tDom.style.top = this._zrHeight / 2 + 'px'; |
| this.dom.firstChild.appendChild(this._tDom); |
| this.hasAppend = true; |
| } |
| this._show(position, zrEvent.getX(this._event), zrEvent.getY(this._event), specialCssText); |
| return true; |
| } |
| }, |
| _showItemTrigger: function (axisTrigger) { |
| if (!this._curTarget) { |
| return; |
| } |
| var serie = ecData.get(this._curTarget, 'series'); |
| var seriesIndex = ecData.get(this._curTarget, 'seriesIndex'); |
| var data = ecData.get(this._curTarget, 'data'); |
| var dataIndex = ecData.get(this._curTarget, 'dataIndex'); |
| var name = ecData.get(this._curTarget, 'name'); |
| var value = ecData.get(this._curTarget, 'value'); |
| var special = ecData.get(this._curTarget, 'special'); |
| var special2 = ecData.get(this._curTarget, 'special2'); |
| var formatter; |
| var position; |
| var showContent; |
| var specialCssText = ''; |
| if (this._curTarget._type != 'island') { |
| var trigger = axisTrigger ? 'axis' : 'item'; |
| if (this.option.tooltip.trigger === trigger) { |
| formatter = this.option.tooltip.formatter; |
| position = this.option.tooltip.position; |
| } |
| if (this.query(serie, 'tooltip.trigger') === trigger) { |
| showContent = this.query(serie, 'tooltip.showContent') || showContent; |
| formatter = this.query(serie, 'tooltip.formatter') || formatter; |
| position = this.query(serie, 'tooltip.position') || position; |
| specialCssText += this._style(this.query(serie, 'tooltip')); |
| } |
| showContent = this.query(data, 'tooltip.showContent') || showContent; |
| formatter = this.query(data, 'tooltip.formatter') || formatter; |
| position = this.query(data, 'tooltip.position') || position; |
| specialCssText += this._style(this.query(data, 'tooltip')); |
| } else { |
| this._lastItemTriggerId = NaN; |
| showContent = this.deepQuery([ |
| data, |
| serie, |
| this.option |
| ], 'tooltip.showContent'); |
| formatter = this.deepQuery([ |
| data, |
| serie, |
| this.option |
| ], 'tooltip.islandFormatter'); |
| position = this.deepQuery([ |
| data, |
| serie, |
| this.option |
| ], 'tooltip.islandPosition'); |
| } |
| if (this._lastItemTriggerId !== this._curTarget.id) { |
| this._lastItemTriggerId = this._curTarget.id; |
| if (typeof formatter === 'function') { |
| this._curTicket = (serie.name || '') + ':' + dataIndex; |
| this._tDom.innerHTML = formatter.call(this.myChart, { |
| seriesIndex: seriesIndex, |
| seriesName: serie.name || '', |
| series: serie, |
| dataIndex: dataIndex, |
| data: data, |
| name: name, |
| value: value, |
| percent: special, |
| indicator: special, |
| value2: special2, |
| indicator2: special2, |
| 0: serie.name || '', |
| 1: name, |
| 2: value, |
| 3: special, |
| 4: special2, |
| 5: data, |
| 6: seriesIndex, |
| 7: dataIndex |
| }, this._curTicket, this._setContent); |
| } else if (typeof formatter === 'string') { |
| this._curTicket = NaN; |
| formatter = formatter.replace('{a}', '{a0}').replace('{b}', '{b0}').replace('{c}', '{c0}'); |
| formatter = formatter.replace('{a0}', this._encodeHTML(serie.name || '')).replace('{b0}', this._encodeHTML(name)).replace('{c0}', value instanceof Array ? value : this.numAddCommas(value)); |
| formatter = formatter.replace('{d}', '{d0}').replace('{d0}', special || ''); |
| formatter = formatter.replace('{e}', '{e0}').replace('{e0}', ecData.get(this._curTarget, 'special2') || ''); |
| this._tDom.innerHTML = formatter; |
| } else { |
| this._curTicket = NaN; |
| if (serie.type === ecConfig.CHART_TYPE_RADAR && special) { |
| this._tDom.innerHTML = this._itemFormatter.radar.call(this, serie, name, value, special); |
| } else if (serie.type === ecConfig.CHART_TYPE_EVENTRIVER) { |
| this._tDom.innerHTML = this._itemFormatter.eventRiver.call(this, serie, name, value, data); |
| } else { |
| this._tDom.innerHTML = '' + (serie.name != null ? this._encodeHTML(serie.name) + '<br/>' : '') + (name === '' ? '' : this._encodeHTML(name) + ' : ') + (value instanceof Array ? value : this.numAddCommas(value)); |
| } |
| } |
| } |
| if (!this._axisLineShape.invisible || !this._axisShadowShape.invisible) { |
| this._axisLineShape.invisible = true; |
| this.zr.modShape(this._axisLineShape.id); |
| this._axisShadowShape.invisible = true; |
| this.zr.modShape(this._axisShadowShape.id); |
| this.zr.refresh(); |
| } |
| if (showContent === false || !this.option.tooltip.showContent) { |
| return; |
| } |
| if (!this.hasAppend) { |
| this._tDom.style.left = this._zrWidth / 2 + 'px'; |
| this._tDom.style.top = this._zrHeight / 2 + 'px'; |
| this.dom.firstChild.appendChild(this._tDom); |
| this.hasAppend = true; |
| } |
| this._show(position, zrEvent.getX(this._event) + 20, zrEvent.getY(this._event) - 20, specialCssText); |
| }, |
| _itemFormatter: { |
| radar: function (serie, name, value, indicator) { |
| var html = ''; |
| html += this._encodeHTML(name === '' ? serie.name || '' : name); |
| html += html === '' ? '' : '<br />'; |
| for (var i = 0; i < indicator.length; i++) { |
| html += this._encodeHTML(indicator[i].text) + ' : ' + this.numAddCommas(value[i]) + '<br />'; |
| } |
| return html; |
| }, |
| chord: function (serie, name, value, special, special2) { |
| if (special2 == null) { |
| return this._encodeHTML(name) + ' (' + this.numAddCommas(value) + ')'; |
| } else { |
| var name1 = this._encodeHTML(name); |
| var name2 = this._encodeHTML(special); |
| return '' + (serie.name != null ? this._encodeHTML(serie.name) + '<br/>' : '') + name1 + ' -> ' + name2 + ' (' + this.numAddCommas(value) + ')' + '<br />' + name2 + ' -> ' + name1 + ' (' + this.numAddCommas(special2) + ')'; |
| } |
| }, |
| eventRiver: function (serie, name, value, data) { |
| var html = ''; |
| html += this._encodeHTML(serie.name === '' ? '' : serie.name + ' : '); |
| html += this._encodeHTML(name); |
| html += html === '' ? '' : '<br />'; |
| data = data.evolution; |
| for (var i = 0, l = data.length; i < l; i++) { |
| html += '<div style="padding-top:5px;">'; |
| if (!data[i].detail) { |
| continue; |
| } |
| if (data[i].detail.img) { |
| html += '<img src="' + data[i].detail.img + '" style="float:left;width:40px;height:40px;">'; |
| } |
| html += '<div style="margin-left:45px;">' + data[i].time + '<br/>'; |
| html += '<a href="' + data[i].detail.link + '" target="_blank">'; |
| html += data[i].detail.text + '</a></div>'; |
| html += '</div>'; |
| } |
| return html; |
| } |
| }, |
| _styleAxisPointer: function (seriesArray, xStart, yStart, xEnd, yEnd, gap, x, y) { |
| if (seriesArray.length > 0) { |
| var queryTarget; |
| var curType; |
| var axisPointer = this.option.tooltip.axisPointer; |
| var pointType = axisPointer.type; |
| var style = { |
| line: {}, |
| cross: {}, |
| shadow: {} |
| }; |
| for (var pType in style) { |
| style[pType].color = axisPointer[pType + 'Style'].color; |
| style[pType].width = axisPointer[pType + 'Style'].width; |
| style[pType].type = axisPointer[pType + 'Style'].type; |
| } |
| for (var i = 0, l = seriesArray.length; i < l; i++) { |
| if (this.deepQuery([ |
| seriesArray[i], |
| this.option |
| ], 'tooltip.trigger') === 'axis') { |
| queryTarget = seriesArray[i]; |
| curType = this.query(queryTarget, 'tooltip.axisPointer.type'); |
| pointType = curType || pointType; |
| if (curType) { |
| style[curType].color = this.query(queryTarget, 'tooltip.axisPointer.' + curType + 'Style.color') || style[curType].color; |
| style[curType].width = this.query(queryTarget, 'tooltip.axisPointer.' + curType + 'Style.width') || style[curType].width; |
| style[curType].type = this.query(queryTarget, 'tooltip.axisPointer.' + curType + 'Style.type') || style[curType].type; |
| } |
| } |
| } |
| if (pointType === 'line') { |
| this._axisLineShape.style = { |
| xStart: xStart, |
| yStart: yStart, |
| xEnd: xEnd, |
| yEnd: yEnd, |
| strokeColor: style.line.color, |
| lineWidth: style.line.width, |
| lineType: style.line.type |
| }; |
| this._axisLineShape.invisible = false; |
| this.zr.modShape(this._axisLineShape.id); |
| } else if (pointType === 'cross') { |
| this._axisCrossShape.style = { |
| brushType: 'stroke', |
| rect: this.component.grid.getArea(), |
| x: x, |
| y: y, |
| text: ('( ' + this.component.xAxis.getAxis(0).getValueFromCoord(x) + ' , ' + this.component.yAxis.getAxis(0).getValueFromCoord(y) + ' )').replace(' , ', ' ').replace(' , ', ' '), |
| textPosition: 'specific', |
| strokeColor: style.cross.color, |
| lineWidth: style.cross.width, |
| lineType: style.cross.type |
| }; |
| if (this.component.grid.getXend() - x > 100) { |
| this._axisCrossShape.style.textAlign = 'left'; |
| this._axisCrossShape.style.textX = x + 10; |
| } else { |
| this._axisCrossShape.style.textAlign = 'right'; |
| this._axisCrossShape.style.textX = x - 10; |
| } |
| if (y - this.component.grid.getY() > 50) { |
| this._axisCrossShape.style.textBaseline = 'bottom'; |
| this._axisCrossShape.style.textY = y - 10; |
| } else { |
| this._axisCrossShape.style.textBaseline = 'top'; |
| this._axisCrossShape.style.textY = y + 10; |
| } |
| this._axisCrossShape.invisible = false; |
| this.zr.modShape(this._axisCrossShape.id); |
| } else if (pointType === 'shadow') { |
| if (style.shadow.width == null || style.shadow.width === 'auto' || isNaN(style.shadow.width)) { |
| style.shadow.width = gap; |
| } |
| if (xStart === xEnd) { |
| if (Math.abs(this.component.grid.getX() - xStart) < 2) { |
| style.shadow.width /= 2; |
| xStart = xEnd = xEnd + style.shadow.width / 2; |
| } else if (Math.abs(this.component.grid.getXend() - xStart) < 2) { |
| style.shadow.width /= 2; |
| xStart = xEnd = xEnd - style.shadow.width / 2; |
| } |
| } else if (yStart === yEnd) { |
| if (Math.abs(this.component.grid.getY() - yStart) < 2) { |
| style.shadow.width /= 2; |
| yStart = yEnd = yEnd + style.shadow.width / 2; |
| } else if (Math.abs(this.component.grid.getYend() - yStart) < 2) { |
| style.shadow.width /= 2; |
| yStart = yEnd = yEnd - style.shadow.width / 2; |
| } |
| } |
| this._axisShadowShape.style = { |
| xStart: xStart, |
| yStart: yStart, |
| xEnd: xEnd, |
| yEnd: yEnd, |
| strokeColor: style.shadow.color, |
| lineWidth: style.shadow.width |
| }; |
| this._axisShadowShape.invisible = false; |
| this.zr.modShape(this._axisShadowShape.id); |
| } |
| this.zr.refresh(); |
| } |
| }, |
| __onmousemove: function (param) { |
| clearTimeout(this._hidingTicket); |
| clearTimeout(this._showingTicket); |
| if (this._mousein && this._enterable) { |
| return; |
| } |
| var target = param.target; |
| var mx = zrEvent.getX(param.event); |
| var my = zrEvent.getY(param.event); |
| if (!target) { |
| this._curTarget = false; |
| this._event = param.event; |
| this._event.zrenderX = mx; |
| this._event.zrenderY = my; |
| if (this._needAxisTrigger && this.component.grid && zrArea.isInside(rectangleInstance, this.component.grid.getArea(), mx, my)) { |
| this._showingTicket = setTimeout(this._tryShow, this._showDelay); |
| } else if (this._needAxisTrigger && this.component.polar && this.component.polar.isInside([ |
| mx, |
| my |
| ]) != -1) { |
| this._showingTicket = setTimeout(this._tryShow, this._showDelay); |
| } else { |
| !this._event.connectTrigger && this.messageCenter.dispatch(ecConfig.EVENT.TOOLTIP_OUT_GRID, this._event, null, this.myChart); |
| this._hidingTicket = setTimeout(this._hide, this._hideDelay); |
| } |
| } else { |
| this._curTarget = target; |
| this._event = param.event; |
| this._event.zrenderX = mx; |
| this._event.zrenderY = my; |
| var polarIndex; |
| if (this._needAxisTrigger && this.component.polar && (polarIndex = this.component.polar.isInside([ |
| mx, |
| my |
| ])) != -1) { |
| var series = this.option.series; |
| for (var i = 0, l = series.length; i < l; i++) { |
| if (series[i].polarIndex === polarIndex && this.deepQuery([ |
| series[i], |
| this.option |
| ], 'tooltip.trigger') === 'axis') { |
| this._curTarget = null; |
| break; |
| } |
| } |
| } |
| this._showingTicket = setTimeout(this._tryShow, this._showDelay); |
| } |
| }, |
| __onglobalout: function () { |
| clearTimeout(this._hidingTicket); |
| clearTimeout(this._showingTicket); |
| this._hidingTicket = setTimeout(this._hide, this._hideDelay); |
| }, |
| __setContent: function (ticket, content) { |
| if (!this._tDom) { |
| return; |
| } |
| if (ticket === this._curTicket) { |
| this._tDom.innerHTML = content; |
| } |
| setTimeout(this._refixed, 20); |
| }, |
| ontooltipHover: function (param, tipShape) { |
| if (!this._lastTipShape || this._lastTipShape && this._lastTipShape.dataIndex != param.dataIndex) { |
| if (this._lastTipShape && this._lastTipShape.tipShape.length > 0) { |
| this.zr.delShape(this._lastTipShape.tipShape); |
| this.shapeList.length = 2; |
| } |
| for (var i = 0, l = tipShape.length; i < l; i++) { |
| tipShape[i].zlevel = this._zlevelBase; |
| tipShape[i].style = zrShapeBase.prototype.getHighlightStyle(tipShape[i].style, tipShape[i].highlightStyle); |
| tipShape[i].draggable = false; |
| tipShape[i].hoverable = false; |
| tipShape[i].clickable = false; |
| tipShape[i].ondragend = null; |
| tipShape[i].ondragover = null; |
| tipShape[i].ondrop = null; |
| this.shapeList.push(tipShape[i]); |
| this.zr.addShape(tipShape[i]); |
| } |
| this._lastTipShape = { |
| dataIndex: param.dataIndex, |
| tipShape: tipShape |
| }; |
| } |
| }, |
| ondragend: function () { |
| this._hide(); |
| }, |
| onlegendSelected: function (param) { |
| this._selectedMap = param.selected; |
| }, |
| _setSelectedMap: function () { |
| if (this.component.legend) { |
| this._selectedMap = zrUtil.clone(this.component.legend.getSelectedMap()); |
| } else { |
| this._selectedMap = {}; |
| } |
| }, |
| _isSelected: function (itemName) { |
| if (this._selectedMap[itemName] != null) { |
| return this._selectedMap[itemName]; |
| } else { |
| return true; |
| } |
| }, |
| showTip: function (params) { |
| if (!params) { |
| return; |
| } |
| var seriesIndex; |
| var series = this.option.series; |
| if (params.seriesIndex != null) { |
| seriesIndex = params.seriesIndex; |
| } else { |
| var seriesName = params.seriesName; |
| for (var i = 0, l = series.length; i < l; i++) { |
| if (series[i].name === seriesName) { |
| seriesIndex = i; |
| break; |
| } |
| } |
| } |
| var serie = series[seriesIndex]; |
| if (serie == null) { |
| return; |
| } |
| var chart = this.myChart.chart[serie.type]; |
| var isAxisTrigger = this.deepQuery([ |
| serie, |
| this.option |
| ], 'tooltip.trigger') === 'axis'; |
| if (!chart) { |
| return; |
| } |
| if (isAxisTrigger) { |
| var dataIndex = params.dataIndex; |
| switch (chart.type) { |
| case ecConfig.CHART_TYPE_LINE: |
| case ecConfig.CHART_TYPE_BAR: |
| case ecConfig.CHART_TYPE_K: |
| if (this.component.xAxis == null || this.component.yAxis == null || serie.data.length <= dataIndex) { |
| return; |
| } |
| var xAxisIndex = serie.xAxisIndex || 0; |
| var yAxisIndex = serie.yAxisIndex || 0; |
| if (this.component.xAxis.getAxis(xAxisIndex).type === ecConfig.COMPONENT_TYPE_AXIS_CATEGORY) { |
| this._event = { |
| zrenderX: this.component.xAxis.getAxis(xAxisIndex).getCoordByIndex(dataIndex), |
| zrenderY: this.component.grid.getY() + (this.component.grid.getYend() - this.component.grid.getY()) / 4 |
| }; |
| } else { |
| this._event = { |
| zrenderX: this.component.grid.getX() + (this.component.grid.getXend() - this.component.grid.getX()) / 4, |
| zrenderY: this.component.yAxis.getAxis(yAxisIndex).getCoordByIndex(dataIndex) |
| }; |
| } |
| this._showAxisTrigger(xAxisIndex, yAxisIndex, dataIndex); |
| break; |
| case ecConfig.CHART_TYPE_RADAR: |
| if (this.component.polar == null || serie.data[0].value.length <= dataIndex) { |
| return; |
| } |
| var polarIndex = serie.polarIndex || 0; |
| var vector = this.component.polar.getVector(polarIndex, dataIndex, 'max'); |
| this._event = { |
| zrenderX: vector[0], |
| zrenderY: vector[1] |
| }; |
| this._showPolarTrigger(polarIndex, dataIndex); |
| break; |
| } |
| } else { |
| var shapeList = chart.shapeList; |
| var x; |
| var y; |
| switch (chart.type) { |
| case ecConfig.CHART_TYPE_LINE: |
| case ecConfig.CHART_TYPE_BAR: |
| case ecConfig.CHART_TYPE_K: |
| case ecConfig.CHART_TYPE_SCATTER: |
| var dataIndex = params.dataIndex; |
| for (var i = 0, l = shapeList.length; i < l; i++) { |
| if (ecData.get(shapeList[i], 'seriesIndex') == seriesIndex && ecData.get(shapeList[i], 'dataIndex') == dataIndex) { |
| this._curTarget = shapeList[i]; |
| x = shapeList[i].style.x; |
| y = chart.type != ecConfig.CHART_TYPE_K ? shapeList[i].style.y : shapeList[i].style.y[0]; |
| break; |
| } |
| } |
| break; |
| case ecConfig.CHART_TYPE_RADAR: |
| var dataIndex = params.dataIndex; |
| for (var i = 0, l = shapeList.length; i < l; i++) { |
| if (shapeList[i].type === 'polygon' && ecData.get(shapeList[i], 'seriesIndex') == seriesIndex && ecData.get(shapeList[i], 'dataIndex') == dataIndex) { |
| this._curTarget = shapeList[i]; |
| var vector = this.component.polar.getCenter(serie.polarIndex || 0); |
| x = vector[0]; |
| y = vector[1]; |
| break; |
| } |
| } |
| break; |
| case ecConfig.CHART_TYPE_PIE: |
| var name = params.name; |
| for (var i = 0, l = shapeList.length; i < l; i++) { |
| if (shapeList[i].type === 'sector' && ecData.get(shapeList[i], 'seriesIndex') == seriesIndex && ecData.get(shapeList[i], 'name') == name) { |
| this._curTarget = shapeList[i]; |
| var style = this._curTarget.style; |
| var midAngle = (style.startAngle + style.endAngle) / 2 * Math.PI / 180; |
| x = this._curTarget.style.x + Math.cos(midAngle) * style.r / 1.5; |
| y = this._curTarget.style.y - Math.sin(midAngle) * style.r / 1.5; |
| break; |
| } |
| } |
| break; |
| case ecConfig.CHART_TYPE_MAP: |
| var name = params.name; |
| var mapType = serie.mapType; |
| for (var i = 0, l = shapeList.length; i < l; i++) { |
| if (shapeList[i].type === 'text' && shapeList[i]._mapType === mapType && shapeList[i].style._name === name) { |
| this._curTarget = shapeList[i]; |
| x = this._curTarget.style.x + this._curTarget.position[0]; |
| y = this._curTarget.style.y + this._curTarget.position[1]; |
| break; |
| } |
| } |
| break; |
| case ecConfig.CHART_TYPE_CHORD: |
| var name = params.name; |
| for (var i = 0, l = shapeList.length; i < l; i++) { |
| if (shapeList[i].type === 'sector' && ecData.get(shapeList[i], 'name') == name) { |
| this._curTarget = shapeList[i]; |
| var style = this._curTarget.style; |
| var midAngle = (style.startAngle + style.endAngle) / 2 * Math.PI / 180; |
| x = this._curTarget.style.x + Math.cos(midAngle) * (style.r - 2); |
| y = this._curTarget.style.y - Math.sin(midAngle) * (style.r - 2); |
| this.zr.trigger(zrConfig.EVENT.MOUSEMOVE, { |
| zrenderX: x, |
| zrenderY: y |
| }); |
| return; |
| } |
| } |
| break; |
| case ecConfig.CHART_TYPE_FORCE: |
| var name = params.name; |
| for (var i = 0, l = shapeList.length; i < l; i++) { |
| if (shapeList[i].type === 'circle' && ecData.get(shapeList[i], 'name') == name) { |
| this._curTarget = shapeList[i]; |
| x = this._curTarget.position[0]; |
| y = this._curTarget.position[1]; |
| break; |
| } |
| } |
| break; |
| } |
| if (x != null && y != null) { |
| this._event = { |
| zrenderX: x, |
| zrenderY: y |
| }; |
| this.zr.addHoverShape(this._curTarget); |
| this.zr.refreshHover(); |
| this._showItemTrigger(); |
| } |
| } |
| }, |
| hideTip: function () { |
| this._hide(); |
| }, |
| refresh: function (newOption) { |
| this._zrHeight = this.zr.getHeight(); |
| this._zrWidth = this.zr.getWidth(); |
| if (this._lastTipShape && this._lastTipShape.tipShape.length > 0) { |
| this.zr.delShape(this._lastTipShape.tipShape); |
| } |
| this._lastTipShape = false; |
| this.shapeList.length = 2; |
| this._lastDataIndex = -1; |
| this._lastSeriesIndex = -1; |
| this._lastItemTriggerId = -1; |
| if (newOption) { |
| this.option = newOption; |
| this.option.tooltip = this.reformOption(this.option.tooltip); |
| this.option.tooltip.textStyle = zrUtil.merge(this.option.tooltip.textStyle, this.ecTheme.textStyle); |
| this._needAxisTrigger = false; |
| if (this.option.tooltip.trigger === 'axis') { |
| this._needAxisTrigger = true; |
| } |
| var series = this.option.series; |
| for (var i = 0, l = series.length; i < l; i++) { |
| if (this.query(series[i], 'tooltip.trigger') === 'axis') { |
| this._needAxisTrigger = true; |
| break; |
| } |
| } |
| this._showDelay = this.option.tooltip.showDelay; |
| this._hideDelay = this.option.tooltip.hideDelay; |
| this._defaultCssText = this._style(this.option.tooltip); |
| this._setSelectedMap(); |
| this._axisLineWidth = this.option.tooltip.axisPointer.lineStyle.width; |
| this._enterable = this.option.tooltip.enterable; |
| } |
| if (this.showing) { |
| var self = this; |
| setTimeout(function () { |
| self.zr.trigger(zrConfig.EVENT.MOUSEMOVE, self.zr.handler._event); |
| }, 50); |
| } |
| }, |
| onbeforDispose: function () { |
| if (this._lastTipShape && this._lastTipShape.tipShape.length > 0) { |
| this.zr.delShape(this._lastTipShape.tipShape); |
| } |
| clearTimeout(this._hidingTicket); |
| clearTimeout(this._showingTicket); |
| this.zr.un(zrConfig.EVENT.MOUSEMOVE, this._onmousemove); |
| this.zr.un(zrConfig.EVENT.GLOBALOUT, this._onglobalout); |
| if (this.hasAppend) { |
| this.dom.firstChild.removeChild(this._tDom); |
| } |
| this._tDom = null; |
| }, |
| _encodeHTML: function (source) { |
| return String(source).replace(/&/g, '&').replace(/</g, '<').replace(/>/g, '>').replace(/"/g, '"').replace(/'/g, '''); |
| } |
| }; |
| zrUtil.inherits(Tooltip, Base); |
| require('../component').define('tooltip', Tooltip); |
| return Tooltip; |
| });define('echarts/component/legend', [ |
| 'require', |
| './base', |
| 'zrender/shape/Text', |
| 'zrender/shape/Rectangle', |
| 'zrender/shape/Sector', |
| '../util/shape/Icon', |
| '../util/shape/Candle', |
| '../config', |
| 'zrender/tool/util', |
| 'zrender/tool/area', |
| '../component' |
| ], function (require) { |
| var Base = require('./base'); |
| var TextShape = require('zrender/shape/Text'); |
| var RectangleShape = require('zrender/shape/Rectangle'); |
| var SectorShape = require('zrender/shape/Sector'); |
| var IconShape = require('../util/shape/Icon'); |
| var CandleShape = require('../util/shape/Candle'); |
| var ecConfig = require('../config'); |
| var zrUtil = require('zrender/tool/util'); |
| var zrArea = require('zrender/tool/area'); |
| function Legend(ecTheme, messageCenter, zr, option, myChart) { |
| if (!this.query(option, 'legend.data')) { |
| console.error('option.legend.data has not been defined.'); |
| return; |
| } |
| Base.call(this, ecTheme, messageCenter, zr, option, myChart); |
| var self = this; |
| self._legendSelected = function (param) { |
| self.__legendSelected(param); |
| }; |
| self._dispatchHoverLink = function (param) { |
| return self.__dispatchHoverLink(param); |
| }; |
| this._colorIndex = 0; |
| this._colorMap = {}; |
| this._selectedMap = {}; |
| this._hasDataMap = {}; |
| this.refresh(option); |
| } |
| Legend.prototype = { |
| type: ecConfig.COMPONENT_TYPE_LEGEND, |
| _buildShape: function () { |
| if (!this.legendOption.show) { |
| return; |
| } |
| this._itemGroupLocation = this._getItemGroupLocation(); |
| this._buildBackground(); |
| this._buildItem(); |
| for (var i = 0, l = this.shapeList.length; i < l; i++) { |
| this.zr.addShape(this.shapeList[i]); |
| } |
| }, |
| _buildItem: function () { |
| var data = this.legendOption.data; |
| var dataLength = data.length; |
| var itemName; |
| var itemType; |
| var itemShape; |
| var textShape; |
| var textStyle = this.legendOption.textStyle; |
| var dataTextStyle; |
| var dataFont; |
| var formattedName; |
| var zrWidth = this.zr.getWidth(); |
| var zrHeight = this.zr.getHeight(); |
| var lastX = this._itemGroupLocation.x; |
| var lastY = this._itemGroupLocation.y; |
| var itemWidth = this.legendOption.itemWidth; |
| var itemHeight = this.legendOption.itemHeight; |
| var itemGap = this.legendOption.itemGap; |
| var color; |
| if (this.legendOption.orient === 'vertical' && this.legendOption.x === 'right') { |
| lastX = this._itemGroupLocation.x + this._itemGroupLocation.width - itemWidth; |
| } |
| for (var i = 0; i < dataLength; i++) { |
| dataTextStyle = zrUtil.merge(data[i].textStyle || {}, textStyle); |
| dataFont = this.getFont(dataTextStyle); |
| itemName = this._getName(data[i]); |
| formattedName = this._getFormatterName(itemName); |
| if (itemName === '') { |
| if (this.legendOption.orient === 'horizontal') { |
| lastX = this._itemGroupLocation.x; |
| lastY += itemHeight + itemGap; |
| } else { |
| this.legendOption.x === 'right' ? lastX -= this._itemGroupLocation.maxWidth + itemGap : lastX += this._itemGroupLocation.maxWidth + itemGap; |
| lastY = this._itemGroupLocation.y; |
| } |
| continue; |
| } |
| itemType = data[i].icon || this._getSomethingByName(itemName).type; |
| color = this.getColor(itemName); |
| if (this.legendOption.orient === 'horizontal') { |
| if (zrWidth - lastX < 200 && itemWidth + 5 + zrArea.getTextWidth(formattedName, dataFont) + (i === dataLength - 1 || data[i + 1] === '' ? 0 : itemGap) >= zrWidth - lastX) { |
| lastX = this._itemGroupLocation.x; |
| lastY += itemHeight + itemGap; |
| } |
| } else { |
| if (zrHeight - lastY < 200 && itemHeight + (i === dataLength - 1 || data[i + 1] === '' ? 0 : itemGap) >= zrHeight - lastY) { |
| this.legendOption.x === 'right' ? lastX -= this._itemGroupLocation.maxWidth + itemGap : lastX += this._itemGroupLocation.maxWidth + itemGap; |
| lastY = this._itemGroupLocation.y; |
| } |
| } |
| itemShape = this._getItemShapeByType(lastX, lastY, itemWidth, itemHeight, this._selectedMap[itemName] && this._hasDataMap[itemName] ? color : '#ccc', itemType, color); |
| itemShape._name = itemName; |
| itemShape = new IconShape(itemShape); |
| textShape = { |
| zlevel: this._zlevelBase, |
| style: { |
| x: lastX + itemWidth + 5, |
| y: lastY + itemHeight / 2, |
| color: this._selectedMap[itemName] ? dataTextStyle.color === 'auto' ? color : dataTextStyle.color : '#ccc', |
| text: formattedName, |
| textFont: dataFont, |
| textBaseline: 'middle' |
| }, |
| highlightStyle: { |
| color: color, |
| brushType: 'fill' |
| }, |
| hoverable: !!this.legendOption.selectedMode, |
| clickable: !!this.legendOption.selectedMode |
| }; |
| if (this.legendOption.orient === 'vertical' && this.legendOption.x === 'right') { |
| textShape.style.x -= itemWidth + 10; |
| textShape.style.textAlign = 'right'; |
| } |
| textShape._name = itemName; |
| textShape = new TextShape(textShape); |
| if (this.legendOption.selectedMode) { |
| itemShape.onclick = textShape.onclick = this._legendSelected; |
| itemShape.onmouseover = textShape.onmouseover = this._dispatchHoverLink; |
| itemShape.hoverConnect = textShape.id; |
| textShape.hoverConnect = itemShape.id; |
| } |
| this.shapeList.push(itemShape); |
| this.shapeList.push(textShape); |
| if (this.legendOption.orient === 'horizontal') { |
| lastX += itemWidth + 5 + zrArea.getTextWidth(formattedName, dataFont) + itemGap; |
| } else { |
| lastY += itemHeight + itemGap; |
| } |
| } |
| if (this.legendOption.orient === 'horizontal' && this.legendOption.x === 'center' && lastY != this._itemGroupLocation.y) { |
| this._mLineOptimize(); |
| } |
| }, |
| _getName: function (data) { |
| return typeof data.name != 'undefined' ? data.name : data; |
| }, |
| _getFormatterName: function (itemName) { |
| var formatter = this.legendOption.formatter; |
| var formattedName; |
| if (typeof formatter === 'function') { |
| formattedName = formatter.call(this.myChart, itemName); |
| } else if (typeof formatter === 'string') { |
| formattedName = formatter.replace('{name}', itemName); |
| } else { |
| formattedName = itemName; |
| } |
| return formattedName; |
| }, |
| _getFormatterNameFromData: function (data) { |
| var itemName = this._getName(data); |
| return this._getFormatterName(itemName); |
| }, |
| _mLineOptimize: function () { |
| var lineOffsetArray = []; |
| var lastX = this._itemGroupLocation.x; |
| for (var i = 2, l = this.shapeList.length; i < l; i++) { |
| if (this.shapeList[i].style.x === lastX) { |
| lineOffsetArray.push((this._itemGroupLocation.width - (this.shapeList[i - 1].style.x + zrArea.getTextWidth(this.shapeList[i - 1].style.text, this.shapeList[i - 1].style.textFont) - lastX)) / 2); |
| } else if (i === l - 1) { |
| lineOffsetArray.push((this._itemGroupLocation.width - (this.shapeList[i].style.x + zrArea.getTextWidth(this.shapeList[i].style.text, this.shapeList[i].style.textFont) - lastX)) / 2); |
| } |
| } |
| var curLineIndex = -1; |
| for (var i = 1, l = this.shapeList.length; i < l; i++) { |
| if (this.shapeList[i].style.x === lastX) { |
| curLineIndex++; |
| } |
| if (lineOffsetArray[curLineIndex] === 0) { |
| continue; |
| } else { |
| this.shapeList[i].style.x += lineOffsetArray[curLineIndex]; |
| } |
| } |
| }, |
| _buildBackground: function () { |
| var padding = this.reformCssArray(this.legendOption.padding); |
| this.shapeList.push(new RectangleShape({ |
| zlevel: this._zlevelBase, |
| hoverable: false, |
| style: { |
| x: this._itemGroupLocation.x - padding[3], |
| y: this._itemGroupLocation.y - padding[0], |
| width: this._itemGroupLocation.width + padding[3] + padding[1], |
| height: this._itemGroupLocation.height + padding[0] + padding[2], |
| brushType: this.legendOption.borderWidth === 0 ? 'fill' : 'both', |
| color: this.legendOption.backgroundColor, |
| strokeColor: this.legendOption.borderColor, |
| lineWidth: this.legendOption.borderWidth |
| } |
| })); |
| }, |
| _getItemGroupLocation: function () { |
| var data = this.legendOption.data; |
| var dataLength = data.length; |
| var itemGap = this.legendOption.itemGap; |
| var itemWidth = this.legendOption.itemWidth + 5; |
| var itemHeight = this.legendOption.itemHeight; |
| var textStyle = this.legendOption.textStyle; |
| var font = this.getFont(textStyle); |
| var totalWidth = 0; |
| var totalHeight = 0; |
| var padding = this.reformCssArray(this.legendOption.padding); |
| var zrWidth = this.zr.getWidth() - padding[1] - padding[3]; |
| var zrHeight = this.zr.getHeight() - padding[0] - padding[2]; |
| var temp = 0; |
| var maxWidth = 0; |
| if (this.legendOption.orient === 'horizontal') { |
| totalHeight = itemHeight; |
| for (var i = 0; i < dataLength; i++) { |
| if (this._getName(data[i]) === '') { |
| temp -= itemGap; |
| if (temp > zrWidth) { |
| totalWidth = zrWidth; |
| totalHeight += itemHeight + itemGap; |
| } else { |
| totalWidth = Math.max(totalWidth, temp); |
| } |
| totalHeight += itemHeight + itemGap; |
| temp = 0; |
| continue; |
| } |
| temp += itemWidth + zrArea.getTextWidth(this._getFormatterNameFromData(data[i]), data[i].textStyle ? this.getFont(zrUtil.merge(data[i].textStyle || {}, textStyle)) : font) + itemGap; |
| } |
| totalHeight = Math.max(totalHeight, itemHeight); |
| temp -= itemGap; |
| if (temp > zrWidth) { |
| totalWidth = zrWidth; |
| totalHeight += itemHeight + itemGap; |
| } else { |
| totalWidth = Math.max(totalWidth, temp); |
| } |
| } else { |
| for (var i = 0; i < dataLength; i++) { |
| maxWidth = Math.max(maxWidth, zrArea.getTextWidth(this._getFormatterNameFromData(data[i]), data[i].textStyle ? this.getFont(zrUtil.merge(data[i].textStyle || {}, textStyle)) : font)); |
| } |
| maxWidth += itemWidth; |
| totalWidth = maxWidth; |
| for (var i = 0; i < dataLength; i++) { |
| if (this._getName(data[i]) === '') { |
| temp -= itemGap; |
| if (temp > zrHeight) { |
| totalHeight = zrHeight; |
| totalWidth += maxWidth + itemGap; |
| } else { |
| totalHeight = Math.max(totalHeight, temp); |
| } |
| totalWidth += maxWidth + itemGap; |
| temp = 0; |
| continue; |
| } |
| temp += itemHeight + itemGap; |
| } |
| totalWidth = Math.max(totalWidth, maxWidth); |
| temp -= itemGap; |
| if (temp > zrHeight) { |
| totalHeight = zrHeight; |
| totalWidth += maxWidth + itemGap; |
| } else { |
| totalHeight = Math.max(totalHeight, temp); |
| } |
| } |
| zrWidth = this.zr.getWidth(); |
| zrHeight = this.zr.getHeight(); |
| var x; |
| switch (this.legendOption.x) { |
| case 'center': |
| x = Math.floor((zrWidth - totalWidth) / 2); |
| break; |
| case 'left': |
| x = padding[3] + this.legendOption.borderWidth; |
| break; |
| case 'right': |
| x = zrWidth - totalWidth - padding[1] - padding[3] - this.legendOption.borderWidth * 2; |
| break; |
| default: |
| x = this.parsePercent(this.legendOption.x, zrWidth); |
| break; |
| } |
| var y; |
| switch (this.legendOption.y) { |
| case 'top': |
| y = padding[0] + this.legendOption.borderWidth; |
| break; |
| case 'bottom': |
| y = zrHeight - totalHeight - padding[0] - padding[2] - this.legendOption.borderWidth * 2; |
| break; |
| case 'center': |
| y = Math.floor((zrHeight - totalHeight) / 2); |
| break; |
| default: |
| y = this.parsePercent(this.legendOption.y, zrHeight); |
| break; |
| } |
| return { |
| x: x, |
| y: y, |
| width: totalWidth, |
| height: totalHeight, |
| maxWidth: maxWidth |
| }; |
| }, |
| _getSomethingByName: function (name) { |
| var series = this.option.series; |
| var data; |
| for (var i = 0, l = series.length; i < l; i++) { |
| if (series[i].name === name) { |
| return { |
| type: series[i].type, |
| series: series[i], |
| seriesIndex: i, |
| data: null, |
| dataIndex: -1 |
| }; |
| } |
| if (series[i].type === ecConfig.CHART_TYPE_PIE || series[i].type === ecConfig.CHART_TYPE_RADAR || series[i].type === ecConfig.CHART_TYPE_CHORD || series[i].type === ecConfig.CHART_TYPE_FORCE || series[i].type === ecConfig.CHART_TYPE_FUNNEL) { |
| data = series[i].categories || series[i].data || series[i].nodes; |
| for (var j = 0, k = data.length; j < k; j++) { |
| if (data[j].name === name) { |
| return { |
| type: series[i].type, |
| series: series[i], |
| seriesIndex: i, |
| data: data[j], |
| dataIndex: j |
| }; |
| } |
| } |
| } |
| } |
| return { |
| type: 'bar', |
| series: null, |
| seriesIndex: -1, |
| data: null, |
| dataIndex: -1 |
| }; |
| }, |
| _getItemShapeByType: function (x, y, width, height, color, itemType, defaultColor) { |
| var highlightColor = color === '#ccc' ? defaultColor : color; |
| var itemShape = { |
| zlevel: this._zlevelBase, |
| style: { |
| iconType: 'legendicon' + itemType, |
| x: x, |
| y: y, |
| width: width, |
| height: height, |
| color: color, |
| strokeColor: color, |
| lineWidth: 2 |
| }, |
| highlightStyle: { |
| color: highlightColor, |
| strokeColor: highlightColor, |
| lineWidth: 1 |
| }, |
| hoverable: this.legendOption.selectedMode, |
| clickable: this.legendOption.selectedMode |
| }; |
| var imageLocation; |
| if (itemType.match('image')) { |
| var imageLocation = itemType.replace(new RegExp('^image:\\/\\/'), ''); |
| itemType = 'image'; |
| } |
| switch (itemType) { |
| case 'line': |
| itemShape.style.brushType = 'stroke'; |
| itemShape.highlightStyle.lineWidth = 3; |
| break; |
| case 'radar': |
| case 'scatter': |
| itemShape.highlightStyle.lineWidth = 3; |
| break; |
| case 'k': |
| itemShape.style.brushType = 'both'; |
| itemShape.highlightStyle.lineWidth = 3; |
| itemShape.highlightStyle.color = itemShape.style.color = this.query(this.ecTheme, 'k.itemStyle.normal.color') || '#fff'; |
| itemShape.style.strokeColor = color != '#ccc' ? this.query(this.ecTheme, 'k.itemStyle.normal.lineStyle.color') || '#ff3200' : color; |
| break; |
| case 'image': |
| itemShape.style.iconType = 'image'; |
| itemShape.style.image = imageLocation; |
| if (color === '#ccc') { |
| itemShape.style.opacity = 0.5; |
| } |
| break; |
| } |
| return itemShape; |
| }, |
| __legendSelected: function (param) { |
| var itemName = param.target._name; |
| if (this.legendOption.selectedMode === 'single') { |
| for (var k in this._selectedMap) { |
| this._selectedMap[k] = false; |
| } |
| } |
| this._selectedMap[itemName] = !this._selectedMap[itemName]; |
| this.messageCenter.dispatch(ecConfig.EVENT.LEGEND_SELECTED, param.event, { |
| selected: this._selectedMap, |
| target: itemName |
| }, this.myChart); |
| }, |
| __dispatchHoverLink: function (param) { |
| this.messageCenter.dispatch(ecConfig.EVENT.LEGEND_HOVERLINK, param.event, { target: param.target._name }, this.myChart); |
| return; |
| }, |
| refresh: function (newOption) { |
| if (newOption) { |
| this.option = newOption || this.option; |
| this.option.legend = this.reformOption(this.option.legend); |
| this.legendOption = this.option.legend; |
| var data = this.legendOption.data || []; |
| var itemName; |
| var something; |
| var color; |
| var queryTarget; |
| if (this.legendOption.selected) { |
| for (var k in this.legendOption.selected) { |
| this._selectedMap[k] = typeof this._selectedMap[k] != 'undefined' ? this._selectedMap[k] : this.legendOption.selected[k]; |
| } |
| } |
| for (var i = 0, dataLength = data.length; i < dataLength; i++) { |
| itemName = this._getName(data[i]); |
| if (itemName === '') { |
| continue; |
| } |
| something = this._getSomethingByName(itemName); |
| if (!something.series) { |
| this._hasDataMap[itemName] = false; |
| } else { |
| this._hasDataMap[itemName] = true; |
| if (something.data && (something.type === ecConfig.CHART_TYPE_PIE || something.type === ecConfig.CHART_TYPE_FORCE || something.type === ecConfig.CHART_TYPE_FUNNEL)) { |
| queryTarget = [ |
| something.data, |
| something.series |
| ]; |
| } else { |
| queryTarget = [something.series]; |
| } |
| color = this.getItemStyleColor(this.deepQuery(queryTarget, 'itemStyle.normal.color'), something.seriesIndex, something.dataIndex, something.data); |
| if (color && something.type != ecConfig.CHART_TYPE_K) { |
| this.setColor(itemName, color); |
| } |
| this._selectedMap[itemName] = this._selectedMap[itemName] != null ? this._selectedMap[itemName] : true; |
| } |
| } |
| } |
| this.clear(); |
| this._buildShape(); |
| }, |
| getRelatedAmount: function (name) { |
| var amount = 0; |
| var series = this.option.series; |
| var data; |
| for (var i = 0, l = series.length; i < l; i++) { |
| if (series[i].name === name) { |
| amount++; |
| } |
| if (series[i].type === ecConfig.CHART_TYPE_PIE || series[i].type === ecConfig.CHART_TYPE_RADAR || series[i].type === ecConfig.CHART_TYPE_CHORD || series[i].type === ecConfig.CHART_TYPE_FORCE || series[i].type === ecConfig.CHART_TYPE_FUNNEL) { |
| data = series[i].type != ecConfig.CHART_TYPE_FORCE ? series[i].data : series[i].categories; |
| for (var j = 0, k = data.length; j < k; j++) { |
| if (data[j].name === name && data[j].value != '-') { |
| amount++; |
| } |
| } |
| } |
| } |
| return amount; |
| }, |
| setColor: function (legendName, color) { |
| this._colorMap[legendName] = color; |
| }, |
| getColor: function (legendName) { |
| if (!this._colorMap[legendName]) { |
| this._colorMap[legendName] = this.zr.getColor(this._colorIndex++); |
| } |
| return this._colorMap[legendName]; |
| }, |
| hasColor: function (legendName) { |
| return this._colorMap[legendName] ? this._colorMap[legendName] : false; |
| }, |
| add: function (name, color) { |
| var data = this.legendOption.data; |
| for (var i = 0, dataLength = data.length; i < dataLength; i++) { |
| if (this._getName(data[i]) === name) { |
| return; |
| } |
| } |
| this.legendOption.data.push(name); |
| this.setColor(name, color); |
| this._selectedMap[name] = true; |
| this._hasDataMap[name] = true; |
| }, |
| del: function (name) { |
| var data = this.legendOption.data; |
| for (var i = 0, dataLength = data.length; i < dataLength; i++) { |
| if (this._getName(data[i]) === name) { |
| return this.legendOption.data.splice(i, 1); |
| } |
| } |
| }, |
| getItemShape: function (name) { |
| if (name == null) { |
| return; |
| } |
| var shape; |
| for (var i = 0, l = this.shapeList.length; i < l; i++) { |
| shape = this.shapeList[i]; |
| if (shape._name === name && shape.type != 'text') { |
| return shape; |
| } |
| } |
| }, |
| setItemShape: function (name, itemShape) { |
| var shape; |
| for (var i = 0, l = this.shapeList.length; i < l; i++) { |
| shape = this.shapeList[i]; |
| if (shape._name === name && shape.type != 'text') { |
| if (!this._selectedMap[name]) { |
| itemShape.style.color = '#ccc'; |
| itemShape.style.strokeColor = '#ccc'; |
| } |
| this.zr.modShape(shape.id, itemShape); |
| } |
| } |
| }, |
| isSelected: function (itemName) { |
| if (typeof this._selectedMap[itemName] != 'undefined') { |
| return this._selectedMap[itemName]; |
| } else { |
| return true; |
| } |
| }, |
| getSelectedMap: function () { |
| return this._selectedMap; |
| }, |
| setSelected: function (itemName, selectStatus) { |
| if (this.legendOption.selectedMode === 'single') { |
| for (var k in this._selectedMap) { |
| this._selectedMap[k] = false; |
| } |
| } |
| this._selectedMap[itemName] = selectStatus; |
| this.messageCenter.dispatch(ecConfig.EVENT.LEGEND_SELECTED, null, { |
| selected: this._selectedMap, |
| target: itemName |
| }, this.myChart); |
| }, |
| onlegendSelected: function (param, status) { |
| var legendSelected = param.selected; |
| for (var itemName in legendSelected) { |
| if (this._selectedMap[itemName] != legendSelected[itemName]) { |
| status.needRefresh = true; |
| } |
| this._selectedMap[itemName] = legendSelected[itemName]; |
| } |
| return; |
| } |
| }; |
| var legendIcon = { |
| line: function (ctx, style) { |
| var dy = style.height / 2; |
| ctx.moveTo(style.x, style.y + dy); |
| ctx.lineTo(style.x + style.width, style.y + dy); |
| }, |
| pie: function (ctx, style) { |
| var x = style.x; |
| var y = style.y; |
| var width = style.width; |
| var height = style.height; |
| SectorShape.prototype.buildPath(ctx, { |
| x: x + width / 2, |
| y: y + height + 2, |
| r: height + 2, |
| r0: 6, |
| startAngle: 45, |
| endAngle: 135 |
| }); |
| }, |
| eventRiver: function (ctx, style) { |
| var x = style.x; |
| var y = style.y; |
| var width = style.width; |
| var height = style.height; |
| ctx.moveTo(x, y + height); |
| ctx.bezierCurveTo(x + width, y + height, x, y + 4, x + width, y + 4); |
| ctx.lineTo(x + width, y); |
| ctx.bezierCurveTo(x, y, x + width, y + height - 4, x, y + height - 4); |
| ctx.lineTo(x, y + height); |
| }, |
| k: function (ctx, style) { |
| var x = style.x; |
| var y = style.y; |
| var width = style.width; |
| var height = style.height; |
| CandleShape.prototype.buildPath(ctx, { |
| x: x + width / 2, |
| y: [ |
| y + 1, |
| y + 1, |
| y + height - 6, |
| y + height |
| ], |
| width: width - 6 |
| }); |
| }, |
| bar: function (ctx, style) { |
| var x = style.x; |
| var y = style.y + 1; |
| var width = style.width; |
| var height = style.height - 2; |
| var r = 3; |
| ctx.moveTo(x + r, y); |
| ctx.lineTo(x + width - r, y); |
| ctx.quadraticCurveTo(x + width, y, x + width, y + r); |
| ctx.lineTo(x + width, y + height - r); |
| ctx.quadraticCurveTo(x + width, y + height, x + width - r, y + height); |
| ctx.lineTo(x + r, y + height); |
| ctx.quadraticCurveTo(x, y + height, x, y + height - r); |
| ctx.lineTo(x, y + r); |
| ctx.quadraticCurveTo(x, y, x + r, y); |
| }, |
| force: function (ctx, style) { |
| IconShape.prototype.iconLibrary.circle(ctx, style); |
| }, |
| radar: function (ctx, style) { |
| var n = 6; |
| var x = style.x + style.width / 2; |
| var y = style.y + style.height / 2; |
| var r = style.height / 2; |
| var dStep = 2 * Math.PI / n; |
| var deg = -Math.PI / 2; |
| var xStart = x + r * Math.cos(deg); |
| var yStart = y + r * Math.sin(deg); |
| ctx.moveTo(xStart, yStart); |
| deg += dStep; |
| for (var i = 0, end = n - 1; i < end; i++) { |
| ctx.lineTo(x + r * Math.cos(deg), y + r * Math.sin(deg)); |
| deg += dStep; |
| } |
| ctx.lineTo(xStart, yStart); |
| } |
| }; |
| legendIcon.chord = legendIcon.pie; |
| legendIcon.map = legendIcon.bar; |
| for (var k in legendIcon) { |
| IconShape.prototype.iconLibrary['legendicon' + k] = legendIcon[k]; |
| } |
| zrUtil.inherits(Legend, Base); |
| require('../component').define('legend', Legend); |
| return Legend; |
| });define('echarts/util/ecData', [], function () { |
| function pack(shape, series, seriesIndex, data, dataIndex, name, special, special2) { |
| var value; |
| if (typeof data != 'undefined') { |
| value = data.value == null ? data : data.value; |
| } |
| shape._echartsData = { |
| '_series': series, |
| '_seriesIndex': seriesIndex, |
| '_data': data, |
| '_dataIndex': dataIndex, |
| '_name': name, |
| '_value': value, |
| '_special': special, |
| '_special2': special2 |
| }; |
| return shape._echartsData; |
| } |
| function get(shape, key) { |
| var data = shape._echartsData; |
| if (!key) { |
| return data; |
| } |
| switch (key) { |
| case 'series': |
| case 'seriesIndex': |
| case 'data': |
| case 'dataIndex': |
| case 'name': |
| case 'value': |
| case 'special': |
| case 'special2': |
| return data && data['_' + key]; |
| } |
| return null; |
| } |
| function set(shape, key, value) { |
| shape._echartsData = shape._echartsData || {}; |
| switch (key) { |
| case 'series': |
| case 'seriesIndex': |
| case 'data': |
| case 'dataIndex': |
| case 'name': |
| case 'value': |
| case 'special': |
| case 'special2': |
| shape._echartsData['_' + key] = value; |
| break; |
| } |
| } |
| function clone(source, target) { |
| target._echartsData = { |
| '_series': source._echartsData._series, |
| '_seriesIndex': source._echartsData._seriesIndex, |
| '_data': source._echartsData._data, |
| '_dataIndex': source._echartsData._dataIndex, |
| '_name': source._echartsData._name, |
| '_value': source._echartsData._value, |
| '_special': source._echartsData._special, |
| '_special2': source._echartsData._special2 |
| }; |
| } |
| return { |
| pack: pack, |
| set: set, |
| get: get, |
| clone: clone |
| }; |
| });define('echarts/chart', [], function () { |
| var self = {}; |
| var _chartLibrary = {}; |
| self.define = function (name, clazz) { |
| _chartLibrary[name] = clazz; |
| return self; |
| }; |
| self.get = function (name) { |
| return _chartLibrary[name]; |
| }; |
| return self; |
| });define('zrender/tool/color', [ |
| 'require', |
| '../tool/util' |
| ], function (require) { |
| var util = require('../tool/util'); |
| var _ctx; |
| var palette = [ |
| '#ff9277', |
| ' #dddd00', |
| ' #ffc877', |
| ' #bbe3ff', |
| ' #d5ffbb', |
| '#bbbbff', |
| ' #ddb000', |
| ' #b0dd00', |
| ' #e2bbff', |
| ' #ffbbe3', |
| '#ff7777', |
| ' #ff9900', |
| ' #83dd00', |
| ' #77e3ff', |
| ' #778fff', |
| '#c877ff', |
| ' #ff77ab', |
| ' #ff6600', |
| ' #aa8800', |
| ' #77c7ff', |
| '#ad77ff', |
| ' #ff77ff', |
| ' #dd0083', |
| ' #777700', |
| ' #00aa00', |
| '#0088aa', |
| ' #8400dd', |
| ' #aa0088', |
| ' #dd0000', |
| ' #772e00' |
| ]; |
| var _palette = palette; |
| var highlightColor = 'rgba(255,255,0,0.5)'; |
| var _highlightColor = highlightColor; |
| var colorRegExp = /^\s*((#[a-f\d]{6})|(#[a-f\d]{3})|rgba?\(\s*([\d\.]+%?\s*,\s*[\d\.]+%?\s*,\s*[\d\.]+%?(?:\s*,\s*[\d\.]+%?)?)\s*\)|hsba?\(\s*([\d\.]+(?:deg|\xb0|%)?\s*,\s*[\d\.]+%?\s*,\s*[\d\.]+%?(?:\s*,\s*[\d\.]+)?)%?\s*\)|hsla?\(\s*([\d\.]+(?:deg|\xb0|%)?\s*,\s*[\d\.]+%?\s*,\s*[\d\.]+%?(?:\s*,\s*[\d\.]+)?)%?\s*\))\s*$/i; |
| var _nameColors = { |
| aliceblue: '#f0f8ff', |
| antiquewhite: '#faebd7', |
| aqua: '#0ff', |
| aquamarine: '#7fffd4', |
| azure: '#f0ffff', |
| beige: '#f5f5dc', |
| bisque: '#ffe4c4', |
| black: '#000', |
| blanchedalmond: '#ffebcd', |
| blue: '#00f', |
| blueviolet: '#8a2be2', |
| brown: '#a52a2a', |
| burlywood: '#deb887', |
| cadetblue: '#5f9ea0', |
| chartreuse: '#7fff00', |
| chocolate: '#d2691e', |
| coral: '#ff7f50', |
| cornflowerblue: '#6495ed', |
| cornsilk: '#fff8dc', |
| crimson: '#dc143c', |
| cyan: '#0ff', |
| darkblue: '#00008b', |
| darkcyan: '#008b8b', |
| darkgoldenrod: '#b8860b', |
| darkgray: '#a9a9a9', |
| darkgrey: '#a9a9a9', |
| darkgreen: '#006400', |
| darkkhaki: '#bdb76b', |
| darkmagenta: '#8b008b', |
| darkolivegreen: '#556b2f', |
| darkorange: '#ff8c00', |
| darkorchid: '#9932cc', |
| darkred: '#8b0000', |
| darksalmon: '#e9967a', |
| darkseagreen: '#8fbc8f', |
| darkslateblue: '#483d8b', |
| darkslategray: '#2f4f4f', |
| darkslategrey: '#2f4f4f', |
| darkturquoise: '#00ced1', |
| darkviolet: '#9400d3', |
| deeppink: '#ff1493', |
| deepskyblue: '#00bfff', |
| dimgray: '#696969', |
| dimgrey: '#696969', |
| dodgerblue: '#1e90ff', |
| firebrick: '#b22222', |
| floralwhite: '#fffaf0', |
| forestgreen: '#228b22', |
| fuchsia: '#f0f', |
| gainsboro: '#dcdcdc', |
| ghostwhite: '#f8f8ff', |
| gold: '#ffd700', |
| goldenrod: '#daa520', |
| gray: '#808080', |
| grey: '#808080', |
| green: '#008000', |
| greenyellow: '#adff2f', |
| honeydew: '#f0fff0', |
| hotpink: '#ff69b4', |
| indianred: '#cd5c5c', |
| indigo: '#4b0082', |
| ivory: '#fffff0', |
| khaki: '#f0e68c', |
| lavender: '#e6e6fa', |
| lavenderblush: '#fff0f5', |
| lawngreen: '#7cfc00', |
| lemonchiffon: '#fffacd', |
| lightblue: '#add8e6', |
| lightcoral: '#f08080', |
| lightcyan: '#e0ffff', |
| lightgoldenrodyellow: '#fafad2', |
| lightgray: '#d3d3d3', |
| lightgrey: '#d3d3d3', |
| lightgreen: '#90ee90', |
| lightpink: '#ffb6c1', |
| lightsalmon: '#ffa07a', |
| lightseagreen: '#20b2aa', |
| lightskyblue: '#87cefa', |
| lightslategray: '#789', |
| lightslategrey: '#789', |
| lightsteelblue: '#b0c4de', |
| lightyellow: '#ffffe0', |
| lime: '#0f0', |
| limegreen: '#32cd32', |
| linen: '#faf0e6', |
| magenta: '#f0f', |
| maroon: '#800000', |
| mediumaquamarine: '#66cdaa', |
| mediumblue: '#0000cd', |
| mediumorchid: '#ba55d3', |
| mediumpurple: '#9370d8', |
| mediumseagreen: '#3cb371', |
| mediumslateblue: '#7b68ee', |
| mediumspringgreen: '#00fa9a', |
| mediumturquoise: '#48d1cc', |
| mediumvioletred: '#c71585', |
| midnightblue: '#191970', |
| mintcream: '#f5fffa', |
| mistyrose: '#ffe4e1', |
| moccasin: '#ffe4b5', |
| navajowhite: '#ffdead', |
| navy: '#000080', |
| oldlace: '#fdf5e6', |
| olive: '#808000', |
| olivedrab: '#6b8e23', |
| orange: '#ffa500', |
| orangered: '#ff4500', |
| orchid: '#da70d6', |
| palegoldenrod: '#eee8aa', |
| palegreen: '#98fb98', |
| paleturquoise: '#afeeee', |
| palevioletred: '#d87093', |
| papayawhip: '#ffefd5', |
| peachpuff: '#ffdab9', |
| peru: '#cd853f', |
| pink: '#ffc0cb', |
| plum: '#dda0dd', |
| powderblue: '#b0e0e6', |
| purple: '#800080', |
| red: '#f00', |
| rosybrown: '#bc8f8f', |
| royalblue: '#4169e1', |
| saddlebrown: '#8b4513', |
| salmon: '#fa8072', |
| sandybrown: '#f4a460', |
| seagreen: '#2e8b57', |
| seashell: '#fff5ee', |
| sienna: '#a0522d', |
| silver: '#c0c0c0', |
| skyblue: '#87ceeb', |
| slateblue: '#6a5acd', |
| slategray: '#708090', |
| slategrey: '#708090', |
| snow: '#fffafa', |
| springgreen: '#00ff7f', |
| steelblue: '#4682b4', |
| tan: '#d2b48c', |
| teal: '#008080', |
| thistle: '#d8bfd8', |
| tomato: '#ff6347', |
| turquoise: '#40e0d0', |
| violet: '#ee82ee', |
| wheat: '#f5deb3', |
| white: '#fff', |
| whitesmoke: '#f5f5f5', |
| yellow: '#ff0', |
| yellowgreen: '#9acd32' |
| }; |
| function customPalette(userPalete) { |
| palette = userPalete; |
| } |
| function resetPalette() { |
| palette = _palette; |
| } |
| function getColor(idx, userPalete) { |
| idx = idx | 0; |
| userPalete = userPalete || palette; |
| return userPalete[idx % userPalete.length]; |
| } |
| function customHighlight(userHighlightColor) { |
| highlightColor = userHighlightColor; |
| } |
| function resetHighlight() { |
| _highlightColor = highlightColor; |
| } |
| function getHighlightColor() { |
| return highlightColor; |
| } |
| function getRadialGradient(x0, y0, r0, x1, y1, r1, colorList) { |
| if (!_ctx) { |
| _ctx = util.getContext(); |
| } |
| var gradient = _ctx.createRadialGradient(x0, y0, r0, x1, y1, r1); |
| for (var i = 0, l = colorList.length; i < l; i++) { |
| gradient.addColorStop(colorList[i][0], colorList[i][1]); |
| } |
| gradient.__nonRecursion = true; |
| return gradient; |
| } |
| function getLinearGradient(x0, y0, x1, y1, colorList) { |
| if (!_ctx) { |
| _ctx = util.getContext(); |
| } |
| var gradient = _ctx.createLinearGradient(x0, y0, x1, y1); |
| for (var i = 0, l = colorList.length; i < l; i++) { |
| gradient.addColorStop(colorList[i][0], colorList[i][1]); |
| } |
| gradient.__nonRecursion = true; |
| return gradient; |
| } |
| function getStepColors(start, end, step) { |
| start = toRGBA(start); |
| end = toRGBA(end); |
| start = getData(start); |
| end = getData(end); |
| var colors = []; |
| var stepR = (end[0] - start[0]) / step; |
| var stepG = (end[1] - start[1]) / step; |
| var stepB = (end[2] - start[2]) / step; |
| var stepA = (end[3] - start[3]) / step; |
| for (var i = 0, r = start[0], g = start[1], b = start[2], a = start[3]; i < step; i++) { |
| colors[i] = toColor([ |
| adjust(Math.floor(r), [ |
| 0, |
| 255 |
| ]), |
| adjust(Math.floor(g), [ |
| 0, |
| 255 |
| ]), |
| adjust(Math.floor(b), [ |
| 0, |
| 255 |
| ]), |
| a.toFixed(4) - 0 |
| ], 'rgba'); |
| r += stepR; |
| g += stepG; |
| b += stepB; |
| a += stepA; |
| } |
| r = end[0]; |
| g = end[1]; |
| b = end[2]; |
| a = end[3]; |
| colors[i] = toColor([ |
| r, |
| g, |
| b, |
| a |
| ], 'rgba'); |
| return colors; |
| } |
| function getGradientColors(colors, step) { |
| var ret = []; |
| var len = colors.length; |
| if (step === undefined) { |
| step = 20; |
| } |
| if (len === 1) { |
| ret = getStepColors(colors[0], colors[0], step); |
| } else if (len > 1) { |
| for (var i = 0, n = len - 1; i < n; i++) { |
| var steps = getStepColors(colors[i], colors[i + 1], step); |
| if (i < n - 1) { |
| steps.pop(); |
| } |
| ret = ret.concat(steps); |
| } |
| } |
| return ret; |
| } |
| function toColor(data, format) { |
| format = format || 'rgb'; |
| if (data && (data.length === 3 || data.length === 4)) { |
| data = map(data, function (c) { |
| return c > 1 ? Math.ceil(c) : c; |
| }); |
| if (format.indexOf('hex') > -1) { |
| return '#' + ((1 << 24) + (data[0] << 16) + (data[1] << 8) + +data[2]).toString(16).slice(1); |
| } else if (format.indexOf('hs') > -1) { |
| var sx = map(data.slice(1, 3), function (c) { |
| return c + '%'; |
| }); |
| data[1] = sx[0]; |
| data[2] = sx[1]; |
| } |
| if (format.indexOf('a') > -1) { |
| if (data.length === 3) { |
| data.push(1); |
| } |
| data[3] = adjust(data[3], [ |
| 0, |
| 1 |
| ]); |
| return format + '(' + data.slice(0, 4).join(',') + ')'; |
| } |
| return format + '(' + data.slice(0, 3).join(',') + ')'; |
| } |
| } |
| function toArray(color) { |
| color = trim(color); |
| if (color.indexOf('rgba') < 0) { |
| color = toRGBA(color); |
| } |
| var data = []; |
| var i = 0; |
| color.replace(/[\d.]+/g, function (n) { |
| if (i < 3) { |
| n = n | 0; |
| } else { |
| n = +n; |
| } |
| data[i++] = n; |
| }); |
| return data; |
| } |
| function convert(color, format) { |
| if (!isCalculableColor(color)) { |
| return color; |
| } |
| var data = getData(color); |
| var alpha = data[3]; |
| if (typeof alpha === 'undefined') { |
| alpha = 1; |
| } |
| if (color.indexOf('hsb') > -1) { |
| data = _HSV_2_RGB(data); |
| } else if (color.indexOf('hsl') > -1) { |
| data = _HSL_2_RGB(data); |
| } |
| if (format.indexOf('hsb') > -1 || format.indexOf('hsv') > -1) { |
| data = _RGB_2_HSB(data); |
| } else if (format.indexOf('hsl') > -1) { |
| data = _RGB_2_HSL(data); |
| } |
| data[3] = alpha; |
| return toColor(data, format); |
| } |
| function toRGBA(color) { |
| return convert(color, 'rgba'); |
| } |
| function toRGB(color) { |
| return convert(color, 'rgb'); |
| } |
| function toHex(color) { |
| return convert(color, 'hex'); |
| } |
| function toHSVA(color) { |
| return convert(color, 'hsva'); |
| } |
| function toHSV(color) { |
| return convert(color, 'hsv'); |
| } |
| function toHSBA(color) { |
| return convert(color, 'hsba'); |
| } |
| function toHSB(color) { |
| return convert(color, 'hsb'); |
| } |
| function toHSLA(color) { |
| return convert(color, 'hsla'); |
| } |
| function toHSL(color) { |
| return convert(color, 'hsl'); |
| } |
| function toName(color) { |
| for (var key in _nameColors) { |
| if (toHex(_nameColors[key]) === toHex(color)) { |
| return key; |
| } |
| } |
| return null; |
| } |
| function trim(color) { |
| return String(color).replace(/\s+/g, ''); |
| } |
| function normalize(color) { |
| if (_nameColors[color]) { |
| color = _nameColors[color]; |
| } |
| color = trim(color); |
| color = color.replace(/hsv/i, 'hsb'); |
| if (/^#[\da-f]{3}$/i.test(color)) { |
| color = parseInt(color.slice(1), 16); |
| var r = (color & 3840) << 8; |
| var g = (color & 240) << 4; |
| var b = color & 15; |
| color = '#' + ((1 << 24) + (r << 4) + r + (g << 4) + g + (b << 4) + b).toString(16).slice(1); |
| } |
| return color; |
| } |
| function lift(color, level) { |
| if (!isCalculableColor(color)) { |
| return color; |
| } |
| var direct = level > 0 ? 1 : -1; |
| if (typeof level === 'undefined') { |
| level = 0; |
| } |
| level = Math.abs(level) > 1 ? 1 : Math.abs(level); |
| color = toRGB(color); |
| var data = getData(color); |
| for (var i = 0; i < 3; i++) { |
| if (direct === 1) { |
| data[i] = data[i] * (1 - level) | 0; |
| } else { |
| data[i] = (255 - data[i]) * level + data[i] | 0; |
| } |
| } |
| return 'rgb(' + data.join(',') + ')'; |
| } |
| function reverse(color) { |
| if (!isCalculableColor(color)) { |
| return color; |
| } |
| var data = getData(toRGBA(color)); |
| data = map(data, function (c) { |
| return 255 - c; |
| }); |
| return toColor(data, 'rgb'); |
| } |
| function mix(color1, color2, weight) { |
| if (!isCalculableColor(color1) || !isCalculableColor(color2)) { |
| return color1; |
| } |
| if (typeof weight === 'undefined') { |
| weight = 0.5; |
| } |
| weight = 1 - adjust(weight, [ |
| 0, |
| 1 |
| ]); |
| var w = weight * 2 - 1; |
| var data1 = getData(toRGBA(color1)); |
| var data2 = getData(toRGBA(color2)); |
| var d = data1[3] - data2[3]; |
| var weight1 = ((w * d === -1 ? w : (w + d) / (1 + w * d)) + 1) / 2; |
| var weight2 = 1 - weight1; |
| var data = []; |
| for (var i = 0; i < 3; i++) { |
| data[i] = data1[i] * weight1 + data2[i] * weight2; |
| } |
| var alpha = data1[3] * weight + data2[3] * (1 - weight); |
| alpha = Math.max(0, Math.min(1, alpha)); |
| if (data1[3] === 1 && data2[3] === 1) { |
| return toColor(data, 'rgb'); |
| } |
| data[3] = alpha; |
| return toColor(data, 'rgba'); |
| } |
| function random() { |
| return '#' + (Math.random().toString(16) + '0000').slice(2, 8); |
| } |
| function getData(color) { |
| color = normalize(color); |
| var r = color.match(colorRegExp); |
| if (r === null) { |
| throw new Error('The color format error'); |
| } |
| var d; |
| var a; |
| var data = []; |
| var rgb; |
| if (r[2]) { |
| d = r[2].replace('#', '').split(''); |
| rgb = [ |
| d[0] + d[1], |
| d[2] + d[3], |
| d[4] + d[5] |
| ]; |
| data = map(rgb, function (c) { |
| return adjust(parseInt(c, 16), [ |
| 0, |
| 255 |
| ]); |
| }); |
| } else if (r[4]) { |
| var rgba = r[4].split(','); |
| a = rgba[3]; |
| rgb = rgba.slice(0, 3); |
| data = map(rgb, function (c) { |
| c = Math.floor(c.indexOf('%') > 0 ? parseInt(c, 0) * 2.55 : c); |
| return adjust(c, [ |
| 0, |
| 255 |
| ]); |
| }); |
| if (typeof a !== 'undefined') { |
| data.push(adjust(parseFloat(a), [ |
| 0, |
| 1 |
| ])); |
| } |
| } else if (r[5] || r[6]) { |
| var hsxa = (r[5] || r[6]).split(','); |
| var h = parseInt(hsxa[0], 0) / 360; |
| var s = hsxa[1]; |
| var x = hsxa[2]; |
| a = hsxa[3]; |
| data = map([ |
| s, |
| x |
| ], function (c) { |
| return adjust(parseFloat(c) / 100, [ |
| 0, |
| 1 |
| ]); |
| }); |
| data.unshift(h); |
| if (typeof a !== 'undefined') { |
| data.push(adjust(parseFloat(a), [ |
| 0, |
| 1 |
| ])); |
| } |
| } |
| return data; |
| } |
| function alpha(color, a) { |
| if (!isCalculableColor(color)) { |
| return color; |
| } |
| if (a === null) { |
| a = 1; |
| } |
| var data = getData(toRGBA(color)); |
| data[3] = adjust(Number(a).toFixed(4), [ |
| 0, |
| 1 |
| ]); |
| return toColor(data, 'rgba'); |
| } |
| function map(array, fun) { |
| if (typeof fun !== 'function') { |
| throw new TypeError(); |
| } |
| var len = array ? array.length : 0; |
| for (var i = 0; i < len; i++) { |
| array[i] = fun(array[i]); |
| } |
| return array; |
| } |
| function adjust(value, region) { |
| if (value <= region[0]) { |
| value = region[0]; |
| } else if (value >= region[1]) { |
| value = region[1]; |
| } |
| return value; |
| } |
| function isCalculableColor(color) { |
| return color instanceof Array || typeof color === 'string'; |
| } |
| function _HSV_2_RGB(data) { |
| var H = data[0]; |
| var S = data[1]; |
| var V = data[2]; |
| var R; |
| var G; |
| var B; |
| if (S === 0) { |
| R = V * 255; |
| G = V * 255; |
| B = V * 255; |
| } else { |
| var h = H * 6; |
| if (h === 6) { |
| h = 0; |
| } |
| var i = h | 0; |
| var v1 = V * (1 - S); |
| var v2 = V * (1 - S * (h - i)); |
| var v3 = V * (1 - S * (1 - (h - i))); |
| var r = 0; |
| var g = 0; |
| var b = 0; |
| if (i === 0) { |
| r = V; |
| g = v3; |
| b = v1; |
| } else if (i === 1) { |
| r = v2; |
| g = V; |
| b = v1; |
| } else if (i === 2) { |
| r = v1; |
| g = V; |
| b = v3; |
| } else if (i === 3) { |
| r = v1; |
| g = v2; |
| b = V; |
| } else if (i === 4) { |
| r = v3; |
| g = v1; |
| b = V; |
| } else { |
| r = V; |
| g = v1; |
| b = v2; |
| } |
| R = r * 255; |
| G = g * 255; |
| B = b * 255; |
| } |
| return [ |
| R, |
| G, |
| B |
| ]; |
| } |
| function _HSL_2_RGB(data) { |
| var H = data[0]; |
| var S = data[1]; |
| var L = data[2]; |
| var R; |
| var G; |
| var B; |
| if (S === 0) { |
| R = L * 255; |
| G = L * 255; |
| B = L * 255; |
| } else { |
| var v2; |
| if (L < 0.5) { |
| v2 = L * (1 + S); |
| } else { |
| v2 = L + S - S * L; |
| } |
| var v1 = 2 * L - v2; |
| R = 255 * _HUE_2_RGB(v1, v2, H + 1 / 3); |
| G = 255 * _HUE_2_RGB(v1, v2, H); |
| B = 255 * _HUE_2_RGB(v1, v2, H - 1 / 3); |
| } |
| return [ |
| R, |
| G, |
| B |
| ]; |
| } |
| function _HUE_2_RGB(v1, v2, vH) { |
| if (vH < 0) { |
| vH += 1; |
| } |
| if (vH > 1) { |
| vH -= 1; |
| } |
| if (6 * vH < 1) { |
| return v1 + (v2 - v1) * 6 * vH; |
| } |
| if (2 * vH < 1) { |
| return v2; |
| } |
| if (3 * vH < 2) { |
| return v1 + (v2 - v1) * (2 / 3 - vH) * 6; |
| } |
| return v1; |
| } |
| function _RGB_2_HSB(data) { |
| var R = data[0] / 255; |
| var G = data[1] / 255; |
| var B = data[2] / 255; |
| var vMin = Math.min(R, G, B); |
| var vMax = Math.max(R, G, B); |
| var delta = vMax - vMin; |
| var V = vMax; |
| var H; |
| var S; |
| if (delta === 0) { |
| H = 0; |
| S = 0; |
| } else { |
| S = delta / vMax; |
| var deltaR = ((vMax - R) / 6 + delta / 2) / delta; |
| var deltaG = ((vMax - G) / 6 + delta / 2) / delta; |
| var deltaB = ((vMax - B) / 6 + delta / 2) / delta; |
| if (R === vMax) { |
| H = deltaB - deltaG; |
| } else if (G === vMax) { |
| H = 1 / 3 + deltaR - deltaB; |
| } else if (B === vMax) { |
| H = 2 / 3 + deltaG - deltaR; |
| } |
| if (H < 0) { |
| H += 1; |
| } |
| if (H > 1) { |
| H -= 1; |
| } |
| } |
| H = H * 360; |
| S = S * 100; |
| V = V * 100; |
| return [ |
| H, |
| S, |
| V |
| ]; |
| } |
| function _RGB_2_HSL(data) { |
| var R = data[0] / 255; |
| var G = data[1] / 255; |
| var B = data[2] / 255; |
| var vMin = Math.min(R, G, B); |
| var vMax = Math.max(R, G, B); |
| var delta = vMax - vMin; |
| var L = (vMax + vMin) / 2; |
| var H; |
| var S; |
| if (delta === 0) { |
| H = 0; |
| S = 0; |
| } else { |
| if (L < 0.5) { |
| S = delta / (vMax + vMin); |
| } else { |
| S = delta / (2 - vMax - vMin); |
| } |
| var deltaR = ((vMax - R) / 6 + delta / 2) / delta; |
| var deltaG = ((vMax - G) / 6 + delta / 2) / delta; |
| var deltaB = ((vMax - B) / 6 + delta / 2) / delta; |
| if (R === vMax) { |
| H = deltaB - deltaG; |
| } else if (G === vMax) { |
| H = 1 / 3 + deltaR - deltaB; |
| } else if (B === vMax) { |
| H = 2 / 3 + deltaG - deltaR; |
| } |
| if (H < 0) { |
| H += 1; |
| } |
| if (H > 1) { |
| H -= 1; |
| } |
| } |
| H = H * 360; |
| S = S * 100; |
| L = L * 100; |
| return [ |
| H, |
| S, |
| L |
| ]; |
| } |
| return { |
| customPalette: customPalette, |
| resetPalette: resetPalette, |
| getColor: getColor, |
| getHighlightColor: getHighlightColor, |
| customHighlight: customHighlight, |
| resetHighlight: resetHighlight, |
| getRadialGradient: getRadialGradient, |
| getLinearGradient: getLinearGradient, |
| getGradientColors: getGradientColors, |
| getStepColors: getStepColors, |
| reverse: reverse, |
| mix: mix, |
| lift: lift, |
| trim: trim, |
| random: random, |
| toRGB: toRGB, |
| toRGBA: toRGBA, |
| toHex: toHex, |
| toHSL: toHSL, |
| toHSLA: toHSLA, |
| toHSB: toHSB, |
| toHSBA: toHSBA, |
| toHSV: toHSV, |
| toHSVA: toHSVA, |
| toName: toName, |
| toColor: toColor, |
| toArray: toArray, |
| alpha: alpha, |
| getData: getData |
| }; |
| });define('echarts/component/timeline', [ |
| 'require', |
| './base', |
| 'zrender/shape/Rectangle', |
| '../util/shape/Icon', |
| '../util/shape/Chain', |
| '../config', |
| 'zrender/tool/util', |
| 'zrender/tool/area', |
| 'zrender/tool/event', |
| '../component' |
| ], function (require) { |
| var Base = require('./base'); |
| var RectangleShape = require('zrender/shape/Rectangle'); |
| var IconShape = require('../util/shape/Icon'); |
| var ChainShape = require('../util/shape/Chain'); |
| var ecConfig = require('../config'); |
| var zrUtil = require('zrender/tool/util'); |
| var zrArea = require('zrender/tool/area'); |
| var zrEvent = require('zrender/tool/event'); |
| function Timeline(ecTheme, messageCenter, zr, option, myChart) { |
| Base.call(this, ecTheme, messageCenter, zr, option, myChart); |
| var self = this; |
| self._onclick = function (param) { |
| return self.__onclick(param); |
| }; |
| self._ondrift = function (dx, dy) { |
| return self.__ondrift(this, dx, dy); |
| }; |
| self._ondragend = function () { |
| return self.__ondragend(); |
| }; |
| self._setCurrentOption = function () { |
| var timelineOption = self.timelineOption; |
| self.currentIndex %= timelineOption.data.length; |
| var curOption = self.options[self.currentIndex] || {}; |
| self.myChart.setOption(curOption, timelineOption.notMerge); |
| self.messageCenter.dispatch(ecConfig.EVENT.TIMELINE_CHANGED, null, { |
| currentIndex: self.currentIndex, |
| data: timelineOption.data[self.currentIndex].name != null ? timelineOption.data[self.currentIndex].name : timelineOption.data[self.currentIndex] |
| }, self.myChart); |
| }; |
| self._onFrame = function () { |
| self._setCurrentOption(); |
| self._syncHandleShape(); |
| if (self.timelineOption.autoPlay) { |
| self.playTicket = setTimeout(function () { |
| self.currentIndex += 1; |
| if (!self.timelineOption.loop && self.currentIndex >= self.timelineOption.data.length) { |
| self.currentIndex = self.timelineOption.data.length - 1; |
| self.stop(); |
| return; |
| } |
| self._onFrame(); |
| }, self.timelineOption.playInterval); |
| } |
| }; |
| this.setTheme(false); |
| this.options = this.option.options; |
| this.currentIndex = this.timelineOption.currentIndex % this.timelineOption.data.length; |
| if (!this.timelineOption.notMerge && this.currentIndex !== 0) { |
| this.options[this.currentIndex] = zrUtil.merge(this.options[this.currentIndex], this.options[0]); |
| } |
| if (this.timelineOption.show) { |
| this._buildShape(); |
| this._syncHandleShape(); |
| } |
| this._setCurrentOption(); |
| if (this.timelineOption.autoPlay) { |
| var self = this; |
| this.playTicket = setTimeout(function () { |
| self.play(); |
| }, this.ecTheme.animationDuration); |
| } |
| } |
| Timeline.prototype = { |
| type: ecConfig.COMPONENT_TYPE_TIMELINE, |
| _buildShape: function () { |
| this._location = this._getLocation(); |
| this._buildBackground(); |
| this._buildControl(); |
| this._chainPoint = this._getChainPoint(); |
| if (this.timelineOption.label.show) { |
| var interval = this._getInterval(); |
| for (var i = 0, len = this._chainPoint.length; i < len; i += interval) { |
| this._chainPoint[i].showLabel = true; |
| } |
| } |
| this._buildChain(); |
| this._buildHandle(); |
| for (var i = 0, l = this.shapeList.length; i < l; i++) { |
| this.zr.addShape(this.shapeList[i]); |
| } |
| }, |
| _getLocation: function () { |
| var timelineOption = this.timelineOption; |
| var padding = this.reformCssArray(this.timelineOption.padding); |
| var zrWidth = this.zr.getWidth(); |
| var x = this.parsePercent(timelineOption.x, zrWidth); |
| var x2 = this.parsePercent(timelineOption.x2, zrWidth); |
| var width; |
| if (timelineOption.width == null) { |
| width = zrWidth - x - x2; |
| x2 = zrWidth - x2; |
| } else { |
| width = this.parsePercent(timelineOption.width, zrWidth); |
| x2 = x + width; |
| } |
| var zrHeight = this.zr.getHeight(); |
| var height = this.parsePercent(timelineOption.height, zrHeight); |
| var y; |
| var y2; |
| if (timelineOption.y != null) { |
| y = this.parsePercent(timelineOption.y, zrHeight); |
| y2 = y + height; |
| } else { |
| y2 = zrHeight - this.parsePercent(timelineOption.y2, zrHeight); |
| y = y2 - height; |
| } |
| return { |
| x: x + padding[3], |
| y: y + padding[0], |
| x2: x2 - padding[1], |
| y2: y2 - padding[2], |
| width: width - padding[1] - padding[3], |
| height: height - padding[0] - padding[2] |
| }; |
| }, |
| _getReformedLabel: function (idx) { |
| var timelineOption = this.timelineOption; |
| var data = timelineOption.data[idx].name != null ? timelineOption.data[idx].name : timelineOption.data[idx]; |
| var formatter = timelineOption.data[idx].formatter || timelineOption.label.formatter; |
| if (formatter) { |
| if (typeof formatter === 'function') { |
| data = formatter.call(this.myChart, data); |
| } else if (typeof formatter === 'string') { |
| data = formatter.replace('{value}', data); |
| } |
| } |
| return data; |
| }, |
| _getInterval: function () { |
| var chainPoint = this._chainPoint; |
| var timelineOption = this.timelineOption; |
| var interval = timelineOption.label.interval; |
| if (interval === 'auto') { |
| var fontSize = timelineOption.label.textStyle.fontSize; |
| var data = timelineOption.data; |
| var dataLength = timelineOption.data.length; |
| if (dataLength > 3) { |
| var isEnough = false; |
| var labelSpace; |
| var labelSize; |
| interval = 0; |
| while (!isEnough && interval < dataLength) { |
| interval++; |
| isEnough = true; |
| for (var i = interval; i < dataLength; i += interval) { |
| labelSpace = chainPoint[i].x - chainPoint[i - interval].x; |
| if (timelineOption.label.rotate !== 0) { |
| labelSize = fontSize; |
| } else if (data[i].textStyle) { |
| labelSize = zrArea.getTextWidth(chainPoint[i].name, chainPoint[i].textFont); |
| } else { |
| var label = chainPoint[i].name + ''; |
| var wLen = (label.match(/\w/g) || '').length; |
| var oLen = label.length - wLen; |
| labelSize = wLen * fontSize * 2 / 3 + oLen * fontSize; |
| } |
| if (labelSpace < labelSize) { |
| isEnough = false; |
| break; |
| } |
| } |
| } |
| } else { |
| interval = 1; |
| } |
| } else { |
| interval = interval - 0 + 1; |
| } |
| return interval; |
| }, |
| _getChainPoint: function () { |
| var timelineOption = this.timelineOption; |
| var symbol = timelineOption.symbol.toLowerCase(); |
| var symbolSize = timelineOption.symbolSize; |
| var rotate = timelineOption.label.rotate; |
| var textStyle = timelineOption.label.textStyle; |
| var textFont = this.getFont(textStyle); |
| var dataTextStyle; |
| var data = timelineOption.data; |
| var x = this._location.x; |
| var y = this._location.y + this._location.height / 4 * 3; |
| var width = this._location.x2 - this._location.x; |
| var len = data.length; |
| function _getName(i) { |
| return data[i].name != null ? data[i].name : data[i] + ''; |
| } |
| var xList = []; |
| if (len > 1) { |
| var boundaryGap = width / len; |
| boundaryGap = boundaryGap > 50 ? 50 : boundaryGap < 20 ? 5 : boundaryGap; |
| width -= boundaryGap * 2; |
| if (timelineOption.type === 'number') { |
| for (var i = 0; i < len; i++) { |
| xList.push(x + boundaryGap + width / (len - 1) * i); |
| } |
| } else { |
| xList[0] = new Date(_getName(0).replace(/-/g, '/')); |
| xList[len - 1] = new Date(_getName(len - 1).replace(/-/g, '/')) - xList[0]; |
| for (var i = 1; i < len; i++) { |
| xList[i] = x + boundaryGap + width * (new Date(_getName(i).replace(/-/g, '/')) - xList[0]) / xList[len - 1]; |
| } |
| xList[0] = x + boundaryGap; |
| } |
| } else { |
| xList.push(x + width / 2); |
| } |
| var list = []; |
| var curSymbol; |
| var n; |
| var isEmpty; |
| var textAlign; |
| var rotation; |
| for (var i = 0; i < len; i++) { |
| x = xList[i]; |
| curSymbol = data[i].symbol && data[i].symbol.toLowerCase() || symbol; |
| if (curSymbol.match('empty')) { |
| curSymbol = curSymbol.replace('empty', ''); |
| isEmpty = true; |
| } else { |
| isEmpty = false; |
| } |
| if (curSymbol.match('star')) { |
| n = curSymbol.replace('star', '') - 0 || 5; |
| curSymbol = 'star'; |
| } |
| dataTextStyle = data[i].textStyle ? zrUtil.merge(data[i].textStyle || {}, textStyle) : textStyle; |
| textAlign = dataTextStyle.align || 'center'; |
| if (rotate) { |
| textAlign = rotate > 0 ? 'right' : 'left'; |
| rotation = [ |
| rotate * Math.PI / 180, |
| x, |
| y - 5 |
| ]; |
| } else { |
| rotation = false; |
| } |
| list.push({ |
| x: x, |
| n: n, |
| isEmpty: isEmpty, |
| symbol: curSymbol, |
| symbolSize: data[i].symbolSize || symbolSize, |
| color: data[i].color, |
| borderColor: data[i].borderColor, |
| borderWidth: data[i].borderWidth, |
| name: this._getReformedLabel(i), |
| textColor: dataTextStyle.color, |
| textAlign: textAlign, |
| textBaseline: dataTextStyle.baseline || 'middle', |
| textX: x, |
| textY: y - (rotate ? 5 : 0), |
| textFont: data[i].textStyle ? this.getFont(dataTextStyle) : textFont, |
| rotation: rotation, |
| showLabel: false |
| }); |
| } |
| return list; |
| }, |
| _buildBackground: function () { |
| var timelineOption = this.timelineOption; |
| var padding = this.reformCssArray(this.timelineOption.padding); |
| var width = this._location.width; |
| var height = this._location.height; |
| if (timelineOption.borderWidth !== 0 || timelineOption.backgroundColor.replace(/\s/g, '') != 'rgba(0,0,0,0)') { |
| this.shapeList.push(new RectangleShape({ |
| zlevel: this._zlevelBase, |
| hoverable: false, |
| style: { |
| x: this._location.x - padding[3], |
| y: this._location.y - padding[0], |
| width: width + padding[1] + padding[3], |
| height: height + padding[0] + padding[2], |
| brushType: timelineOption.borderWidth === 0 ? 'fill' : 'both', |
| color: timelineOption.backgroundColor, |
| strokeColor: timelineOption.borderColor, |
| lineWidth: timelineOption.borderWidth |
| } |
| })); |
| } |
| }, |
| _buildControl: function () { |
| var self = this; |
| var timelineOption = this.timelineOption; |
| var lineStyle = timelineOption.lineStyle; |
| var controlStyle = timelineOption.controlStyle; |
| if (timelineOption.controlPosition === 'none') { |
| return; |
| } |
| var iconSize = 15; |
| var iconGap = 5; |
| var x; |
| if (timelineOption.controlPosition === 'left') { |
| x = this._location.x; |
| this._location.x += (iconSize + iconGap) * 3; |
| } else { |
| x = this._location.x2 - ((iconSize + iconGap) * 3 - iconGap); |
| this._location.x2 -= (iconSize + iconGap) * 3; |
| } |
| var y = this._location.y; |
| var iconStyle = { |
| zlevel: this._zlevelBase + 1, |
| style: { |
| iconType: 'timelineControl', |
| symbol: 'last', |
| x: x, |
| y: y, |
| width: iconSize, |
| height: iconSize, |
| brushType: 'stroke', |
| color: controlStyle.normal.color, |
| strokeColor: controlStyle.normal.color, |
| lineWidth: lineStyle.width |
| }, |
| highlightStyle: { |
| color: controlStyle.emphasis.color, |
| strokeColor: controlStyle.emphasis.color, |
| lineWidth: lineStyle.width + 1 |
| }, |
| clickable: true |
| }; |
| this._ctrLastShape = new IconShape(iconStyle); |
| this._ctrLastShape.onclick = function () { |
| self.last(); |
| }; |
| this.shapeList.push(this._ctrLastShape); |
| x += iconSize + iconGap; |
| this._ctrPlayShape = new IconShape(zrUtil.clone(iconStyle)); |
| this._ctrPlayShape.style.brushType = 'fill'; |
| this._ctrPlayShape.style.symbol = 'play'; |
| this._ctrPlayShape.style.status = this.timelineOption.autoPlay ? 'playing' : 'stop'; |
| this._ctrPlayShape.style.x = x; |
| this._ctrPlayShape.onclick = function () { |
| if (self._ctrPlayShape.style.status === 'stop') { |
| self.play(); |
| } else { |
| self.stop(); |
| } |
| }; |
| this.shapeList.push(this._ctrPlayShape); |
| x += iconSize + iconGap; |
| this._ctrNextShape = new IconShape(zrUtil.clone(iconStyle)); |
| this._ctrNextShape.style.symbol = 'next'; |
| this._ctrNextShape.style.x = x; |
| this._ctrNextShape.onclick = function () { |
| self.next(); |
| }; |
| this.shapeList.push(this._ctrNextShape); |
| }, |
| _buildChain: function () { |
| var timelineOption = this.timelineOption; |
| var lineStyle = timelineOption.lineStyle; |
| this._timelineShae = { |
| zlevel: this._zlevelBase, |
| style: { |
| x: this._location.x, |
| y: this.subPixelOptimize(this._location.y, lineStyle.width), |
| width: this._location.x2 - this._location.x, |
| height: this._location.height, |
| chainPoint: this._chainPoint, |
| brushType: 'both', |
| strokeColor: lineStyle.color, |
| lineWidth: lineStyle.width, |
| lineType: lineStyle.type |
| }, |
| hoverable: false, |
| clickable: true, |
| onclick: this._onclick |
| }; |
| this._timelineShae = new ChainShape(this._timelineShae); |
| this.shapeList.push(this._timelineShae); |
| }, |
| _buildHandle: function () { |
| var curPoint = this._chainPoint[this.currentIndex]; |
| var symbolSize = curPoint.symbolSize + 1; |
| symbolSize = symbolSize < 5 ? 5 : symbolSize; |
| this._handleShape = { |
| zlevel: this._zlevelBase + 1, |
| hoverable: false, |
| draggable: true, |
| style: { |
| iconType: 'diamond', |
| n: curPoint.n, |
| x: curPoint.x - symbolSize, |
| y: this._location.y + this._location.height / 4 - symbolSize, |
| width: symbolSize * 2, |
| height: symbolSize * 2, |
| brushType: 'both', |
| textPosition: 'specific', |
| textX: curPoint.x, |
| textY: this._location.y - this._location.height / 4, |
| textAlign: 'center', |
| textBaseline: 'middle' |
| }, |
| highlightStyle: {}, |
| ondrift: this._ondrift, |
| ondragend: this._ondragend |
| }; |
| this._handleShape = new IconShape(this._handleShape); |
| this.shapeList.push(this._handleShape); |
| }, |
| _syncHandleShape: function () { |
| if (!this.timelineOption.show) { |
| return; |
| } |
| var timelineOption = this.timelineOption; |
| var cpStyle = timelineOption.checkpointStyle; |
| var curPoint = this._chainPoint[this.currentIndex]; |
| this._handleShape.style.text = cpStyle.label.show ? curPoint.name : ''; |
| this._handleShape.style.textFont = curPoint.textFont; |
| this._handleShape.style.n = curPoint.n; |
| if (cpStyle.symbol === 'auto') { |
| this._handleShape.style.iconType = curPoint.symbol != 'none' ? curPoint.symbol : 'diamond'; |
| } else { |
| this._handleShape.style.iconType = cpStyle.symbol; |
| if (cpStyle.symbol.match('star')) { |
| this._handleShape.style.n = cpStyle.symbol.replace('star', '') - 0 || 5; |
| this._handleShape.style.iconType = 'star'; |
| } |
| } |
| var symbolSize; |
| if (cpStyle.symbolSize === 'auto') { |
| symbolSize = curPoint.symbolSize + 2; |
| symbolSize = symbolSize < 5 ? 5 : symbolSize; |
| } else { |
| symbolSize = cpStyle.symbolSize - 0; |
| } |
| this._handleShape.style.color = cpStyle.color === 'auto' ? curPoint.color ? curPoint.color : timelineOption.controlStyle.emphasis.color : cpStyle.color; |
| this._handleShape.style.textColor = cpStyle.label.textStyle.color === 'auto' ? this._handleShape.style.color : cpStyle.label.textStyle.color; |
| this._handleShape.highlightStyle.strokeColor = this._handleShape.style.strokeColor = cpStyle.borderColor === 'auto' ? curPoint.borderColor ? curPoint.borderColor : '#fff' : cpStyle.borderColor; |
| this._handleShape.style.lineWidth = cpStyle.borderWidth === 'auto' ? curPoint.borderWidth ? curPoint.borderWidth : 0 : cpStyle.borderWidth - 0; |
| this._handleShape.highlightStyle.lineWidth = this._handleShape.style.lineWidth + 1; |
| this.zr.animate(this._handleShape.id, 'style').when(500, { |
| x: curPoint.x - symbolSize, |
| textX: curPoint.x, |
| y: this._location.y + this._location.height / 4 - symbolSize, |
| width: symbolSize * 2, |
| height: symbolSize * 2 |
| }).start('ExponentialOut'); |
| }, |
| _findChainIndex: function (x) { |
| var chainPoint = this._chainPoint; |
| var len = chainPoint.length; |
| if (x <= chainPoint[0].x) { |
| return 0; |
| } else if (x >= chainPoint[len - 1].x) { |
| return len - 1; |
| } |
| for (var i = 0; i < len - 1; i++) { |
| if (x >= chainPoint[i].x && x <= chainPoint[i + 1].x) { |
| return Math.abs(x - chainPoint[i].x) < Math.abs(x - chainPoint[i + 1].x) ? i : i + 1; |
| } |
| } |
| }, |
| __onclick: function (param) { |
| var x = zrEvent.getX(param.event); |
| var newIndex = this._findChainIndex(x); |
| if (newIndex === this.currentIndex) { |
| return true; |
| } |
| this.currentIndex = newIndex; |
| this.timelineOption.autoPlay && this.stop(); |
| clearTimeout(this.playTicket); |
| this._onFrame(); |
| }, |
| __ondrift: function (shape, dx) { |
| this.timelineOption.autoPlay && this.stop(); |
| var chainPoint = this._chainPoint; |
| var len = chainPoint.length; |
| var newIndex; |
| if (shape.style.x + dx <= chainPoint[0].x - chainPoint[0].symbolSize) { |
| shape.style.x = chainPoint[0].x - chainPoint[0].symbolSize; |
| newIndex = 0; |
| } else if (shape.style.x + dx >= chainPoint[len - 1].x - chainPoint[len - 1].symbolSize) { |
| shape.style.x = chainPoint[len - 1].x - chainPoint[len - 1].symbolSize; |
| newIndex = len - 1; |
| } else { |
| shape.style.x += dx; |
| newIndex = this._findChainIndex(shape.style.x); |
| } |
| var curPoint = chainPoint[newIndex]; |
| var symbolSize = curPoint.symbolSize + 2; |
| shape.style.iconType = curPoint.symbol; |
| shape.style.n = curPoint.n; |
| shape.style.textX = shape.style.x + symbolSize / 2; |
| shape.style.y = this._location.y + this._location.height / 4 - symbolSize; |
| shape.style.width = symbolSize * 2; |
| shape.style.height = symbolSize * 2; |
| shape.style.text = curPoint.name; |
| if (newIndex === this.currentIndex) { |
| return true; |
| } |
| this.currentIndex = newIndex; |
| if (this.timelineOption.realtime) { |
| clearTimeout(this.playTicket); |
| var self = this; |
| this.playTicket = setTimeout(function () { |
| self._setCurrentOption(); |
| }, 200); |
| } |
| return true; |
| }, |
| __ondragend: function () { |
| this.isDragend = true; |
| }, |
| ondragend: function (param, status) { |
| if (!this.isDragend || !param.target) { |
| return; |
| } |
| !this.timelineOption.realtime && this._setCurrentOption(); |
| status.dragOut = true; |
| status.dragIn = true; |
| status.needRefresh = false; |
| this.isDragend = false; |
| this._syncHandleShape(); |
| return; |
| }, |
| last: function () { |
| this.timelineOption.autoPlay && this.stop(); |
| this.currentIndex -= 1; |
| if (this.currentIndex < 0) { |
| this.currentIndex = this.timelineOption.data.length - 1; |
| } |
| this._onFrame(); |
| return this.currentIndex; |
| }, |
| next: function () { |
| this.timelineOption.autoPlay && this.stop(); |
| this.currentIndex += 1; |
| if (this.currentIndex >= this.timelineOption.data.length) { |
| this.currentIndex = 0; |
| } |
| this._onFrame(); |
| return this.currentIndex; |
| }, |
| play: function (targetIndex, autoPlay) { |
| if (this._ctrPlayShape && this._ctrPlayShape.style.status != 'playing') { |
| this._ctrPlayShape.style.status = 'playing'; |
| this.zr.modShape(this._ctrPlayShape.id); |
| this.zr.refresh(); |
| } |
| this.timelineOption.autoPlay = autoPlay != null ? autoPlay : true; |
| if (!this.timelineOption.autoPlay) { |
| clearTimeout(this.playTicket); |
| } |
| this.currentIndex = targetIndex != null ? targetIndex : this.currentIndex + 1; |
| if (this.currentIndex >= this.timelineOption.data.length) { |
| this.currentIndex = 0; |
| } |
| this._onFrame(); |
| return this.currentIndex; |
| }, |
| stop: function () { |
| if (this._ctrPlayShape && this._ctrPlayShape.style.status != 'stop') { |
| this._ctrPlayShape.style.status = 'stop'; |
| this.zr.modShape(this._ctrPlayShape.id); |
| this.zr.refresh(); |
| } |
| this.timelineOption.autoPlay = false; |
| clearTimeout(this.playTicket); |
| return this.currentIndex; |
| }, |
| resize: function () { |
| if (this.timelineOption.show) { |
| this.clear(); |
| this._buildShape(); |
| this._syncHandleShape(); |
| } |
| }, |
| setTheme: function (needRefresh) { |
| this.timelineOption = this.reformOption(zrUtil.clone(this.option.timeline)); |
| this.timelineOption.label.textStyle = zrUtil.merge(this.timelineOption.label.textStyle || {}, this.ecTheme.textStyle); |
| this.timelineOption.checkpointStyle.label.textStyle = zrUtil.merge(this.timelineOption.checkpointStyle.label.textStyle || {}, this.ecTheme.textStyle); |
| if (!this.myChart.canvasSupported) { |
| this.timelineOption.realtime = false; |
| } |
| if (this.timelineOption.show && needRefresh) { |
| this.clear(); |
| this._buildShape(); |
| this._syncHandleShape(); |
| } |
| }, |
| onbeforDispose: function () { |
| clearTimeout(this.playTicket); |
| } |
| }; |
| function timelineControl(ctx, style) { |
| var lineWidth = 2; |
| var x = style.x + lineWidth; |
| var y = style.y + lineWidth + 2; |
| var width = style.width - lineWidth; |
| var height = style.height - lineWidth; |
| var symbol = style.symbol; |
| if (symbol === 'last') { |
| ctx.moveTo(x + width - 2, y + height / 3); |
| ctx.lineTo(x + width - 2, y); |
| ctx.lineTo(x + 2, y + height / 2); |
| ctx.lineTo(x + width - 2, y + height); |
| ctx.lineTo(x + width - 2, y + height / 3 * 2); |
| ctx.moveTo(x, y); |
| ctx.lineTo(x, y); |
| } else if (symbol === 'next') { |
| ctx.moveTo(x + 2, y + height / 3); |
| ctx.lineTo(x + 2, y); |
| ctx.lineTo(x + width - 2, y + height / 2); |
| ctx.lineTo(x + 2, y + height); |
| ctx.lineTo(x + 2, y + height / 3 * 2); |
| ctx.moveTo(x, y); |
| ctx.lineTo(x, y); |
| } else if (symbol === 'play') { |
| if (style.status === 'stop') { |
| ctx.moveTo(x + 2, y); |
| ctx.lineTo(x + width - 2, y + height / 2); |
| ctx.lineTo(x + 2, y + height); |
| ctx.lineTo(x + 2, y); |
| } else { |
| var delta = style.brushType === 'both' ? 2 : 3; |
| ctx.rect(x + 2, y, delta, height); |
| ctx.rect(x + width - delta - 2, y, delta, height); |
| } |
| } else if (symbol.match('image')) { |
| var imageLocation = ''; |
| imageLocation = symbol.replace(new RegExp('^image:\\/\\/'), ''); |
| symbol = IconShape.prototype.iconLibrary.image; |
| symbol(ctx, { |
| x: x, |
| y: y, |
| width: width, |
| height: height, |
| image: imageLocation |
| }); |
| } |
| } |
| IconShape.prototype.iconLibrary['timelineControl'] = timelineControl; |
| zrUtil.inherits(Timeline, Base); |
| require('../component').define('timeline', Timeline); |
| return Timeline; |
| });define('zrender/shape/Image', [ |
| 'require', |
| './Base', |
| '../tool/util' |
| ], function (require) { |
| var Base = require('./Base'); |
| var ZImage = function (options) { |
| Base.call(this, options); |
| }; |
| ZImage.prototype = { |
| type: 'image', |
| brush: function (ctx, isHighlight, refreshNextFrame) { |
| var style = this.style || {}; |
| if (isHighlight) { |
| style = this.getHighlightStyle(style, this.highlightStyle || {}); |
| } |
| var image = style.image; |
| var self = this; |
| if (!this._imageCache) { |
| this._imageCache = {}; |
| } |
| if (typeof image === 'string') { |
| var src = image; |
| if (this._imageCache[src]) { |
| image = this._imageCache[src]; |
| } else { |
| image = new Image(); |
| image.onload = function () { |
| image.onload = null; |
| self.modSelf(); |
| refreshNextFrame(); |
| }; |
| image.src = src; |
| this._imageCache[src] = image; |
| } |
| } |
| if (image) { |
| if (image.nodeName.toUpperCase() == 'IMG') { |
| if (window.ActiveXObject) { |
| if (image.readyState != 'complete') { |
| return; |
| } |
| } else { |
| if (!image.complete) { |
| return; |
| } |
| } |
| } |
| var width = style.width || image.width; |
| var height = style.height || image.height; |
| var x = style.x; |
| var y = style.y; |
| if (!image.width || !image.height) { |
| return; |
| } |
| ctx.save(); |
| this.doClip(ctx); |
| this.setContext(ctx, style); |
| this.setTransform(ctx); |
| if (style.sWidth && style.sHeight) { |
| var sx = style.sx || 0; |
| var sy = style.sy || 0; |
| ctx.drawImage(image, sx, sy, style.sWidth, style.sHeight, x, y, width, height); |
| } else if (style.sx && style.sy) { |
| var sx = style.sx; |
| var sy = style.sy; |
| var sWidth = width - sx; |
| var sHeight = height - sy; |
| ctx.drawImage(image, sx, sy, sWidth, sHeight, x, y, width, height); |
| } else { |
| ctx.drawImage(image, x, y, width, height); |
| } |
| if (!style.width) { |
| style.width = width; |
| } |
| if (!style.height) { |
| style.height = height; |
| } |
| if (!this.style.width) { |
| this.style.width = width; |
| } |
| if (!this.style.height) { |
| this.style.height = height; |
| } |
| this.drawText(ctx, style, this.style); |
| ctx.restore(); |
| } |
| }, |
| getRect: function (style) { |
| return { |
| x: style.x, |
| y: style.y, |
| width: style.width, |
| height: style.height |
| }; |
| }, |
| clearCache: function () { |
| this._imageCache = {}; |
| } |
| }; |
| require('../tool/util').inherits(ZImage, Base); |
| return ZImage; |
| });define('zrender/loadingEffect/Bar', [ |
| 'require', |
| './Base', |
| '../tool/util', |
| '../tool/color', |
| '../shape/Rectangle' |
| ], function (require) { |
| var Base = require('./Base'); |
| var util = require('../tool/util'); |
| var zrColor = require('../tool/color'); |
| var RectangleShape = require('../shape/Rectangle'); |
| function Bar(options) { |
| Base.call(this, options); |
| } |
| util.inherits(Bar, Base); |
| Bar.prototype._start = function (addShapeHandle, refreshHandle) { |
| var options = util.merge(this.options, { |
| textStyle: { color: '#888' }, |
| backgroundColor: 'rgba(250, 250, 250, 0.8)', |
| effectOption: { |
| x: 0, |
| y: this.canvasHeight / 2 - 30, |
| width: this.canvasWidth, |
| height: 5, |
| brushType: 'fill', |
| timeInterval: 100 |
| } |
| }); |
| var textShape = this.createTextShape(options.textStyle); |
| var background = this.createBackgroundShape(options.backgroundColor); |
| var effectOption = options.effectOption; |
| var barShape = new RectangleShape({ highlightStyle: util.clone(effectOption) }); |
| barShape.highlightStyle.color = effectOption.color || zrColor.getLinearGradient(effectOption.x, effectOption.y, effectOption.x + effectOption.width, effectOption.y + effectOption.height, [ |
| [ |
| 0, |
| '#ff6400' |
| ], |
| [ |
| 0.5, |
| '#ffe100' |
| ], |
| [ |
| 1, |
| '#b1ff00' |
| ] |
| ]); |
| if (options.progress != null) { |
| addShapeHandle(background); |
| barShape.highlightStyle.width = this.adjust(options.progress, [ |
| 0, |
| 1 |
| ]) * options.effectOption.width; |
| addShapeHandle(barShape); |
| addShapeHandle(textShape); |
| refreshHandle(); |
| return; |
| } else { |
| barShape.highlightStyle.width = 0; |
| return setInterval(function () { |
| addShapeHandle(background); |
| if (barShape.highlightStyle.width < effectOption.width) { |
| barShape.highlightStyle.width += 8; |
| } else { |
| barShape.highlightStyle.width = 0; |
| } |
| addShapeHandle(barShape); |
| addShapeHandle(textShape); |
| refreshHandle(); |
| }, effectOption.timeInterval); |
| } |
| }; |
| return Bar; |
| });define('zrender/loadingEffect/Bubble', [ |
| 'require', |
| './Base', |
| '../tool/util', |
| '../tool/color', |
| '../shape/Circle' |
| ], function (require) { |
| var Base = require('./Base'); |
| var util = require('../tool/util'); |
| var zrColor = require('../tool/color'); |
| var CircleShape = require('../shape/Circle'); |
| function Bubble(options) { |
| Base.call(this, options); |
| } |
| util.inherits(Bubble, Base); |
| Bubble.prototype._start = function (addShapeHandle, refreshHandle) { |
| var options = util.merge(this.options, { |
| textStyle: { color: '#888' }, |
| backgroundColor: 'rgba(250, 250, 250, 0.8)', |
| effect: { |
| n: 50, |
| lineWidth: 2, |
| brushType: 'stroke', |
| color: 'random', |
| timeInterval: 100 |
| } |
| }); |
| var textShape = this.createTextShape(options.textStyle); |
| var background = this.createBackgroundShape(options.backgroundColor); |
| var effectOption = options.effect; |
| var n = effectOption.n; |
| var brushType = effectOption.brushType; |
| var lineWidth = effectOption.lineWidth; |
| var shapeList = []; |
| var canvasWidth = this.canvasWidth; |
| var canvasHeight = this.canvasHeight; |
| for (var i = 0; i < n; i++) { |
| var color = effectOption.color == 'random' ? zrColor.alpha(zrColor.random(), 0.3) : effectOption.color; |
| shapeList[i] = new CircleShape({ |
| highlightStyle: { |
| x: Math.ceil(Math.random() * canvasWidth), |
| y: Math.ceil(Math.random() * canvasHeight), |
| r: Math.ceil(Math.random() * 40), |
| brushType: brushType, |
| color: color, |
| strokeColor: color, |
| lineWidth: lineWidth |
| }, |
| animationY: Math.ceil(Math.random() * 20) |
| }); |
| } |
| return setInterval(function () { |
| addShapeHandle(background); |
| for (var i = 0; i < n; i++) { |
| var style = shapeList[i].highlightStyle; |
| if (style.y - shapeList[i].animationY + style.r <= 0) { |
| shapeList[i].highlightStyle.y = canvasHeight + style.r; |
| shapeList[i].highlightStyle.x = Math.ceil(Math.random() * canvasWidth); |
| } |
| shapeList[i].highlightStyle.y -= shapeList[i].animationY; |
| addShapeHandle(shapeList[i]); |
| } |
| addShapeHandle(textShape); |
| refreshHandle(); |
| }, effectOption.timeInterval); |
| }; |
| return Bubble; |
| });define('zrender/loadingEffect/DynamicLine', [ |
| 'require', |
| './Base', |
| '../tool/util', |
| '../tool/color', |
| '../shape/Line' |
| ], function (require) { |
| var Base = require('./Base'); |
| var util = require('../tool/util'); |
| var zrColor = require('../tool/color'); |
| var LineShape = require('../shape/Line'); |
| function DynamicLine(options) { |
| Base.call(this, options); |
| } |
| util.inherits(DynamicLine, Base); |
| DynamicLine.prototype._start = function (addShapeHandle, refreshHandle) { |
| var options = util.merge(this.options, { |
| textStyle: { color: '#fff' }, |
| backgroundColor: 'rgba(0, 0, 0, 0.8)', |
| effectOption: { |
| n: 30, |
| lineWidth: 1, |
| color: 'random', |
| timeInterval: 100 |
| } |
| }); |
| var textShape = this.createTextShape(options.textStyle); |
| var background = this.createBackgroundShape(options.backgroundColor); |
| var effectOption = options.effectOption; |
| var n = effectOption.n; |
| var lineWidth = effectOption.lineWidth; |
| var shapeList = []; |
| var canvasWidth = this.canvasWidth; |
| var canvasHeight = this.canvasHeight; |
| for (var i = 0; i < n; i++) { |
| var xStart = -Math.ceil(Math.random() * 1000); |
| var len = Math.ceil(Math.random() * 400); |
| var pos = Math.ceil(Math.random() * canvasHeight); |
| var color = effectOption.color == 'random' ? zrColor.random() : effectOption.color; |
| shapeList[i] = new LineShape({ |
| highlightStyle: { |
| xStart: xStart, |
| yStart: pos, |
| xEnd: xStart + len, |
| yEnd: pos, |
| strokeColor: color, |
| lineWidth: lineWidth |
| }, |
| animationX: Math.ceil(Math.random() * 100), |
| len: len |
| }); |
| } |
| return setInterval(function () { |
| addShapeHandle(background); |
| for (var i = 0; i < n; i++) { |
| var style = shapeList[i].highlightStyle; |
| if (style.xStart >= canvasWidth) { |
| shapeList[i].len = Math.ceil(Math.random() * 400); |
| style.xStart = -400; |
| style.xEnd = -400 + shapeList[i].len; |
| style.yStart = Math.ceil(Math.random() * canvasHeight); |
| style.yEnd = style.yStart; |
| } |
| style.xStart += shapeList[i].animationX; |
| style.xEnd += shapeList[i].animationX; |
| addShapeHandle(shapeList[i]); |
| } |
| addShapeHandle(textShape); |
| refreshHandle(); |
| }, effectOption.timeInterval); |
| }; |
| return DynamicLine; |
| });define('zrender/loadingEffect/Ring', [ |
| 'require', |
| './Base', |
| '../tool/util', |
| '../tool/color', |
| '../shape/Ring', |
| '../shape/Sector' |
| ], function (require) { |
| var Base = require('./Base'); |
| var util = require('../tool/util'); |
| var zrColor = require('../tool/color'); |
| var RingShape = require('../shape/Ring'); |
| var SectorShape = require('../shape/Sector'); |
| function Ring(options) { |
| Base.call(this, options); |
| } |
| util.inherits(Ring, Base); |
| Ring.prototype._start = function (addShapeHandle, refreshHandle) { |
| var options = util.merge(this.options, { |
| textStyle: { color: '#07a' }, |
| backgroundColor: 'rgba(250, 250, 250, 0.8)', |
| effect: { |
| x: this.canvasWidth / 2, |
| y: this.canvasHeight / 2, |
| r0: 60, |
| r: 100, |
| color: '#bbdcff', |
| brushType: 'fill', |
| textPosition: 'inside', |
| textFont: 'normal 30px verdana', |
| textColor: 'rgba(30, 144, 255, 0.6)', |
| timeInterval: 100 |
| } |
| }); |
| var effectOption = options.effect; |
| var textStyle = options.textStyle; |
| if (textStyle.x == null) { |
| textStyle.x = effectOption.x; |
| } |
| if (textStyle.y == null) { |
| textStyle.y = effectOption.y + (effectOption.r0 + effectOption.r) / 2 - 5; |
| } |
| var textShape = this.createTextShape(options.textStyle); |
| var background = this.createBackgroundShape(options.backgroundColor); |
| var x = effectOption.x; |
| var y = effectOption.y; |
| var r0 = effectOption.r0 + 6; |
| var r = effectOption.r - 6; |
| var color = effectOption.color; |
| var darkColor = zrColor.lift(color, 0.1); |
| var shapeRing = new RingShape({ highlightStyle: util.clone(effectOption) }); |
| var shapeList = []; |
| var clolrList = zrColor.getGradientColors([ |
| '#ff6400', |
| '#ffe100', |
| '#97ff00' |
| ], 25); |
| var preAngle = 15; |
| var endAngle = 240; |
| for (var i = 0; i < 16; i++) { |
| shapeList.push(new SectorShape({ |
| highlightStyle: { |
| x: x, |
| y: y, |
| r0: r0, |
| r: r, |
| startAngle: endAngle - preAngle, |
| endAngle: endAngle, |
| brushType: 'fill', |
| color: darkColor |
| }, |
| _color: zrColor.getLinearGradient(x + r0 * Math.cos(endAngle, true), y - r0 * Math.sin(endAngle, true), x + r0 * Math.cos(endAngle - preAngle, true), y - r0 * Math.sin(endAngle - preAngle, true), [ |
| [ |
| 0, |
| clolrList[i * 2] |
| ], |
| [ |
| 1, |
| clolrList[i * 2 + 1] |
| ] |
| ]) |
| })); |
| endAngle -= preAngle; |
| } |
| endAngle = 360; |
| for (var i = 0; i < 4; i++) { |
| shapeList.push(new SectorShape({ |
| highlightStyle: { |
| x: x, |
| y: y, |
| r0: r0, |
| r: r, |
| startAngle: endAngle - preAngle, |
| endAngle: endAngle, |
| brushType: 'fill', |
| color: darkColor |
| }, |
| _color: zrColor.getLinearGradient(x + r0 * Math.cos(endAngle, true), y - r0 * Math.sin(endAngle, true), x + r0 * Math.cos(endAngle - preAngle, true), y - r0 * Math.sin(endAngle - preAngle, true), [ |
| [ |
| 0, |
| clolrList[i * 2 + 32] |
| ], |
| [ |
| 1, |
| clolrList[i * 2 + 33] |
| ] |
| ]) |
| })); |
| endAngle -= preAngle; |
| } |
| var n = 0; |
| if (options.progress != null) { |
| addShapeHandle(background); |
| n = this.adjust(options.progress, [ |
| 0, |
| 1 |
| ]).toFixed(2) * 100 / 5; |
| shapeRing.highlightStyle.text = n * 5 + '%'; |
| addShapeHandle(shapeRing); |
| for (var i = 0; i < 20; i++) { |
| shapeList[i].highlightStyle.color = i < n ? shapeList[i]._color : darkColor; |
| addShapeHandle(shapeList[i]); |
| } |
| addShapeHandle(textShape); |
| refreshHandle(); |
| return; |
| } |
| return setInterval(function () { |
| addShapeHandle(background); |
| n += n >= 20 ? -20 : 1; |
| addShapeHandle(shapeRing); |
| for (var i = 0; i < 20; i++) { |
| shapeList[i].highlightStyle.color = i < n ? shapeList[i]._color : darkColor; |
| addShapeHandle(shapeList[i]); |
| } |
| addShapeHandle(textShape); |
| refreshHandle(); |
| }, effectOption.timeInterval); |
| }; |
| return Ring; |
| });define('zrender/loadingEffect/Spin', [ |
| 'require', |
| './Base', |
| '../tool/util', |
| '../tool/color', |
| '../tool/area', |
| '../shape/Sector' |
| ], function (require) { |
| var Base = require('./Base'); |
| var util = require('../tool/util'); |
| var zrColor = require('../tool/color'); |
| var zrArea = require('../tool/area'); |
| var SectorShape = require('../shape/Sector'); |
| function Spin(options) { |
| Base.call(this, options); |
| } |
| util.inherits(Spin, Base); |
| Spin.prototype._start = function (addShapeHandle, refreshHandle) { |
| var options = util.merge(this.options, { |
| textStyle: { |
| color: '#fff', |
| textAlign: 'start' |
| }, |
| backgroundColor: 'rgba(0, 0, 0, 0.8)' |
| }); |
| var textShape = this.createTextShape(options.textStyle); |
| var textGap = 10; |
| var textWidth = zrArea.getTextWidth(textShape.highlightStyle.text, textShape.highlightStyle.textFont); |
| var textHeight = zrArea.getTextHeight(textShape.highlightStyle.text, textShape.highlightStyle.textFont); |
| var effectOption = util.merge(this.options.effect || {}, { |
| r0: 9, |
| r: 15, |
| n: 18, |
| color: '#fff', |
| timeInterval: 100 |
| }); |
| var location = this.getLocation(this.options.textStyle, textWidth + textGap + effectOption.r * 2, Math.max(effectOption.r * 2, textHeight)); |
| effectOption.x = location.x + effectOption.r; |
| effectOption.y = textShape.highlightStyle.y = location.y + location.height / 2; |
| textShape.highlightStyle.x = effectOption.x + effectOption.r + textGap; |
| var background = this.createBackgroundShape(options.backgroundColor); |
| var n = effectOption.n; |
| var x = effectOption.x; |
| var y = effectOption.y; |
| var r0 = effectOption.r0; |
| var r = effectOption.r; |
| var color = effectOption.color; |
| var shapeList = []; |
| var preAngle = Math.round(180 / n); |
| for (var i = 0; i < n; i++) { |
| shapeList[i] = new SectorShape({ |
| highlightStyle: { |
| x: x, |
| y: y, |
| r0: r0, |
| r: r, |
| startAngle: preAngle * i * 2, |
| endAngle: preAngle * i * 2 + preAngle, |
| color: zrColor.alpha(color, (i + 1) / n), |
| brushType: 'fill' |
| } |
| }); |
| } |
| var pos = [ |
| 0, |
| x, |
| y |
| ]; |
| return setInterval(function () { |
| addShapeHandle(background); |
| pos[0] -= 0.3; |
| for (var i = 0; i < n; i++) { |
| shapeList[i].rotation = pos; |
| addShapeHandle(shapeList[i]); |
| } |
| addShapeHandle(textShape); |
| refreshHandle(); |
| }, effectOption.timeInterval); |
| }; |
| return Spin; |
| });define('zrender/loadingEffect/Whirling', [ |
| 'require', |
| './Base', |
| '../tool/util', |
| '../tool/area', |
| '../shape/Ring', |
| '../shape/Droplet', |
| '../shape/Circle' |
| ], function (require) { |
| var Base = require('./Base'); |
| var util = require('../tool/util'); |
| var zrArea = require('../tool/area'); |
| var RingShape = require('../shape/Ring'); |
| var DropletShape = require('../shape/Droplet'); |
| var CircleShape = require('../shape/Circle'); |
| function Whirling(options) { |
| Base.call(this, options); |
| } |
| util.inherits(Whirling, Base); |
| Whirling.prototype._start = function (addShapeHandle, refreshHandle) { |
| var options = util.merge(this.options, { |
| textStyle: { |
| color: '#888', |
| textAlign: 'start' |
| }, |
| backgroundColor: 'rgba(250, 250, 250, 0.8)' |
| }); |
| var textShape = this.createTextShape(options.textStyle); |
| var textGap = 10; |
| var textWidth = zrArea.getTextWidth(textShape.highlightStyle.text, textShape.highlightStyle.textFont); |
| var textHeight = zrArea.getTextHeight(textShape.highlightStyle.text, textShape.highlightStyle.textFont); |
| var effectOption = util.merge(this.options.effect || {}, { |
| r: 18, |
| colorIn: '#fff', |
| colorOut: '#555', |
| colorWhirl: '#6cf', |
| timeInterval: 50 |
| }); |
| var location = this.getLocation(this.options.textStyle, textWidth + textGap + effectOption.r * 2, Math.max(effectOption.r * 2, textHeight)); |
| effectOption.x = location.x + effectOption.r; |
| effectOption.y = textShape.highlightStyle.y = location.y + location.height / 2; |
| textShape.highlightStyle.x = effectOption.x + effectOption.r + textGap; |
| var background = this.createBackgroundShape(options.backgroundColor); |
| var droplet = new DropletShape({ |
| highlightStyle: { |
| a: Math.round(effectOption.r / 2), |
| b: Math.round(effectOption.r - effectOption.r / 6), |
| brushType: 'fill', |
| color: effectOption.colorWhirl |
| } |
| }); |
| var circleIn = new CircleShape({ |
| highlightStyle: { |
| r: Math.round(effectOption.r / 6), |
| brushType: 'fill', |
| color: effectOption.colorIn |
| } |
| }); |
| var circleOut = new RingShape({ |
| highlightStyle: { |
| r0: Math.round(effectOption.r - effectOption.r / 3), |
| r: effectOption.r, |
| brushType: 'fill', |
| color: effectOption.colorOut |
| } |
| }); |
| var pos = [ |
| 0, |
| effectOption.x, |
| effectOption.y |
| ]; |
| droplet.highlightStyle.x = circleIn.highlightStyle.x = circleOut.highlightStyle.x = pos[1]; |
| droplet.highlightStyle.y = circleIn.highlightStyle.y = circleOut.highlightStyle.y = pos[2]; |
| return setInterval(function () { |
| addShapeHandle(background); |
| addShapeHandle(circleOut); |
| pos[0] -= 0.3; |
| droplet.rotation = pos; |
| addShapeHandle(droplet); |
| addShapeHandle(circleIn); |
| addShapeHandle(textShape); |
| refreshHandle(); |
| }, effectOption.timeInterval); |
| }; |
| return Whirling; |
| });define('echarts/theme/default', [], function () { |
| var config = {}; |
| return config; |
| });define('zrender/dep/excanvas', ['require'], function (require) { |
| if (!document.createElement('canvas').getContext) { |
| (function () { |
| var m = Math; |
| var mr = m.round; |
| var ms = m.sin; |
| var mc = m.cos; |
| var abs = m.abs; |
| var sqrt = m.sqrt; |
| var Z = 10; |
| var Z2 = Z / 2; |
| var IE_VERSION = +navigator.userAgent.match(/MSIE ([\d.]+)?/)[1]; |
| function getContext() { |
| return this.context_ || (this.context_ = new CanvasRenderingContext2D_(this)); |
| } |
| var slice = Array.prototype.slice; |
| function bind(f, obj, var_args) { |
| var a = slice.call(arguments, 2); |
| return function () { |
| return f.apply(obj, a.concat(slice.call(arguments))); |
| }; |
| } |
| function encodeHtmlAttribute(s) { |
| return String(s).replace(/&/g, '&').replace(/"/g, '"'); |
| } |
| function addNamespace(doc, prefix, urn) { |
| if (!doc.namespaces[prefix]) { |
| doc.namespaces.add(prefix, urn, '#default#VML'); |
| } |
| } |
| function addNamespacesAndStylesheet(doc) { |
| addNamespace(doc, 'g_vml_', 'urn:schemas-microsoft-com:vml'); |
| addNamespace(doc, 'g_o_', 'urn:schemas-microsoft-com:office:office'); |
| if (!doc.styleSheets['ex_canvas_']) { |
| var ss = doc.createStyleSheet(); |
| ss.owningElement.id = 'ex_canvas_'; |
| ss.cssText = 'canvas{display:inline-block;overflow:hidden;' + 'text-align:left;width:300px;height:150px}'; |
| } |
| } |
| addNamespacesAndStylesheet(document); |
| var G_vmlCanvasManager_ = { |
| init: function (opt_doc) { |
| var doc = opt_doc || document; |
| doc.createElement('canvas'); |
| doc.attachEvent('onreadystatechange', bind(this.init_, this, doc)); |
| }, |
| init_: function (doc) { |
| var els = doc.getElementsByTagName('canvas'); |
| for (var i = 0; i < els.length; i++) { |
| this.initElement(els[i]); |
| } |
| }, |
| initElement: function (el) { |
| if (!el.getContext) { |
| el.getContext = getContext; |
| addNamespacesAndStylesheet(el.ownerDocument); |
| el.innerHTML = ''; |
| el.attachEvent('onpropertychange', onPropertyChange); |
| el.attachEvent('onresize', onResize); |
| var attrs = el.attributes; |
| if (attrs.width && attrs.width.specified) { |
| el.style.width = attrs.width.nodeValue + 'px'; |
| } else { |
| el.width = el.clientWidth; |
| } |
| if (attrs.height && attrs.height.specified) { |
| el.style.height = attrs.height.nodeValue + 'px'; |
| } else { |
| el.height = el.clientHeight; |
| } |
| } |
| return el; |
| } |
| }; |
| function onPropertyChange(e) { |
| var el = e.srcElement; |
| switch (e.propertyName) { |
| case 'width': |
| el.getContext().clearRect(); |
| el.style.width = el.attributes.width.nodeValue + 'px'; |
| el.firstChild.style.width = el.clientWidth + 'px'; |
| break; |
| case 'height': |
| el.getContext().clearRect(); |
| el.style.height = el.attributes.height.nodeValue + 'px'; |
| el.firstChild.style.height = el.clientHeight + 'px'; |
| break; |
| } |
| } |
| function onResize(e) { |
| var el = e.srcElement; |
| if (el.firstChild) { |
| el.firstChild.style.width = el.clientWidth + 'px'; |
| el.firstChild.style.height = el.clientHeight + 'px'; |
| } |
| } |
| G_vmlCanvasManager_.init(); |
| var decToHex = []; |
| for (var i = 0; i < 16; i++) { |
| for (var j = 0; j < 16; j++) { |
| decToHex[i * 16 + j] = i.toString(16) + j.toString(16); |
| } |
| } |
| function createMatrixIdentity() { |
| return [ |
| [ |
| 1, |
| 0, |
| 0 |
| ], |
| [ |
| 0, |
| 1, |
| 0 |
| ], |
| [ |
| 0, |
| 0, |
| 1 |
| ] |
| ]; |
| } |
| function matrixMultiply(m1, m2) { |
| var result = createMatrixIdentity(); |
| for (var x = 0; x < 3; x++) { |
| for (var y = 0; y < 3; y++) { |
| var sum = 0; |
| for (var z = 0; z < 3; z++) { |
| sum += m1[x][z] * m2[z][y]; |
| } |
| result[x][y] = sum; |
| } |
| } |
| return result; |
| } |
| function copyState(o1, o2) { |
| o2.fillStyle = o1.fillStyle; |
| o2.lineCap = o1.lineCap; |
| o2.lineJoin = o1.lineJoin; |
| o2.lineWidth = o1.lineWidth; |
| o2.miterLimit = o1.miterLimit; |
| o2.shadowBlur = o1.shadowBlur; |
| o2.shadowColor = o1.shadowColor; |
| o2.shadowOffsetX = o1.shadowOffsetX; |
| o2.shadowOffsetY = o1.shadowOffsetY; |
| o2.strokeStyle = o1.strokeStyle; |
| o2.globalAlpha = o1.globalAlpha; |
| o2.font = o1.font; |
| o2.textAlign = o1.textAlign; |
| o2.textBaseline = o1.textBaseline; |
| o2.scaleX_ = o1.scaleX_; |
| o2.scaleY_ = o1.scaleY_; |
| o2.lineScale_ = o1.lineScale_; |
| } |
| var colorData = { |
| aliceblue: '#F0F8FF', |
| antiquewhite: '#FAEBD7', |
| aquamarine: '#7FFFD4', |
| azure: '#F0FFFF', |
| beige: '#F5F5DC', |
| bisque: '#FFE4C4', |
| black: '#000000', |
| blanchedalmond: '#FFEBCD', |
| blueviolet: '#8A2BE2', |
| brown: '#A52A2A', |
| burlywood: '#DEB887', |
| cadetblue: '#5F9EA0', |
| chartreuse: '#7FFF00', |
| chocolate: '#D2691E', |
| coral: '#FF7F50', |
| cornflowerblue: '#6495ED', |
| cornsilk: '#FFF8DC', |
| crimson: '#DC143C', |
| cyan: '#00FFFF', |
| darkblue: '#00008B', |
| darkcyan: '#008B8B', |
| darkgoldenrod: '#B8860B', |
| darkgray: '#A9A9A9', |
| darkgreen: '#006400', |
| darkgrey: '#A9A9A9', |
| darkkhaki: '#BDB76B', |
| darkmagenta: '#8B008B', |
| darkolivegreen: '#556B2F', |
| darkorange: '#FF8C00', |
| darkorchid: '#9932CC', |
| darkred: '#8B0000', |
| darksalmon: '#E9967A', |
| darkseagreen: '#8FBC8F', |
| darkslateblue: '#483D8B', |
| darkslategray: '#2F4F4F', |
| darkslategrey: '#2F4F4F', |
| darkturquoise: '#00CED1', |
| darkviolet: '#9400D3', |
| deeppink: '#FF1493', |
| deepskyblue: '#00BFFF', |
| dimgray: '#696969', |
| dimgrey: '#696969', |
| dodgerblue: '#1E90FF', |
| firebrick: '#B22222', |
| floralwhite: '#FFFAF0', |
| forestgreen: '#228B22', |
| gainsboro: '#DCDCDC', |
| ghostwhite: '#F8F8FF', |
| gold: '#FFD700', |
| goldenrod: '#DAA520', |
| grey: '#808080', |
| greenyellow: '#ADFF2F', |
| honeydew: '#F0FFF0', |
| hotpink: '#FF69B4', |
| indianred: '#CD5C5C', |
| indigo: '#4B0082', |
| ivory: '#FFFFF0', |
| khaki: '#F0E68C', |
| lavender: '#E6E6FA', |
| lavenderblush: '#FFF0F5', |
| lawngreen: '#7CFC00', |
| lemonchiffon: '#FFFACD', |
| lightblue: '#ADD8E6', |
| lightcoral: '#F08080', |
| lightcyan: '#E0FFFF', |
| lightgoldenrodyellow: '#FAFAD2', |
| lightgreen: '#90EE90', |
| lightgrey: '#D3D3D3', |
| lightpink: '#FFB6C1', |
| lightsalmon: '#FFA07A', |
| lightseagreen: '#20B2AA', |
| lightskyblue: '#87CEFA', |
| lightslategray: '#778899', |
| lightslategrey: '#778899', |
| lightsteelblue: '#B0C4DE', |
| lightyellow: '#FFFFE0', |
| limegreen: '#32CD32', |
| linen: '#FAF0E6', |
| magenta: '#FF00FF', |
| mediumaquamarine: '#66CDAA', |
| mediumblue: '#0000CD', |
| mediumorchid: '#BA55D3', |
| mediumpurple: '#9370DB', |
| mediumseagreen: '#3CB371', |
| mediumslateblue: '#7B68EE', |
| mediumspringgreen: '#00FA9A', |
| mediumturquoise: '#48D1CC', |
| mediumvioletred: '#C71585', |
| midnightblue: '#191970', |
| mintcream: '#F5FFFA', |
| mistyrose: '#FFE4E1', |
| moccasin: '#FFE4B5', |
| navajowhite: '#FFDEAD', |
| oldlace: '#FDF5E6', |
| olivedrab: '#6B8E23', |
| orange: '#FFA500', |
| orangered: '#FF4500', |
| orchid: '#DA70D6', |
| palegoldenrod: '#EEE8AA', |
| palegreen: '#98FB98', |
| paleturquoise: '#AFEEEE', |
| palevioletred: '#DB7093', |
| papayawhip: '#FFEFD5', |
| peachpuff: '#FFDAB9', |
| peru: '#CD853F', |
| pink: '#FFC0CB', |
| plum: '#DDA0DD', |
| powderblue: '#B0E0E6', |
| rosybrown: '#BC8F8F', |
| royalblue: '#4169E1', |
| saddlebrown: '#8B4513', |
| salmon: '#FA8072', |
| sandybrown: '#F4A460', |
| seagreen: '#2E8B57', |
| seashell: '#FFF5EE', |
| sienna: '#A0522D', |
| skyblue: '#87CEEB', |
| slateblue: '#6A5ACD', |
| slategray: '#708090', |
| slategrey: '#708090', |
| snow: '#FFFAFA', |
| springgreen: '#00FF7F', |
| steelblue: '#4682B4', |
| tan: '#D2B48C', |
| thistle: '#D8BFD8', |
| tomato: '#FF6347', |
| turquoise: '#40E0D0', |
| violet: '#EE82EE', |
| wheat: '#F5DEB3', |
| whitesmoke: '#F5F5F5', |
| yellowgreen: '#9ACD32' |
| }; |
| function getRgbHslContent(styleString) { |
| var start = styleString.indexOf('(', 3); |
| var end = styleString.indexOf(')', start + 1); |
| var parts = styleString.substring(start + 1, end).split(','); |
| if (parts.length != 4 || styleString.charAt(3) != 'a') { |
| parts[3] = 1; |
| } |
| return parts; |
| } |
| function percent(s) { |
| return parseFloat(s) / 100; |
| } |
| function clamp(v, min, max) { |
| return Math.min(max, Math.max(min, v)); |
| } |
| function hslToRgb(parts) { |
| var r, g, b, h, s, l; |
| h = parseFloat(parts[0]) / 360 % 360; |
| if (h < 0) |
| h++; |
| s = clamp(percent(parts[1]), 0, 1); |
| l = clamp(percent(parts[2]), 0, 1); |
| if (s == 0) { |
| r = g = b = l; |
| } else { |
| var q = l < 0.5 ? l * (1 + s) : l + s - l * s; |
| var p = 2 * l - q; |
| r = hueToRgb(p, q, h + 1 / 3); |
| g = hueToRgb(p, q, h); |
| b = hueToRgb(p, q, h - 1 / 3); |
| } |
| return '#' + decToHex[Math.floor(r * 255)] + decToHex[Math.floor(g * 255)] + decToHex[Math.floor(b * 255)]; |
| } |
| function hueToRgb(m1, m2, h) { |
| if (h < 0) |
| h++; |
| if (h > 1) |
| h--; |
| if (6 * h < 1) |
| return m1 + (m2 - m1) * 6 * h; |
| else if (2 * h < 1) |
| return m2; |
| else if (3 * h < 2) |
| return m1 + (m2 - m1) * (2 / 3 - h) * 6; |
| else |
| return m1; |
| } |
| var processStyleCache = {}; |
| function processStyle(styleString) { |
| if (styleString in processStyleCache) { |
| return processStyleCache[styleString]; |
| } |
| var str, alpha = 1; |
| styleString = String(styleString); |
| if (styleString.charAt(0) == '#') { |
| str = styleString; |
| } else if (/^rgb/.test(styleString)) { |
| var parts = getRgbHslContent(styleString); |
| var str = '#', n; |
| for (var i = 0; i < 3; i++) { |
| if (parts[i].indexOf('%') != -1) { |
| n = Math.floor(percent(parts[i]) * 255); |
| } else { |
| n = +parts[i]; |
| } |
| str += decToHex[clamp(n, 0, 255)]; |
| } |
| alpha = +parts[3]; |
| } else if (/^hsl/.test(styleString)) { |
| var parts = getRgbHslContent(styleString); |
| str = hslToRgb(parts); |
| alpha = parts[3]; |
| } else { |
| str = colorData[styleString] || styleString; |
| } |
| return processStyleCache[styleString] = { |
| color: str, |
| alpha: alpha |
| }; |
| } |
| var DEFAULT_STYLE = { |
| style: 'normal', |
| variant: 'normal', |
| weight: 'normal', |
| size: 12, |
| family: '微软雅黑' |
| }; |
| var fontStyleCache = {}; |
| function processFontStyle(styleString) { |
| if (fontStyleCache[styleString]) { |
| return fontStyleCache[styleString]; |
| } |
| var el = document.createElement('div'); |
| var style = el.style; |
| var fontFamily; |
| try { |
| style.font = styleString; |
| fontFamily = style.fontFamily.split(',')[0]; |
| } catch (ex) { |
| } |
| return fontStyleCache[styleString] = { |
| style: style.fontStyle || DEFAULT_STYLE.style, |
| variant: style.fontVariant || DEFAULT_STYLE.variant, |
| weight: style.fontWeight || DEFAULT_STYLE.weight, |
| size: style.fontSize || DEFAULT_STYLE.size, |
| family: fontFamily || DEFAULT_STYLE.family |
| }; |
| } |
| function getComputedStyle(style, element) { |
| var computedStyle = {}; |
| for (var p in style) { |
| computedStyle[p] = style[p]; |
| } |
| var canvasFontSize = parseFloat(element.currentStyle.fontSize), fontSize = parseFloat(style.size); |
| if (typeof style.size == 'number') { |
| computedStyle.size = style.size; |
| } else if (style.size.indexOf('px') != -1) { |
| computedStyle.size = fontSize; |
| } else if (style.size.indexOf('em') != -1) { |
| computedStyle.size = canvasFontSize * fontSize; |
| } else if (style.size.indexOf('%') != -1) { |
| computedStyle.size = canvasFontSize / 100 * fontSize; |
| } else if (style.size.indexOf('pt') != -1) { |
| computedStyle.size = fontSize / 0.75; |
| } else { |
| computedStyle.size = canvasFontSize; |
| } |
| return computedStyle; |
| } |
| function buildStyle(style) { |
| return style.style + ' ' + style.variant + ' ' + style.weight + ' ' + style.size + 'px \'' + style.family + '\''; |
| } |
| var lineCapMap = { |
| 'butt': 'flat', |
| 'round': 'round' |
| }; |
| function processLineCap(lineCap) { |
| return lineCapMap[lineCap] || 'square'; |
| } |
| function CanvasRenderingContext2D_(canvasElement) { |
| this.m_ = createMatrixIdentity(); |
| this.mStack_ = []; |
| this.aStack_ = []; |
| this.currentPath_ = []; |
| this.strokeStyle = '#000'; |
| this.fillStyle = '#000'; |
| this.lineWidth = 1; |
| this.lineJoin = 'miter'; |
| this.lineCap = 'butt'; |
| this.miterLimit = Z * 1; |
| this.globalAlpha = 1; |
| this.font = '12px 微软雅黑'; |
| this.textAlign = 'left'; |
| this.textBaseline = 'alphabetic'; |
| this.canvas = canvasElement; |
| var cssText = 'width:' + canvasElement.clientWidth + 'px;height:' + canvasElement.clientHeight + 'px;overflow:hidden;position:absolute'; |
| var el = canvasElement.ownerDocument.createElement('div'); |
| el.style.cssText = cssText; |
| canvasElement.appendChild(el); |
| var overlayEl = el.cloneNode(false); |
| overlayEl.style.backgroundColor = '#fff'; |
| overlayEl.style.filter = 'alpha(opacity=0)'; |
| canvasElement.appendChild(overlayEl); |
| this.element_ = el; |
| this.scaleX_ = 1; |
| this.scaleY_ = 1; |
| this.lineScale_ = 1; |
| } |
| var contextPrototype = CanvasRenderingContext2D_.prototype; |
| contextPrototype.clearRect = function () { |
| if (this.textMeasureEl_) { |
| this.textMeasureEl_.removeNode(true); |
| this.textMeasureEl_ = null; |
| } |
| this.element_.innerHTML = ''; |
| }; |
| contextPrototype.beginPath = function () { |
| this.currentPath_ = []; |
| }; |
| contextPrototype.moveTo = function (aX, aY) { |
| var p = getCoords(this, aX, aY); |
| this.currentPath_.push({ |
| type: 'moveTo', |
| x: p.x, |
| y: p.y |
| }); |
| this.currentX_ = p.x; |
| this.currentY_ = p.y; |
| }; |
| contextPrototype.lineTo = function (aX, aY) { |
| var p = getCoords(this, aX, aY); |
| this.currentPath_.push({ |
| type: 'lineTo', |
| x: p.x, |
| y: p.y |
| }); |
| this.currentX_ = p.x; |
| this.currentY_ = p.y; |
| }; |
| contextPrototype.bezierCurveTo = function (aCP1x, aCP1y, aCP2x, aCP2y, aX, aY) { |
| var p = getCoords(this, aX, aY); |
| var cp1 = getCoords(this, aCP1x, aCP1y); |
| var cp2 = getCoords(this, aCP2x, aCP2y); |
| bezierCurveTo(this, cp1, cp2, p); |
| }; |
| function bezierCurveTo(self, cp1, cp2, p) { |
| self.currentPath_.push({ |
| type: 'bezierCurveTo', |
| cp1x: cp1.x, |
| cp1y: cp1.y, |
| cp2x: cp2.x, |
| cp2y: cp2.y, |
| x: p.x, |
| y: p.y |
| }); |
| self.currentX_ = p.x; |
| self.currentY_ = p.y; |
| } |
| contextPrototype.quadraticCurveTo = function (aCPx, aCPy, aX, aY) { |
| var cp = getCoords(this, aCPx, aCPy); |
| var p = getCoords(this, aX, aY); |
| var cp1 = { |
| x: this.currentX_ + 2 / 3 * (cp.x - this.currentX_), |
| y: this.currentY_ + 2 / 3 * (cp.y - this.currentY_) |
| }; |
| var cp2 = { |
| x: cp1.x + (p.x - this.currentX_) / 3, |
| y: cp1.y + (p.y - this.currentY_) / 3 |
| }; |
| bezierCurveTo(this, cp1, cp2, p); |
| }; |
| contextPrototype.arc = function (aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise) { |
| aRadius *= Z; |
| var arcType = aClockwise ? 'at' : 'wa'; |
| var xStart = aX + mc(aStartAngle) * aRadius - Z2; |
| var yStart = aY + ms(aStartAngle) * aRadius - Z2; |
| var xEnd = aX + mc(aEndAngle) * aRadius - Z2; |
| var yEnd = aY + ms(aEndAngle) * aRadius - Z2; |
| if (xStart == xEnd && !aClockwise) { |
| xStart += 0.125; |
| } |
| var p = getCoords(this, aX, aY); |
| var pStart = getCoords(this, xStart, yStart); |
| var pEnd = getCoords(this, xEnd, yEnd); |
| this.currentPath_.push({ |
| type: arcType, |
| x: p.x, |
| y: p.y, |
| radius: aRadius, |
| xStart: pStart.x, |
| yStart: pStart.y, |
| xEnd: pEnd.x, |
| yEnd: pEnd.y |
| }); |
| }; |
| contextPrototype.rect = function (aX, aY, aWidth, aHeight) { |
| this.moveTo(aX, aY); |
| this.lineTo(aX + aWidth, aY); |
| this.lineTo(aX + aWidth, aY + aHeight); |
| this.lineTo(aX, aY + aHeight); |
| this.closePath(); |
| }; |
| contextPrototype.strokeRect = function (aX, aY, aWidth, aHeight) { |
| var oldPath = this.currentPath_; |
| this.beginPath(); |
| this.moveTo(aX, aY); |
| this.lineTo(aX + aWidth, aY); |
| this.lineTo(aX + aWidth, aY + aHeight); |
| this.lineTo(aX, aY + aHeight); |
| this.closePath(); |
| this.stroke(); |
| this.currentPath_ = oldPath; |
| }; |
| contextPrototype.fillRect = function (aX, aY, aWidth, aHeight) { |
| var oldPath = this.currentPath_; |
| this.beginPath(); |
| this.moveTo(aX, aY); |
| this.lineTo(aX + aWidth, aY); |
| this.lineTo(aX + aWidth, aY + aHeight); |
| this.lineTo(aX, aY + aHeight); |
| this.closePath(); |
| this.fill(); |
| this.currentPath_ = oldPath; |
| }; |
| contextPrototype.createLinearGradient = function (aX0, aY0, aX1, aY1) { |
| var gradient = new CanvasGradient_('gradient'); |
| gradient.x0_ = aX0; |
| gradient.y0_ = aY0; |
| gradient.x1_ = aX1; |
| gradient.y1_ = aY1; |
| return gradient; |
| }; |
| contextPrototype.createRadialGradient = function (aX0, aY0, aR0, aX1, aY1, aR1) { |
| var gradient = new CanvasGradient_('gradientradial'); |
| gradient.x0_ = aX0; |
| gradient.y0_ = aY0; |
| gradient.r0_ = aR0; |
| gradient.x1_ = aX1; |
| gradient.y1_ = aY1; |
| gradient.r1_ = aR1; |
| return gradient; |
| }; |
| contextPrototype.drawImage = function (image, var_args) { |
| var dx, dy, dw, dh, sx, sy, sw, sh; |
| var oldRuntimeWidth = image.runtimeStyle.width; |
| var oldRuntimeHeight = image.runtimeStyle.height; |
| image.runtimeStyle.width = 'auto'; |
| image.runtimeStyle.height = 'auto'; |
| var w = image.width; |
| var h = image.height; |
| image.runtimeStyle.width = oldRuntimeWidth; |
| image.runtimeStyle.height = oldRuntimeHeight; |
| if (arguments.length == 3) { |
| dx = arguments[1]; |
| dy = arguments[2]; |
| sx = sy = 0; |
| sw = dw = w; |
| sh = dh = h; |
| } else if (arguments.length == 5) { |
| dx = arguments[1]; |
| dy = arguments[2]; |
| dw = arguments[3]; |
| dh = arguments[4]; |
| sx = sy = 0; |
| sw = w; |
| sh = h; |
| } else if (arguments.length == 9) { |
| sx = arguments[1]; |
| sy = arguments[2]; |
| sw = arguments[3]; |
| sh = arguments[4]; |
| dx = arguments[5]; |
| dy = arguments[6]; |
| dw = arguments[7]; |
| dh = arguments[8]; |
| } else { |
| throw Error('Invalid number of arguments'); |
| } |
| var d = getCoords(this, dx, dy); |
| var w2 = sw / 2; |
| var h2 = sh / 2; |
| var vmlStr = []; |
| var W = 10; |
| var H = 10; |
| var scaleX = scaleY = 1; |
| vmlStr.push(' <g_vml_:group', ' coordsize="', Z * W, ',', Z * H, '"', ' coordorigin="0,0"', ' style="width:', W, 'px;height:', H, 'px;position:absolute;'); |
| if (this.m_[0][0] != 1 || this.m_[0][1] || this.m_[1][1] != 1 || this.m_[1][0]) { |
| var filter = []; |
| var scaleX = this.scaleX_; |
| var scaleY = this.scaleY_; |
| filter.push('M11=', this.m_[0][0] / scaleX, ',', 'M12=', this.m_[1][0] / scaleY, ',', 'M21=', this.m_[0][1] / scaleX, ',', 'M22=', this.m_[1][1] / scaleY, ',', 'Dx=', mr(d.x / Z), ',', 'Dy=', mr(d.y / Z), ''); |
| var max = d; |
| var c2 = getCoords(this, dx + dw, dy); |
| var c3 = getCoords(this, dx, dy + dh); |
| var c4 = getCoords(this, dx + dw, dy + dh); |
| max.x = m.max(max.x, c2.x, c3.x, c4.x); |
| max.y = m.max(max.y, c2.y, c3.y, c4.y); |
| vmlStr.push('padding:0 ', mr(max.x / Z), 'px ', mr(max.y / Z), 'px 0;filter:progid:DXImageTransform.Microsoft.Matrix(', filter.join(''), ', SizingMethod=\'clip\');'); |
| } else { |
| vmlStr.push('top:', mr(d.y / Z), 'px;left:', mr(d.x / Z), 'px;'); |
| } |
| vmlStr.push(' ">'); |
| if (sx || sy) { |
| vmlStr.push('<div style="overflow: hidden; width:', Math.ceil((dw + sx * dw / sw) * scaleX), 'px;', ' height:', Math.ceil((dh + sy * dh / sh) * scaleY), 'px;', ' filter:progid:DxImageTransform.Microsoft.Matrix(Dx=', -sx * dw / sw * scaleX, ',Dy=', -sy * dh / sh * scaleY, ');">'); |
| } |
| vmlStr.push('<div style="width:', Math.round(scaleX * w * dw / sw), 'px;', ' height:', Math.round(scaleY * h * dh / sh), 'px;', ' filter:'); |
| if (this.globalAlpha < 1) { |
| vmlStr.push(' progid:DXImageTransform.Microsoft.Alpha(opacity=' + this.globalAlpha * 100 + ')'); |
| } |
| vmlStr.push(' progid:DXImageTransform.Microsoft.AlphaImageLoader(src=', image.src, ',sizingMethod=scale)">'); |
| if (sx || sy) |
| vmlStr.push('</div>'); |
| vmlStr.push('</div></div>'); |
| this.element_.insertAdjacentHTML('BeforeEnd', vmlStr.join('')); |
| }; |
| contextPrototype.stroke = function (aFill) { |
| var lineStr = []; |
| var lineOpen = false; |
| var W = 10; |
| var H = 10; |
| lineStr.push('<g_vml_:shape', ' filled="', !!aFill, '"', ' style="position:absolute;width:', W, 'px;height:', H, 'px;"', ' coordorigin="0,0"', ' coordsize="', Z * W, ',', Z * H, '"', ' stroked="', !aFill, '"', ' path="'); |
| var newSeq = false; |
| var min = { |
| x: null, |
| y: null |
| }; |
| var max = { |
| x: null, |
| y: null |
| }; |
| for (var i = 0; i < this.currentPath_.length; i++) { |
| var p = this.currentPath_[i]; |
| var c; |
| switch (p.type) { |
| case 'moveTo': |
| c = p; |
| lineStr.push(' m ', mr(p.x), ',', mr(p.y)); |
| break; |
| case 'lineTo': |
| lineStr.push(' l ', mr(p.x), ',', mr(p.y)); |
| break; |
| case 'close': |
| lineStr.push(' x '); |
| p = null; |
| break; |
| case 'bezierCurveTo': |
| lineStr.push(' c ', mr(p.cp1x), ',', mr(p.cp1y), ',', mr(p.cp2x), ',', mr(p.cp2y), ',', mr(p.x), ',', mr(p.y)); |
| break; |
| case 'at': |
| case 'wa': |
| lineStr.push(' ', p.type, ' ', mr(p.x - this.scaleX_ * p.radius), ',', mr(p.y - this.scaleY_ * p.radius), ' ', mr(p.x + this.scaleX_ * p.radius), ',', mr(p.y + this.scaleY_ * p.radius), ' ', mr(p.xStart), ',', mr(p.yStart), ' ', mr(p.xEnd), ',', mr(p.yEnd)); |
| break; |
| } |
| if (p) { |
| if (min.x == null || p.x < min.x) { |
| min.x = p.x; |
| } |
| if (max.x == null || p.x > max.x) { |
| max.x = p.x; |
| } |
| if (min.y == null || p.y < min.y) { |
| min.y = p.y; |
| } |
| if (max.y == null || p.y > max.y) { |
| max.y = p.y; |
| } |
| } |
| } |
| lineStr.push(' ">'); |
| if (!aFill) { |
| appendStroke(this, lineStr); |
| } else { |
| appendFill(this, lineStr, min, max); |
| } |
| lineStr.push('</g_vml_:shape>'); |
| this.element_.insertAdjacentHTML('beforeEnd', lineStr.join('')); |
| }; |
| function appendStroke(ctx, lineStr) { |
| var a = processStyle(ctx.strokeStyle); |
| var color = a.color; |
| var opacity = a.alpha * ctx.globalAlpha; |
| var lineWidth = ctx.lineScale_ * ctx.lineWidth; |
| if (lineWidth < 1) { |
| opacity *= lineWidth; |
| } |
| lineStr.push('<g_vml_:stroke', ' opacity="', opacity, '"', ' joinstyle="', ctx.lineJoin, '"', ' miterlimit="', ctx.miterLimit, '"', ' endcap="', processLineCap(ctx.lineCap), '"', ' weight="', lineWidth, 'px"', ' color="', color, '" />'); |
| } |
| function appendFill(ctx, lineStr, min, max) { |
| var fillStyle = ctx.fillStyle; |
| var arcScaleX = ctx.scaleX_; |
| var arcScaleY = ctx.scaleY_; |
| var width = max.x - min.x; |
| var height = max.y - min.y; |
| if (fillStyle instanceof CanvasGradient_) { |
| var angle = 0; |
| var focus = { |
| x: 0, |
| y: 0 |
| }; |
| var shift = 0; |
| var expansion = 1; |
| if (fillStyle.type_ == 'gradient') { |
| var x0 = fillStyle.x0_ / arcScaleX; |
| var y0 = fillStyle.y0_ / arcScaleY; |
| var x1 = fillStyle.x1_ / arcScaleX; |
| var y1 = fillStyle.y1_ / arcScaleY; |
| var p0 = getCoords(ctx, x0, y0); |
| var p1 = getCoords(ctx, x1, y1); |
| var dx = p1.x - p0.x; |
| var dy = p1.y - p0.y; |
| angle = Math.atan2(dx, dy) * 180 / Math.PI; |
| if (angle < 0) { |
| angle += 360; |
| } |
| if (angle < 0.000001) { |
| angle = 0; |
| } |
| } else { |
| var p0 = getCoords(ctx, fillStyle.x0_, fillStyle.y0_); |
| focus = { |
| x: (p0.x - min.x) / width, |
| y: (p0.y - min.y) / height |
| }; |
| width /= arcScaleX * Z; |
| height /= arcScaleY * Z; |
| var dimension = m.max(width, height); |
| shift = 2 * fillStyle.r0_ / dimension; |
| expansion = 2 * fillStyle.r1_ / dimension - shift; |
| } |
| var stops = fillStyle.colors_; |
| stops.sort(function (cs1, cs2) { |
| return cs1.offset - cs2.offset; |
| }); |
| var length = stops.length; |
| var color1 = stops[0].color; |
| var color2 = stops[length - 1].color; |
| var opacity1 = stops[0].alpha * ctx.globalAlpha; |
| var opacity2 = stops[length - 1].alpha * ctx.globalAlpha; |
| var colors = []; |
| for (var i = 0; i < length; i++) { |
| var stop = stops[i]; |
| colors.push(stop.offset * expansion + shift + ' ' + stop.color); |
| } |
| lineStr.push('<g_vml_:fill type="', fillStyle.type_, '"', ' method="none" focus="100%"', ' color="', color1, '"', ' color2="', color2, '"', ' colors="', colors.join(','), '"', ' opacity="', opacity2, '"', ' g_o_:opacity2="', opacity1, '"', ' angle="', angle, '"', ' focusposition="', focus.x, ',', focus.y, '" />'); |
| } else if (fillStyle instanceof CanvasPattern_) { |
| if (width && height) { |
| var deltaLeft = -min.x; |
| var deltaTop = -min.y; |
| lineStr.push('<g_vml_:fill', ' position="', deltaLeft / width * arcScaleX * arcScaleX, ',', deltaTop / height * arcScaleY * arcScaleY, '"', ' type="tile"', ' src="', fillStyle.src_, '" />'); |
| } |
| } else { |
| var a = processStyle(ctx.fillStyle); |
| var color = a.color; |
| var opacity = a.alpha * ctx.globalAlpha; |
| lineStr.push('<g_vml_:fill color="', color, '" opacity="', opacity, '" />'); |
| } |
| } |
| contextPrototype.fill = function () { |
| this.stroke(true); |
| }; |
| contextPrototype.closePath = function () { |
| this.currentPath_.push({ type: 'close' }); |
| }; |
| function getCoords(ctx, aX, aY) { |
| var m = ctx.m_; |
| return { |
| x: Z * (aX * m[0][0] + aY * m[1][0] + m[2][0]) - Z2, |
| y: Z * (aX * m[0][1] + aY * m[1][1] + m[2][1]) - Z2 |
| }; |
| } |
| ; |
| contextPrototype.save = function () { |
| var o = {}; |
| copyState(this, o); |
| this.aStack_.push(o); |
| this.mStack_.push(this.m_); |
| this.m_ = matrixMultiply(createMatrixIdentity(), this.m_); |
| }; |
| contextPrototype.restore = function () { |
| if (this.aStack_.length) { |
| copyState(this.aStack_.pop(), this); |
| this.m_ = this.mStack_.pop(); |
| } |
| }; |
| function matrixIsFinite(m) { |
| return isFinite(m[0][0]) && isFinite(m[0][1]) && isFinite(m[1][0]) && isFinite(m[1][1]) && isFinite(m[2][0]) && isFinite(m[2][1]); |
| } |
| function setM(ctx, m, updateLineScale) { |
| if (!matrixIsFinite(m)) { |
| return; |
| } |
| ctx.m_ = m; |
| ctx.scaleX_ = Math.sqrt(m[0][0] * m[0][0] + m[0][1] * m[0][1]); |
| ctx.scaleY_ = Math.sqrt(m[1][0] * m[1][0] + m[1][1] * m[1][1]); |
| if (updateLineScale) { |
| var det = m[0][0] * m[1][1] - m[0][1] * m[1][0]; |
| ctx.lineScale_ = sqrt(abs(det)); |
| } |
| } |
| contextPrototype.translate = function (aX, aY) { |
| var m1 = [ |
| [ |
| 1, |
| 0, |
| 0 |
| ], |
| [ |
| 0, |
| 1, |
| 0 |
| ], |
| [ |
| aX, |
| aY, |
| 1 |
| ] |
| ]; |
| setM(this, matrixMultiply(m1, this.m_), false); |
| }; |
| contextPrototype.rotate = function (aRot) { |
| var c = mc(aRot); |
| var s = ms(aRot); |
| var m1 = [ |
| [ |
| c, |
| s, |
| 0 |
| ], |
| [ |
| -s, |
| c, |
| 0 |
| ], |
| [ |
| 0, |
| 0, |
| 1 |
| ] |
| ]; |
| setM(this, matrixMultiply(m1, this.m_), false); |
| }; |
| contextPrototype.scale = function (aX, aY) { |
| var m1 = [ |
| [ |
| aX, |
| 0, |
| 0 |
| ], |
| [ |
| 0, |
| aY, |
| 0 |
| ], |
| [ |
| 0, |
| 0, |
| 1 |
| ] |
| ]; |
| setM(this, matrixMultiply(m1, this.m_), true); |
| }; |
| contextPrototype.transform = function (m11, m12, m21, m22, dx, dy) { |
| var m1 = [ |
| [ |
| m11, |
| m12, |
| 0 |
| ], |
| [ |
| m21, |
| m22, |
| 0 |
| ], |
| [ |
| dx, |
| dy, |
| 1 |
| ] |
| ]; |
| setM(this, matrixMultiply(m1, this.m_), true); |
| }; |
| contextPrototype.setTransform = function (m11, m12, m21, m22, dx, dy) { |
| var m = [ |
| [ |
| m11, |
| m12, |
| 0 |
| ], |
| [ |
| m21, |
| m22, |
| 0 |
| ], |
| [ |
| dx, |
| dy, |
| 1 |
| ] |
| ]; |
| setM(this, m, true); |
| }; |
| contextPrototype.drawText_ = function (text, x, y, maxWidth, stroke) { |
| var m = this.m_, delta = 1000, left = 0, right = delta, offset = { |
| x: 0, |
| y: 0 |
| }, lineStr = []; |
| var fontStyle = getComputedStyle(processFontStyle(this.font), this.element_); |
| var fontStyleString = buildStyle(fontStyle); |
| var elementStyle = this.element_.currentStyle; |
| var textAlign = this.textAlign.toLowerCase(); |
| switch (textAlign) { |
| case 'left': |
| case 'center': |
| case 'right': |
| break; |
| case 'end': |
| textAlign = elementStyle.direction == 'ltr' ? 'right' : 'left'; |
| break; |
| case 'start': |
| textAlign = elementStyle.direction == 'rtl' ? 'right' : 'left'; |
| break; |
| default: |
| textAlign = 'left'; |
| } |
| switch (this.textBaseline) { |
| case 'hanging': |
| case 'top': |
| offset.y = fontStyle.size / 1.75; |
| break; |
| case 'middle': |
| break; |
| default: |
| case null: |
| case 'alphabetic': |
| case 'ideographic': |
| case 'bottom': |
| offset.y = -fontStyle.size / 2.25; |
| break; |
| } |
| switch (textAlign) { |
| case 'right': |
| left = delta; |
| right = 0.05; |
| break; |
| case 'center': |
| left = right = delta / 2; |
| break; |
| } |
| var d = getCoords(this, x + offset.x, y + offset.y); |
| lineStr.push('<g_vml_:line from="', -left, ' 0" to="', right, ' 0.05" ', ' coordsize="100 100" coordorigin="0 0"', ' filled="', !stroke, '" stroked="', !!stroke, '" style="position:absolute;width:1px;height:1px;">'); |
| if (stroke) { |
| appendStroke(this, lineStr); |
| } else { |
| appendFill(this, lineStr, { |
| x: -left, |
| y: 0 |
| }, { |
| x: right, |
| y: fontStyle.size |
| }); |
| } |
| var skewM = m[0][0].toFixed(3) + ',' + m[1][0].toFixed(3) + ',' + m[0][1].toFixed(3) + ',' + m[1][1].toFixed(3) + ',0,0'; |
| var skewOffset = mr(d.x / Z) + ',' + mr(d.y / Z); |
| lineStr.push('<g_vml_:skew on="t" matrix="', skewM, '" ', ' offset="', skewOffset, '" origin="', left, ' 0" />', '<g_vml_:path textpathok="true" />', '<g_vml_:textpath on="true" string="', encodeHtmlAttribute(text), '" style="v-text-align:', textAlign, ';font:', encodeHtmlAttribute(fontStyleString), '" /></g_vml_:line>'); |
| this.element_.insertAdjacentHTML('beforeEnd', lineStr.join('')); |
| }; |
| contextPrototype.fillText = function (text, x, y, maxWidth) { |
| this.drawText_(text, x, y, maxWidth, false); |
| }; |
| contextPrototype.strokeText = function (text, x, y, maxWidth) { |
| this.drawText_(text, x, y, maxWidth, true); |
| }; |
| contextPrototype.measureText = function (text) { |
| if (!this.textMeasureEl_) { |
| var s = '<span style="position:absolute;' + 'top:-20000px;left:0;padding:0;margin:0;border:none;' + 'white-space:pre;"></span>'; |
| this.element_.insertAdjacentHTML('beforeEnd', s); |
| this.textMeasureEl_ = this.element_.lastChild; |
| } |
| var doc = this.element_.ownerDocument; |
| this.textMeasureEl_.innerHTML = ''; |
| try { |
| this.textMeasureEl_.style.font = this.font; |
| } catch (ex) { |
| } |
| this.textMeasureEl_.appendChild(doc.createTextNode(text)); |
| return { width: this.textMeasureEl_.offsetWidth }; |
| }; |
| contextPrototype.clip = function () { |
| }; |
| contextPrototype.arcTo = function () { |
| }; |
| contextPrototype.createPattern = function (image, repetition) { |
| return new CanvasPattern_(image, repetition); |
| }; |
| function CanvasGradient_(aType) { |
| this.type_ = aType; |
| this.x0_ = 0; |
| this.y0_ = 0; |
| this.r0_ = 0; |
| this.x1_ = 0; |
| this.y1_ = 0; |
| this.r1_ = 0; |
| this.colors_ = []; |
| } |
| CanvasGradient_.prototype.addColorStop = function (aOffset, aColor) { |
| aColor = processStyle(aColor); |
| this.colors_.push({ |
| offset: aOffset, |
| color: aColor.color, |
| alpha: aColor.alpha |
| }); |
| }; |
| function CanvasPattern_(image, repetition) { |
| assertImageIsValid(image); |
| switch (repetition) { |
| case 'repeat': |
| case null: |
| case '': |
| this.repetition_ = 'repeat'; |
| break; |
| case 'repeat-x': |
| case 'repeat-y': |
| case 'no-repeat': |
| this.repetition_ = repetition; |
| break; |
| default: |
| throwException('SYNTAX_ERR'); |
| } |
| this.src_ = image.src; |
| this.width_ = image.width; |
| this.height_ = image.height; |
| } |
| function throwException(s) { |
| throw new DOMException_(s); |
| } |
| function assertImageIsValid(img) { |
| if (!img || img.nodeType != 1 || img.tagName != 'IMG') { |
| throwException('TYPE_MISMATCH_ERR'); |
| } |
| if (img.readyState != 'complete') { |
| throwException('INVALID_STATE_ERR'); |
| } |
| } |
| function DOMException_(s) { |
| this.code = this[s]; |
| this.message = s + ': DOM Exception ' + this.code; |
| } |
| var p = DOMException_.prototype = new Error(); |
| p.INDEX_SIZE_ERR = 1; |
| p.DOMSTRING_SIZE_ERR = 2; |
| p.HIERARCHY_REQUEST_ERR = 3; |
| p.WRONG_DOCUMENT_ERR = 4; |
| p.INVALID_CHARACTER_ERR = 5; |
| p.NO_DATA_ALLOWED_ERR = 6; |
| p.NO_MODIFICATION_ALLOWED_ERR = 7; |
| p.NOT_FOUND_ERR = 8; |
| p.NOT_SUPPORTED_ERR = 9; |
| p.INUSE_ATTRIBUTE_ERR = 10; |
| p.INVALID_STATE_ERR = 11; |
| p.SYNTAX_ERR = 12; |
| p.INVALID_MODIFICATION_ERR = 13; |
| p.NAMESPACE_ERR = 14; |
| p.INVALID_ACCESS_ERR = 15; |
| p.VALIDATION_ERR = 16; |
| p.TYPE_MISMATCH_ERR = 17; |
| G_vmlCanvasManager = G_vmlCanvasManager_; |
| CanvasRenderingContext2D = CanvasRenderingContext2D_; |
| CanvasGradient = CanvasGradient_; |
| CanvasPattern = CanvasPattern_; |
| DOMException = DOMException_; |
| }()); |
| } else { |
| G_vmlCanvasManager = false; |
| } |
| return G_vmlCanvasManager; |
| });define('zrender/mixin/Eventful', ['require'], function (require) { |
| var Eventful = function () { |
| this._handlers = {}; |
| }; |
| Eventful.prototype.one = function (event, handler, context) { |
| var _h = this._handlers; |
| if (!handler || !event) { |
| return this; |
| } |
| if (!_h[event]) { |
| _h[event] = []; |
| } |
| _h[event].push({ |
| h: handler, |
| one: true, |
| ctx: context || this |
| }); |
| return this; |
| }; |
| Eventful.prototype.bind = function (event, handler, context) { |
| var _h = this._handlers; |
| if (!handler || !event) { |
| return this; |
| } |
| if (!_h[event]) { |
| _h[event] = []; |
| } |
| _h[event].push({ |
| h: handler, |
| one: false, |
| ctx: context || this |
| }); |
| return this; |
| }; |
| Eventful.prototype.unbind = function (event, handler) { |
| var _h = this._handlers; |
| if (!event) { |
| this._handlers = {}; |
| return this; |
| } |
| if (handler) { |
| if (_h[event]) { |
| var newList = []; |
| for (var i = 0, l = _h[event].length; i < l; i++) { |
| if (_h[event][i]['h'] != handler) { |
| newList.push(_h[event][i]); |
| } |
| } |
| _h[event] = newList; |
| } |
| if (_h[event] && _h[event].length === 0) { |
| delete _h[event]; |
| } |
| } else { |
| delete _h[event]; |
| } |
| return this; |
| }; |
| Eventful.prototype.dispatch = function (type) { |
| if (this._handlers[type]) { |
| var args = arguments; |
| var argLen = args.length; |
| if (argLen > 3) { |
| args = Array.prototype.slice.call(args, 1); |
| } |
| var _h = this._handlers[type]; |
| var len = _h.length; |
| for (var i = 0; i < len;) { |
| switch (argLen) { |
| case 1: |
| _h[i]['h'].call(_h[i]['ctx']); |
| break; |
| case 2: |
| _h[i]['h'].call(_h[i]['ctx'], args[1]); |
| break; |
| case 3: |
| _h[i]['h'].call(_h[i]['ctx'], args[1], args[2]); |
| break; |
| default: |
| _h[i]['h'].apply(_h[i]['ctx'], args); |
| break; |
| } |
| if (_h[i]['one']) { |
| _h.splice(i, 1); |
| len--; |
| } else { |
| i++; |
| } |
| } |
| } |
| return this; |
| }; |
| Eventful.prototype.dispatchWithContext = function (type) { |
| if (this._handlers[type]) { |
| var args = arguments; |
| var argLen = args.length; |
| if (argLen > 4) { |
| args = Array.prototype.slice.call(args, 1, args.length - 1); |
| } |
| var ctx = args[args.length - 1]; |
| var _h = this._handlers[type]; |
| var len = _h.length; |
| for (var i = 0; i < len;) { |
| switch (argLen) { |
| case 1: |
| _h[i]['h'].call(ctx); |
| break; |
| case 2: |
| _h[i]['h'].call(ctx, args[1]); |
| break; |
| case 3: |
| _h[i]['h'].call(ctx, args[1], args[2]); |
| break; |
| default: |
| _h[i]['h'].apply(ctx, args); |
| break; |
| } |
| if (_h[i]['one']) { |
| _h.splice(i, 1); |
| len--; |
| } else { |
| i++; |
| } |
| } |
| } |
| return this; |
| }; |
| return Eventful; |
| });define('zrender/tool/log', [ |
| 'require', |
| '../config' |
| ], function (require) { |
| var config = require('../config'); |
| return function () { |
| if (config.debugMode === 0) { |
| return; |
| } else if (config.debugMode == 1) { |
| for (var k in arguments) { |
| throw new Error(arguments[k]); |
| } |
| } else if (config.debugMode > 1) { |
| for (var k in arguments) { |
| console.log(arguments[k]); |
| } |
| } |
| }; |
| });define('zrender/tool/guid', [], function () { |
| var idStart = 2311; |
| return function () { |
| return 'zrender__' + idStart++; |
| }; |
| });define('zrender/Handler', [ |
| 'require', |
| './config', |
| './tool/env', |
| './tool/event', |
| './tool/util', |
| './tool/vector', |
| './tool/matrix', |
| './mixin/Eventful' |
| ], function (require) { |
| 'use strict'; |
| var config = require('./config'); |
| var env = require('./tool/env'); |
| var eventTool = require('./tool/event'); |
| var util = require('./tool/util'); |
| var vec2 = require('./tool/vector'); |
| var mat2d = require('./tool/matrix'); |
| var EVENT = config.EVENT; |
| var Eventful = require('./mixin/Eventful'); |
| var domHandlerNames = [ |
| 'resize', |
| 'click', |
| 'dblclick', |
| 'mousewheel', |
| 'mousemove', |
| 'mouseout', |
| 'mouseup', |
| 'mousedown', |
| 'touchstart', |
| 'touchend', |
| 'touchmove' |
| ]; |
| var domHandlers = { |
| resize: function (event) { |
| event = event || window.event; |
| this._lastHover = null; |
| this._isMouseDown = 0; |
| this.dispatch(EVENT.RESIZE, event); |
| }, |
| click: function (event) { |
| event = this._zrenderEventFixed(event); |
| var _lastHover = this._lastHover; |
| if (_lastHover && _lastHover.clickable || !_lastHover) { |
| if (this._clickThreshold < 5) { |
| this._dispatchAgency(_lastHover, EVENT.CLICK, event); |
| } |
| } |
| this._mousemoveHandler(event); |
| }, |
| dblclick: function (event) { |
| event = event || window.event; |
| event = this._zrenderEventFixed(event); |
| var _lastHover = this._lastHover; |
| if (_lastHover && _lastHover.clickable || !_lastHover) { |
| if (this._clickThreshold < 5) { |
| this._dispatchAgency(_lastHover, EVENT.DBLCLICK, event); |
| } |
| } |
| this._mousemoveHandler(event); |
| }, |
| mousewheel: function (event) { |
| event = this._zrenderEventFixed(event); |
| var delta = event.wheelDelta || -event.detail; |
| var scale = delta > 0 ? 1.1 : 1 / 1.1; |
| var layers = this.painter.getLayers(); |
| var needsRefresh = false; |
| for (var z in layers) { |
| if (z !== 'hover') { |
| var layer = layers[z]; |
| var pos = layer.position; |
| if (layer.zoomable) { |
| layer.__zoom = layer.__zoom || 1; |
| var newZoom = layer.__zoom; |
| newZoom *= scale; |
| newZoom = Math.max(Math.min(layer.maxZoom, newZoom), layer.minZoom); |
| scale = newZoom / layer.__zoom; |
| layer.__zoom = newZoom; |
| pos[0] -= (this._mouseX - pos[0]) * (scale - 1); |
| pos[1] -= (this._mouseY - pos[1]) * (scale - 1); |
| layer.scale[0] *= scale; |
| layer.scale[1] *= scale; |
| layer.dirty = true; |
| needsRefresh = true; |
| eventTool.stop(event); |
| } |
| } |
| } |
| if (needsRefresh) { |
| this.painter.refresh(); |
| } |
| this._dispatchAgency(this._lastHover, EVENT.MOUSEWHEEL, event); |
| this._mousemoveHandler(event); |
| }, |
| mousemove: function (event) { |
| if (this.painter.isLoading()) { |
| return; |
| } |
| this._clickThreshold++; |
| event = this._zrenderEventFixed(event); |
| this._lastX = this._mouseX; |
| this._lastY = this._mouseY; |
| this._mouseX = eventTool.getX(event); |
| this._mouseY = eventTool.getY(event); |
| var dx = this._mouseX - this._lastX; |
| var dy = this._mouseY - this._lastY; |
| this._processDragStart(event); |
| this._hasfound = 0; |
| this._event = event; |
| this._iterateAndFindHover(); |
| if (!this._hasfound) { |
| if (!this._draggingTarget || this._lastHover && this._lastHover != this._draggingTarget) { |
| this._processOutShape(event); |
| this._processDragLeave(event); |
| } |
| this._lastHover = null; |
| this.storage.delHover(); |
| this.painter.clearHover(); |
| } |
| var cursor = 'default'; |
| if (this._draggingTarget) { |
| this.storage.drift(this._draggingTarget.id, dx, dy); |
| this._draggingTarget.modSelf(); |
| this.storage.addHover(this._draggingTarget); |
| } else if (this._isMouseDown) { |
| var layers = this.painter.getLayers(); |
| var needsRefresh = false; |
| for (var z in layers) { |
| if (z !== 'hover') { |
| var layer = layers[z]; |
| if (layer.panable) { |
| cursor = 'move'; |
| layer.position[0] += dx; |
| layer.position[1] += dy; |
| needsRefresh = true; |
| layer.dirty = true; |
| } |
| } |
| } |
| if (needsRefresh) { |
| this.painter.refresh(); |
| } |
| } |
| if (this._draggingTarget || this._hasfound && this._lastHover.draggable) { |
| cursor = 'move'; |
| } else if (this._hasfound && this._lastHover.clickable) { |
| cursor = 'pointer'; |
| } |
| this.root.style.cursor = cursor; |
| this._dispatchAgency(this._lastHover, EVENT.MOUSEMOVE, event); |
| if (this._draggingTarget || this._hasfound || this.storage.hasHoverShape()) { |
| this.painter.refreshHover(); |
| } |
| }, |
| mouseout: function (event) { |
| event = this._zrenderEventFixed(event); |
| var element = event.toElement || event.relatedTarget; |
| if (element != this.root) { |
| while (element && element.nodeType != 9) { |
| if (element == this.root) { |
| this._mousemoveHandler(event); |
| return; |
| } |
| element = element.parentNode; |
| } |
| } |
| event.zrenderX = this._lastX; |
| event.zrenderY = this._lastY; |
| this.root.style.cursor = 'default'; |
| this._isMouseDown = 0; |
| this._processOutShape(event); |
| this._processDrop(event); |
| this._processDragEnd(event); |
| if (!this.painter.isLoading()) { |
| this.painter.refreshHover(); |
| } |
| this.dispatch(EVENT.GLOBALOUT, event); |
| }, |
| mousedown: function (event) { |
| this._clickThreshold = 0; |
| if (this._lastDownButton == 2) { |
| this._lastDownButton = event.button; |
| this._mouseDownTarget = null; |
| return; |
| } |
| this._lastMouseDownMoment = new Date(); |
| event = this._zrenderEventFixed(event); |
| this._isMouseDown = 1; |
| this._mouseDownTarget = this._lastHover; |
| this._dispatchAgency(this._lastHover, EVENT.MOUSEDOWN, event); |
| this._lastDownButton = event.button; |
| }, |
| mouseup: function (event) { |
| event = this._zrenderEventFixed(event); |
| this.root.style.cursor = 'default'; |
| this._isMouseDown = 0; |
| this._clickThreshold = 0; |
| this._mouseDownTarget = null; |
| this._dispatchAgency(this._lastHover, EVENT.MOUSEUP, event); |
| this._processDrop(event); |
| this._processDragEnd(event); |
| }, |
| touchstart: function (event) { |
| event = this._zrenderEventFixed(event, true); |
| this._lastTouchMoment = new Date(); |
| this._mobildFindFixed(event); |
| this._mousedownHandler(event); |
| }, |
| touchmove: function (event) { |
| event = this._zrenderEventFixed(event, true); |
| this._mousemoveHandler(event); |
| if (this._isDragging) { |
| eventTool.stop(event); |
| } |
| }, |
| touchend: function (event) { |
| event = this._zrenderEventFixed(event, true); |
| this._mouseupHandler(event); |
| var now = new Date(); |
| if (now - this._lastTouchMoment < EVENT.touchClickDelay) { |
| this._mobildFindFixed(event); |
| this._clickHandler(event); |
| if (now - this._lastClickMoment < EVENT.touchClickDelay / 2) { |
| this._dblclickHandler(event); |
| if (this._lastHover && this._lastHover.clickable) { |
| eventTool.stop(event); |
| } |
| } |
| this._lastClickMoment = now; |
| } |
| this.painter.clearHover(); |
| } |
| }; |
| function bind1Arg(handler, context) { |
| return function (e) { |
| return handler.call(context, e); |
| }; |
| } |
| function bind3Arg(handler, context) { |
| return function (arg1, arg2, arg3) { |
| return handler.call(context, arg1, arg2, arg3); |
| }; |
| } |
| function initDomHandler(instance) { |
| var len = domHandlerNames.length; |
| while (len--) { |
| var name = domHandlerNames[len]; |
| instance['_' + name + 'Handler'] = bind1Arg(domHandlers[name], instance); |
| } |
| } |
| var Handler = function (root, storage, painter) { |
| Eventful.call(this); |
| this.root = root; |
| this.storage = storage; |
| this.painter = painter; |
| this._lastX = this._lastY = this._mouseX = this._mouseY = 0; |
| this._findHover = bind3Arg(findHover, this); |
| this._domHover = painter.getDomHover(); |
| initDomHandler(this); |
| if (window.addEventListener) { |
| window.addEventListener('resize', this._resizeHandler); |
| if (env.os.tablet || env.os.phone) { |
| root.addEventListener('touchstart', this._touchstartHandler); |
| root.addEventListener('touchmove', this._touchmoveHandler); |
| root.addEventListener('touchend', this._touchendHandler); |
| } else { |
| root.addEventListener('click', this._clickHandler); |
| root.addEventListener('dblclick', this._dblclickHandler); |
| root.addEventListener('mousewheel', this._mousewheelHandler); |
| root.addEventListener('mousemove', this._mousemoveHandler); |
| root.addEventListener('mousedown', this._mousedownHandler); |
| root.addEventListener('mouseup', this._mouseupHandler); |
| } |
| root.addEventListener('DOMMouseScroll', this._mousewheelHandler); |
| root.addEventListener('mouseout', this._mouseoutHandler); |
| } else { |
| window.attachEvent('onresize', this._resizeHandler); |
| root.attachEvent('onclick', this._clickHandler); |
| root.ondblclick = this._dblclickHandler; |
| root.attachEvent('onmousewheel', this._mousewheelHandler); |
| root.attachEvent('onmousemove', this._mousemoveHandler); |
| root.attachEvent('onmouseout', this._mouseoutHandler); |
| root.attachEvent('onmousedown', this._mousedownHandler); |
| root.attachEvent('onmouseup', this._mouseupHandler); |
| } |
| }; |
| Handler.prototype.on = function (eventName, handler) { |
| this.bind(eventName, handler); |
| return this; |
| }; |
| Handler.prototype.un = function (eventName, handler) { |
| this.unbind(eventName, handler); |
| return this; |
| }; |
| Handler.prototype.trigger = function (eventName, eventArgs) { |
| switch (eventName) { |
| case EVENT.RESIZE: |
| case EVENT.CLICK: |
| case EVENT.DBLCLICK: |
| case EVENT.MOUSEWHEEL: |
| case EVENT.MOUSEMOVE: |
| case EVENT.MOUSEDOWN: |
| case EVENT.MOUSEUP: |
| case EVENT.MOUSEOUT: |
| this['_' + eventName + 'Handler'](eventArgs); |
| break; |
| } |
| }; |
| Handler.prototype.dispose = function () { |
| var root = this.root; |
| if (window.removeEventListener) { |
| window.removeEventListener('resize', this._resizeHandler); |
| if (env.os.tablet || env.os.phone) { |
| root.removeEventListener('touchstart', this._touchstartHandler); |
| root.removeEventListener('touchmove', this._touchmoveHandler); |
| root.removeEventListener('touchend', this._touchendHandler); |
| } else { |
| root.removeEventListener('click', this._clickHandler); |
| root.removeEventListener('dblclick', this._dblclickHandler); |
| root.removeEventListener('mousewheel', this._mousewheelHandler); |
| root.removeEventListener('mousemove', this._mousemoveHandler); |
| root.removeEventListener('mousedown', this._mousedownHandler); |
| root.removeEventListener('mouseup', this._mouseupHandler); |
| } |
| root.removeEventListener('DOMMouseScroll', this._mousewheelHandler); |
| root.removeEventListener('mouseout', this._mouseoutHandler); |
| } else { |
| window.detachEvent('onresize', this._resizeHandler); |
| root.detachEvent('onclick', this._clickHandler); |
| root.detachEvent('dblclick', this._dblclickHandler); |
| root.detachEvent('onmousewheel', this._mousewheelHandler); |
| root.detachEvent('onmousemove', this._mousemoveHandler); |
| root.detachEvent('onmouseout', this._mouseoutHandler); |
| root.detachEvent('onmousedown', this._mousedownHandler); |
| root.detachEvent('onmouseup', this._mouseupHandler); |
| } |
| this.root = this._domHover = this.storage = this.painter = null; |
| this.un(); |
| }; |
| Handler.prototype._processDragStart = function (event) { |
| var _lastHover = this._lastHover; |
| if (this._isMouseDown && _lastHover && _lastHover.draggable && !this._draggingTarget && this._mouseDownTarget == _lastHover) { |
| if (_lastHover.dragEnableTime && new Date() - this._lastMouseDownMoment < _lastHover.dragEnableTime) { |
| return; |
| } |
| var _draggingTarget = _lastHover; |
| this._draggingTarget = _draggingTarget; |
| this._isDragging = 1; |
| _draggingTarget.invisible = true; |
| this.storage.mod(_draggingTarget.id); |
| this._dispatchAgency(_draggingTarget, EVENT.DRAGSTART, event); |
| this.painter.refresh(); |
| } |
| }; |
| Handler.prototype._processDragEnter = function (event) { |
| if (this._draggingTarget) { |
| this._dispatchAgency(this._lastHover, EVENT.DRAGENTER, event, this._draggingTarget); |
| } |
| }; |
| Handler.prototype._processDragOver = function (event) { |
| if (this._draggingTarget) { |
| this._dispatchAgency(this._lastHover, EVENT.DRAGOVER, event, this._draggingTarget); |
| } |
| }; |
| Handler.prototype._processDragLeave = function (event) { |
| if (this._draggingTarget) { |
| this._dispatchAgency(this._lastHover, EVENT.DRAGLEAVE, event, this._draggingTarget); |
| } |
| }; |
| Handler.prototype._processDrop = function (event) { |
| if (this._draggingTarget) { |
| this._draggingTarget.invisible = false; |
| this.storage.mod(this._draggingTarget.id); |
| this.painter.refresh(); |
| this._dispatchAgency(this._lastHover, EVENT.DROP, event, this._draggingTarget); |
| } |
| }; |
| Handler.prototype._processDragEnd = function (event) { |
| if (this._draggingTarget) { |
| this._dispatchAgency(this._draggingTarget, EVENT.DRAGEND, event); |
| this._lastHover = null; |
| } |
| this._isDragging = 0; |
| this._draggingTarget = null; |
| }; |
| Handler.prototype._processOverShape = function (event) { |
| this._dispatchAgency(this._lastHover, EVENT.MOUSEOVER, event); |
| }; |
| Handler.prototype._processOutShape = function (event) { |
| this._dispatchAgency(this._lastHover, EVENT.MOUSEOUT, event); |
| }; |
| Handler.prototype._dispatchAgency = function (targetShape, eventName, event, draggedShape) { |
| var eventHandler = 'on' + eventName; |
| var eventPacket = { |
| type: eventName, |
| event: event, |
| target: targetShape, |
| cancelBubble: false |
| }; |
| var el = targetShape; |
| if (draggedShape) { |
| eventPacket.dragged = draggedShape; |
| } |
| while (el) { |
| el[eventHandler] && (eventPacket.cancelBubble = el[eventHandler](eventPacket)); |
| el.dispatch(eventName, eventPacket); |
| el = el.parent; |
| if (eventPacket.cancelBubble) { |
| break; |
| } |
| } |
| if (targetShape) { |
| if (!eventPacket.cancelBubble) { |
| this.dispatch(eventName, eventPacket); |
| } |
| } else if (!draggedShape) { |
| this.dispatch(eventName, { |
| type: eventName, |
| event: event |
| }); |
| } |
| }; |
| Handler.prototype._iterateAndFindHover = function () { |
| var invTransform = mat2d.create(); |
| return function () { |
| var list = this.storage.getShapeList(); |
| var currentZLevel; |
| var currentLayer; |
| var tmp = [ |
| 0, |
| 0 |
| ]; |
| for (var i = list.length - 1; i >= 0; i--) { |
| var shape = list[i]; |
| if (currentZLevel !== shape.zlevel) { |
| currentLayer = this.painter.getLayer(shape.zlevel, currentLayer); |
| tmp[0] = this._mouseX; |
| tmp[1] = this._mouseY; |
| if (currentLayer.needTransform) { |
| mat2d.invert(invTransform, currentLayer.transform); |
| vec2.applyTransform(tmp, tmp, invTransform); |
| } |
| } |
| if (this._findHover(shape, tmp[0], tmp[1])) { |
| break; |
| } |
| } |
| }; |
| }(); |
| var MOBILE_TOUCH_OFFSETS = [ |
| { x: 10 }, |
| { x: -20 }, |
| { |
| x: 10, |
| y: 10 |
| }, |
| { y: -20 } |
| ]; |
| Handler.prototype._mobildFindFixed = function (event) { |
| this._lastHover = null; |
| this._mouseX = event.zrenderX; |
| this._mouseY = event.zrenderY; |
| this._event = event; |
| this._iterateAndFindHover(); |
| for (var i = 0; !this._lastHover && i < MOBILE_TOUCH_OFFSETS.length; i++) { |
| var offset = MOBILE_TOUCH_OFFSETS[i]; |
| offset.x && (this._mouseX += offset.x); |
| offset.y && (this._mouseX += offset.y); |
| this._iterateAndFindHover(); |
| } |
| if (this._lastHover) { |
| event.zrenderX = this._mouseX; |
| event.zrenderY = this._mouseY; |
| } |
| }; |
| function findHover(shape, x, y) { |
| if (this._draggingTarget && this._draggingTarget.id == shape.id || shape.isSilent()) { |
| return false; |
| } |
| var event = this._event; |
| if (shape.isCover(x, y)) { |
| if (shape.hoverable) { |
| this.storage.addHover(shape); |
| } |
| var p = shape.parent; |
| while (p) { |
| if (p.clipShape && !p.clipShape.isCover(this._mouseX, this._mouseY)) { |
| return false; |
| } |
| p = p.parent; |
| } |
| if (this._lastHover != shape) { |
| this._processOutShape(event); |
| this._processDragLeave(event); |
| this._lastHover = shape; |
| this._processDragEnter(event); |
| } |
| this._processOverShape(event); |
| this._processDragOver(event); |
| this._hasfound = 1; |
| return true; |
| } |
| return false; |
| } |
| Handler.prototype._zrenderEventFixed = function (event, isTouch) { |
| if (event.zrenderFixed) { |
| return event; |
| } |
| if (!isTouch) { |
| event = event || window.event; |
| var target = event.toElement || event.relatedTarget || event.srcElement || event.target; |
| if (target && target != this._domHover) { |
| event.zrenderX = (typeof event.offsetX != 'undefined' ? event.offsetX : event.layerX) + target.offsetLeft; |
| event.zrenderY = (typeof event.offsetY != 'undefined' ? event.offsetY : event.layerY) + target.offsetTop; |
| } |
| } else { |
| var touch = event.type != 'touchend' ? event.targetTouches[0] : event.changedTouches[0]; |
| if (touch) { |
| var rBounding = this.root.getBoundingClientRect(); |
| event.zrenderX = touch.clientX - rBounding.left; |
| event.zrenderY = touch.clientY - rBounding.top; |
| } |
| } |
| event.zrenderFixed = 1; |
| return event; |
| }; |
| util.merge(Handler.prototype, Eventful.prototype, true); |
| return Handler; |
| });define('zrender/Painter', [ |
| 'require', |
| './config', |
| './tool/util', |
| './tool/log', |
| './tool/matrix', |
| './loadingEffect/Base', |
| './mixin/Transformable', |
| './shape/Image' |
| ], function (require) { |
| 'use strict'; |
| var config = require('./config'); |
| var util = require('./tool/util'); |
| var log = require('./tool/log'); |
| var matrix = require('./tool/matrix'); |
| var BaseLoadingEffect = require('./loadingEffect/Base'); |
| var Transformable = require('./mixin/Transformable'); |
| var devicePixelRatio = window.devicePixelRatio || 1; |
| devicePixelRatio = Math.max(devicePixelRatio, 1); |
| var vmlCanvasManager = window['G_vmlCanvasManager']; |
| function returnFalse() { |
| return false; |
| } |
| function doNothing() { |
| } |
| var Painter = function (root, storage) { |
| this.root = root; |
| this.storage = storage; |
| root.innerHTML = ''; |
| this._width = this._getWidth(); |
| this._height = this._getHeight(); |
| var domRoot = document.createElement('div'); |
| this._domRoot = domRoot; |
| domRoot.style.position = 'relative'; |
| domRoot.style.overflow = 'hidden'; |
| domRoot.style.width = this._width + 'px'; |
| domRoot.style.height = this._height + 'px'; |
| root.appendChild(domRoot); |
| this._layers = {}; |
| this._zlevelList = []; |
| this._layerConfig = {}; |
| this._loadingEffect = new BaseLoadingEffect({}); |
| this.shapeToImage = this._createShapeToImageProcessor(); |
| this._bgDom = createDom('bg', 'div', this); |
| domRoot.appendChild(this._bgDom); |
| this._bgDom.onselectstart = returnFalse; |
| this._bgDom.style['-webkit-user-select'] = 'none'; |
| this._bgDom.style['user-select'] = 'none'; |
| this._bgDom.style['-webkit-touch-callout'] = 'none'; |
| var hoverLayer = new Layer('_zrender_hover_', this); |
| this._layers['hover'] = hoverLayer; |
| domRoot.appendChild(hoverLayer.dom); |
| hoverLayer.initContext(); |
| hoverLayer.dom.onselectstart = returnFalse; |
| hoverLayer.dom.style['-webkit-user-select'] = 'none'; |
| hoverLayer.dom.style['user-select'] = 'none'; |
| hoverLayer.dom.style['-webkit-touch-callout'] = 'none'; |
| this.refreshNextFrame = null; |
| }; |
| Painter.prototype.render = function (callback) { |
| if (this.isLoading()) { |
| this.hideLoading(); |
| } |
| this.refresh(callback, true); |
| return this; |
| }; |
| Painter.prototype.refresh = function (callback, paintAll) { |
| var list = this.storage.getShapeList(true); |
| this._paintList(list, paintAll); |
| if (typeof callback == 'function') { |
| callback(); |
| } |
| return this; |
| }; |
| Painter.prototype._paintList = function (list, paintAll) { |
| if (typeof paintAll == 'undefined') { |
| paintAll = false; |
| } |
| this._updateLayerStatus(list); |
| var currentLayer; |
| var currentZLevel; |
| var ctx; |
| for (var id in this._layers) { |
| if (id !== 'hover') { |
| this._layers[id].unusedCount++; |
| this._layers[id].updateTransform(); |
| } |
| } |
| var invTransform = []; |
| for (var i = 0, l = list.length; i < l; i++) { |
| var shape = list[i]; |
| if (currentZLevel !== shape.zlevel) { |
| if (currentLayer) { |
| if (currentLayer.needTransform) { |
| ctx.restore(); |
| } |
| ctx.flush && ctx.flush(); |
| } |
| currentLayer = this.getLayer(shape.zlevel); |
| ctx = currentLayer.ctx; |
| currentZLevel = shape.zlevel; |
| currentLayer.unusedCount = 0; |
| if (currentLayer.dirty || paintAll) { |
| currentLayer.clear(); |
| } |
| if (currentLayer.needTransform) { |
| ctx.save(); |
| currentLayer.setTransform(ctx); |
| } |
| } |
| if (shape.__startClip && !vmlCanvasManager) { |
| var clipShape = shape.__startClip; |
| ctx.save(); |
| if (clipShape.needTransform) { |
| var m = clipShape.transform; |
| matrix.invert(invTransform, m); |
| ctx.transform(m[0], m[1], m[2], m[3], m[4], m[5]); |
| } |
| ctx.beginPath(); |
| clipShape.buildPath(ctx, clipShape.style); |
| ctx.clip(); |
| if (clipShape.needTransform) { |
| var m = invTransform; |
| ctx.transform(m[0], m[1], m[2], m[3], m[4], m[5]); |
| } |
| } |
| if ((currentLayer.dirty || paintAll) && !shape.invisible) { |
| if (!shape.onbrush || shape.onbrush && !shape.onbrush(ctx, false)) { |
| if (config.catchBrushException) { |
| try { |
| shape.brush(ctx, false, this.refreshNextFrame); |
| } catch (error) { |
| log(error, 'brush error of ' + shape.type, shape); |
| } |
| } else { |
| shape.brush(ctx, false, this.refreshNextFrame); |
| } |
| } |
| } |
| if (shape.__stopClip && !vmlCanvasManager) { |
| ctx.restore(); |
| } |
| shape.__dirty = false; |
| } |
| if (currentLayer) { |
| if (currentLayer.needTransform) { |
| ctx.restore(); |
| } |
| ctx.flush && ctx.flush(); |
| } |
| for (var id in this._layers) { |
| if (id !== 'hover') { |
| var layer = this._layers[id]; |
| layer.dirty = false; |
| if (layer.unusedCount == 1) { |
| layer.clear(); |
| } |
| } |
| } |
| }; |
| Painter.prototype.getLayer = function (zlevel) { |
| var currentLayer = this._layers[zlevel]; |
| if (!currentLayer) { |
| var len = this._zlevelList.length; |
| var prevLayer = null; |
| var i = -1; |
| if (len > 0 && zlevel > this._zlevelList[0]) { |
| for (i = 0; i < len - 1; i++) { |
| if (this._zlevelList[i] < zlevel && this._zlevelList[i + 1] > zlevel) { |
| break; |
| } |
| } |
| prevLayer = this._layers[this._zlevelList[i]]; |
| } |
| this._zlevelList.splice(i + 1, 0, zlevel); |
| currentLayer = new Layer(zlevel, this); |
| var prevDom = prevLayer ? prevLayer.dom : this._bgDom; |
| if (prevDom.nextSibling) { |
| prevDom.parentNode.insertBefore(currentLayer.dom, prevDom.nextSibling); |
| } else { |
| prevDom.parentNode.appendChild(currentLayer.dom); |
| } |
| currentLayer.initContext(); |
| this._layers[zlevel] = currentLayer; |
| if (this._layerConfig[zlevel]) { |
| util.merge(currentLayer, this._layerConfig[zlevel], true); |
| } |
| currentLayer.updateTransform(); |
| } |
| return currentLayer; |
| }; |
| Painter.prototype.getLayers = function () { |
| return this._layers; |
| }; |
| Painter.prototype._updateLayerStatus = function (list) { |
| var layers = this._layers; |
| var elCounts = {}; |
| for (var z in layers) { |
| if (z !== 'hover') { |
| elCounts[z] = layers[z].elCount; |
| layers[z].elCount = 0; |
| } |
| } |
| for (var i = 0, l = list.length; i < l; i++) { |
| var shape = list[i]; |
| var zlevel = shape.zlevel; |
| var layer = layers[zlevel]; |
| if (layer) { |
| layer.elCount++; |
| if (layer.dirty) { |
| continue; |
| } |
| layer.dirty = shape.__dirty; |
| } |
| } |
| for (var z in layers) { |
| if (z !== 'hover') { |
| if (elCounts[z] !== layers[z].elCount) { |
| layers[z].dirty = true; |
| } |
| } |
| } |
| }; |
| Painter.prototype.refreshShapes = function (shapeList, callback) { |
| for (var i = 0, l = shapeList.length; i < l; i++) { |
| var shape = shapeList[i]; |
| shape.modSelf(); |
| } |
| this.refresh(callback); |
| return this; |
| }; |
| Painter.prototype.setLoadingEffect = function (loadingEffect) { |
| this._loadingEffect = loadingEffect; |
| return this; |
| }; |
| Painter.prototype.clear = function () { |
| for (var k in this._layers) { |
| if (k == 'hover') { |
| continue; |
| } |
| this._layers[k].clear(); |
| } |
| return this; |
| }; |
| Painter.prototype.modLayer = function (zlevel, config) { |
| if (config) { |
| if (!this._layerConfig[zlevel]) { |
| this._layerConfig[zlevel] = config; |
| } else { |
| util.merge(this._layerConfig[zlevel], config, true); |
| } |
| var layer = this._layers[zlevel]; |
| if (layer) { |
| util.merge(layer, this._layerConfig[zlevel], true); |
| } |
| } |
| }; |
| Painter.prototype.delLayer = function (zlevel) { |
| var layer = this._layers[zlevel]; |
| if (!layer) { |
| return; |
| } |
| this.modLayer(zlevel, { |
| position: layer.position, |
| rotation: layer.rotation, |
| scale: layer.scale |
| }); |
| layer.dom.parentNode.removeChild(layer.dom); |
| delete this._layers[zlevel]; |
| this._zlevelList.splice(util.indexOf(this._zlevelList, zlevel), 1); |
| }; |
| Painter.prototype.refreshHover = function () { |
| this.clearHover(); |
| var list = this.storage.getHoverShapes(true); |
| for (var i = 0, l = list.length; i < l; i++) { |
| this._brushHover(list[i]); |
| } |
| var ctx = this._layers.hover.ctx; |
| ctx.flush && ctx.flush(); |
| this.storage.delHover(); |
| return this; |
| }; |
| Painter.prototype.clearHover = function () { |
| var hover = this._layers.hover; |
| hover && hover.clear(); |
| return this; |
| }; |
| Painter.prototype.showLoading = function (loadingEffect) { |
| this._loadingEffect && this._loadingEffect.stop(); |
| loadingEffect && this.setLoadingEffect(loadingEffect); |
| this._loadingEffect.start(this); |
| this.loading = true; |
| return this; |
| }; |
| Painter.prototype.hideLoading = function () { |
| this._loadingEffect.stop(); |
| this.clearHover(); |
| this.loading = false; |
| return this; |
| }; |
| Painter.prototype.isLoading = function () { |
| return this.loading; |
| }; |
| Painter.prototype.resize = function () { |
| var domRoot = this._domRoot; |
| domRoot.style.display = 'none'; |
| var width = this._getWidth(); |
| var height = this._getHeight(); |
| domRoot.style.display = ''; |
| if (this._width != width || height != this._height) { |
| this._width = width; |
| this._height = height; |
| domRoot.style.width = width + 'px'; |
| domRoot.style.height = height + 'px'; |
| for (var id in this._layers) { |
| this._layers[id].resize(width, height); |
| } |
| this.refresh(null, true); |
| } |
| return this; |
| }; |
| Painter.prototype.clearLayer = function (zLevel) { |
| var layer = this._layers[zLevel]; |
| if (layer) { |
| layer.clear(); |
| } |
| }; |
| Painter.prototype.dispose = function () { |
| if (this.isLoading()) { |
| this.hideLoading(); |
| } |
| this.root.innerHTML = ''; |
| this.root = this.storage = this._domRoot = this._layers = null; |
| }; |
| Painter.prototype.getDomHover = function () { |
| return this._layers.hover.dom; |
| }; |
| Painter.prototype.toDataURL = function (type, backgroundColor, args) { |
| if (vmlCanvasManager) { |
| return null; |
| } |
| var imageDom = createDom('image', 'canvas', this); |
| this._bgDom.appendChild(imageDom); |
| var ctx = imageDom.getContext('2d'); |
| devicePixelRatio != 1 && ctx.scale(devicePixelRatio, devicePixelRatio); |
| ctx.fillStyle = backgroundColor || '#fff'; |
| ctx.rect(0, 0, this._width * devicePixelRatio, this._height * devicePixelRatio); |
| ctx.fill(); |
| var self = this; |
| this.storage.iterShape(function (shape) { |
| if (!shape.invisible) { |
| if (!shape.onbrush || shape.onbrush && !shape.onbrush(ctx, false)) { |
| if (config.catchBrushException) { |
| try { |
| shape.brush(ctx, false, self.refreshNextFrame); |
| } catch (error) { |
| log(error, 'brush error of ' + shape.type, shape); |
| } |
| } else { |
| shape.brush(ctx, false, self.refreshNextFrame); |
| } |
| } |
| } |
| }, { |
| normal: 'up', |
| update: true |
| }); |
| var image = imageDom.toDataURL(type, args); |
| ctx = null; |
| this._bgDom.removeChild(imageDom); |
| return image; |
| }; |
| Painter.prototype.getWidth = function () { |
| return this._width; |
| }; |
| Painter.prototype.getHeight = function () { |
| return this._height; |
| }; |
| Painter.prototype._getWidth = function () { |
| var root = this.root; |
| var stl = root.currentStyle || document.defaultView.getComputedStyle(root); |
| return ((root.clientWidth || parseInt(stl.width, 10)) - parseInt(stl.paddingLeft, 10) - parseInt(stl.paddingRight, 10)).toFixed(0) - 0; |
| }; |
| Painter.prototype._getHeight = function () { |
| var root = this.root; |
| var stl = root.currentStyle || document.defaultView.getComputedStyle(root); |
| return ((root.clientHeight || parseInt(stl.height, 10)) - parseInt(stl.paddingTop, 10) - parseInt(stl.paddingBottom, 10)).toFixed(0) - 0; |
| }; |
| Painter.prototype._brushHover = function (shape) { |
| var ctx = this._layers.hover.ctx; |
| if (!shape.onbrush || shape.onbrush && !shape.onbrush(ctx, true)) { |
| var layer = this.getLayer(shape.zlevel); |
| if (layer.needTransform) { |
| ctx.save(); |
| layer.setTransform(ctx); |
| } |
| if (config.catchBrushException) { |
| try { |
| shape.brush(ctx, true, this.refreshNextFrame); |
| } catch (error) { |
| log(error, 'hoverBrush error of ' + shape.type, shape); |
| } |
| } else { |
| shape.brush(ctx, true, this.refreshNextFrame); |
| } |
| if (layer.needTransform) { |
| ctx.restore(); |
| } |
| } |
| }; |
| Painter.prototype._shapeToImage = function (id, shape, width, height, devicePixelRatio) { |
| var canvas = document.createElement('canvas'); |
| var ctx = canvas.getContext('2d'); |
| var devicePixelRatio = window.devicePixelRatio || 1; |
| canvas.style.width = width + 'px'; |
| canvas.style.height = height + 'px'; |
| canvas.setAttribute('width', width * devicePixelRatio); |
| canvas.setAttribute('height', height * devicePixelRatio); |
| ctx.clearRect(0, 0, width * devicePixelRatio, height * devicePixelRatio); |
| var shapeTransform = { |
| position: shape.position, |
| rotation: shape.rotation, |
| scale: shape.scale |
| }; |
| shape.position = [ |
| 0, |
| 0, |
| 0 |
| ]; |
| shape.rotation = 0; |
| shape.scale = [ |
| 1, |
| 1 |
| ]; |
| if (shape) { |
| shape.brush(ctx, false); |
| } |
| var ImageShape = require('./shape/Image'); |
| var imgShape = new ImageShape({ |
| id: id, |
| style: { |
| x: 0, |
| y: 0, |
| image: canvas |
| } |
| }); |
| if (shapeTransform.position != null) { |
| imgShape.position = shape.position = shapeTransform.position; |
| } |
| if (shapeTransform.rotation != null) { |
| imgShape.rotation = shape.rotation = shapeTransform.rotation; |
| } |
| if (shapeTransform.scale != null) { |
| imgShape.scale = shape.scale = shapeTransform.scale; |
| } |
| return imgShape; |
| }; |
| Painter.prototype._createShapeToImageProcessor = function () { |
| if (vmlCanvasManager) { |
| return doNothing; |
| } |
| var me = this; |
| return function (id, e, width, height) { |
| return me._shapeToImage(id, e, width, height, devicePixelRatio); |
| }; |
| }; |
| function createDom(id, type, painter) { |
| var newDom = document.createElement(type); |
| var width = painter._width; |
| var height = painter._height; |
| newDom.style.position = 'absolute'; |
| newDom.style.left = 0; |
| newDom.style.top = 0; |
| newDom.style.width = width + 'px'; |
| newDom.style.height = height + 'px'; |
| newDom.setAttribute('width', width * devicePixelRatio); |
| newDom.setAttribute('height', height * devicePixelRatio); |
| newDom.setAttribute('data-zr-dom-id', id); |
| return newDom; |
| } |
| var Layer = function (id, painter) { |
| this.dom = createDom(id, 'canvas', painter); |
| this.dom.onselectstart = returnFalse; |
| this.dom.style['-webkit-user-select'] = 'none'; |
| this.dom.style['user-select'] = 'none'; |
| this.dom.style['-webkit-touch-callout'] = 'none'; |
| vmlCanvasManager && vmlCanvasManager.initElement(this.dom); |
| this.domBack = null; |
| this.ctxBack = null; |
| this.painter = painter; |
| this.unusedCount = 0; |
| this.config = null; |
| this.dirty = true; |
| this.elCount = 0; |
| this.clearColor = 0; |
| this.motionBlur = false; |
| this.lastFrameAlpha = 0.7; |
| this.zoomable = false; |
| this.panable = false; |
| this.maxZoom = Infinity; |
| this.minZoom = 0; |
| Transformable.call(this); |
| }; |
| Layer.prototype.initContext = function () { |
| this.ctx = this.dom.getContext('2d'); |
| if (devicePixelRatio != 1) { |
| this.ctx.scale(devicePixelRatio, devicePixelRatio); |
| } |
| }; |
| Layer.prototype.createBackBuffer = function () { |
| if (vmlCanvasManager) { |
| return; |
| } |
| this.domBack = createDom('back-' + this.id, 'canvas', this.painter); |
| this.ctxBack = this.domBack.getContext('2d'); |
| if (devicePixelRatio != 1) { |
| this.ctxBack.scale(devicePixelRatio, devicePixelRatio); |
| } |
| }; |
| Layer.prototype.resize = function (width, height) { |
| this.dom.style.width = width + 'px'; |
| this.dom.style.height = height + 'px'; |
| this.dom.setAttribute('width', width * devicePixelRatio); |
| this.dom.setAttribute('height', height * devicePixelRatio); |
| if (devicePixelRatio != 1) { |
| this.ctx.scale(devicePixelRatio, devicePixelRatio); |
| } |
| if (this.domBack) { |
| this.domBack.setAttribute('width', width * devicePixelRatio); |
| this.domBack.setAttribute('height', height * devicePixelRatio); |
| if (devicePixelRatio != 1) { |
| this.ctxBack.scale(devicePixelRatio, devicePixelRatio); |
| } |
| } |
| }; |
| Layer.prototype.clear = function () { |
| var dom = this.dom; |
| var ctx = this.ctx; |
| var width = dom.width; |
| var height = dom.height; |
| var haveClearColor = this.clearColor && !vmlCanvasManager; |
| var haveMotionBLur = this.motionBlur && !vmlCanvasManager; |
| var lastFrameAlpha = this.lastFrameAlpha; |
| if (haveMotionBLur) { |
| if (!this.domBack) { |
| this.createBackBuffer(); |
| } |
| this.ctxBack.globalCompositeOperation = 'copy'; |
| this.ctxBack.drawImage(dom, 0, 0, width / devicePixelRatio, height / devicePixelRatio); |
| } |
| if (haveClearColor) { |
| ctx.save(); |
| ctx.fillStyle = this.config.clearColor; |
| ctx.fillRect(0, 0, width / devicePixelRatio, height / devicePixelRatio); |
| ctx.restore(); |
| } else { |
| ctx.clearRect(0, 0, width / devicePixelRatio, height / devicePixelRatio); |
| } |
| if (haveMotionBLur) { |
| var domBack = this.domBack; |
| ctx.save(); |
| ctx.globalAlpha = lastFrameAlpha; |
| ctx.drawImage(domBack, 0, 0, width / devicePixelRatio, height / devicePixelRatio); |
| ctx.restore(); |
| } |
| }; |
| util.merge(Layer.prototype, Transformable.prototype); |
| return Painter; |
| });define('zrender/Storage', [ |
| 'require', |
| './tool/util', |
| './Group' |
| ], function (require) { |
| 'use strict'; |
| var util = require('./tool/util'); |
| var Group = require('./Group'); |
| var defaultIterateOption = { |
| hover: false, |
| normal: 'down', |
| update: false |
| }; |
| function shapeCompareFunc(a, b) { |
| if (a.zlevel == b.zlevel) { |
| if (a.z == b.z) { |
| return a.__renderidx - b.__renderidx; |
| } |
| return a.z - b.z; |
| } |
| return a.zlevel - b.zlevel; |
| } |
| var Storage = function () { |
| this._elements = {}; |
| this._hoverElements = []; |
| this._roots = []; |
| this._shapeList = []; |
| this._shapeListOffset = 0; |
| }; |
| Storage.prototype.iterShape = function (fun, option) { |
| if (!option) { |
| option = defaultIterateOption; |
| } |
| if (option.hover) { |
| for (var i = 0, l = this._hoverElements.length; i < l; i++) { |
| var el = this._hoverElements[i]; |
| el.updateTransform(); |
| if (fun(el)) { |
| return this; |
| } |
| } |
| } |
| if (option.update) { |
| this.updateShapeList(); |
| } |
| switch (option.normal) { |
| case 'down': |
| var l = this._shapeList.length; |
| while (l--) { |
| if (fun(this._shapeList[l])) { |
| return this; |
| } |
| } |
| break; |
| default: |
| for (var i = 0, l = this._shapeList.length; i < l; i++) { |
| if (fun(this._shapeList[i])) { |
| return this; |
| } |
| } |
| break; |
| } |
| return this; |
| }; |
| Storage.prototype.getHoverShapes = function (update) { |
| var hoverElements = []; |
| for (var i = 0, l = this._hoverElements.length; i < l; i++) { |
| hoverElements.push(this._hoverElements[i]); |
| var target = this._hoverElements[i].hoverConnect; |
| if (target) { |
| var shape; |
| target = target instanceof Array ? target : [target]; |
| for (var j = 0, k = target.length; j < k; j++) { |
| shape = target[j].id ? target[j] : this.get(target[j]); |
| if (shape) { |
| hoverElements.push(shape); |
| } |
| } |
| } |
| } |
| hoverElements.sort(shapeCompareFunc); |
| if (update) { |
| for (var i = 0, l = hoverElements.length; i < l; i++) { |
| hoverElements[i].updateTransform(); |
| } |
| } |
| return hoverElements; |
| }; |
| Storage.prototype.getShapeList = function (update) { |
| if (update) { |
| this.updateShapeList(); |
| } |
| return this._shapeList; |
| }; |
| Storage.prototype.updateShapeList = function () { |
| this._shapeListOffset = 0; |
| for (var i = 0, len = this._roots.length; i < len; i++) { |
| var root = this._roots[i]; |
| this._updateAndAddShape(root); |
| } |
| this._shapeList.length = this._shapeListOffset; |
| for (var i = 0, len = this._shapeList.length; i < len; i++) { |
| this._shapeList[i].__renderidx = i; |
| } |
| this._shapeList.sort(shapeCompareFunc); |
| }; |
| Storage.prototype._updateAndAddShape = function (el, clipShapes) { |
| if (el.ignore) { |
| return; |
| } |
| el.updateTransform(); |
| if (el.type == 'group') { |
| if (el.clipShape) { |
| el.clipShape.parent = el; |
| el.clipShape.updateTransform(); |
| if (clipShapes) { |
| clipShapes = clipShapes.slice(); |
| clipShapes.push(el.clipShape); |
| } else { |
| clipShapes = [el.clipShape]; |
| } |
| } |
| for (var i = 0; i < el._children.length; i++) { |
| var child = el._children[i]; |
| child.__dirty = el.__dirty || child.__dirty; |
| this._updateAndAddShape(child, clipShapes); |
| } |
| el.__dirty = false; |
| } else { |
| el.__clipShapes = clipShapes; |
| this._shapeList[this._shapeListOffset++] = el; |
| } |
| }; |
| Storage.prototype.mod = function (elId, params) { |
| var el = this._elements[elId]; |
| if (el) { |
| el.modSelf(); |
| if (params) { |
| if (params.parent || params._storage || params.__startClip) { |
| var target = {}; |
| for (var name in params) { |
| if (name == 'parent' || name == '_storage' || name == '__startClip') { |
| continue; |
| } |
| if (params.hasOwnProperty(name)) { |
| target[name] = params[name]; |
| } |
| } |
| util.merge(el, target, true); |
| } else { |
| util.merge(el, params, true); |
| } |
| } |
| } |
| return this; |
| }; |
| Storage.prototype.drift = function (shapeId, dx, dy) { |
| var shape = this._elements[shapeId]; |
| if (shape) { |
| shape.needTransform = true; |
| if (shape.draggable === 'horizontal') { |
| dy = 0; |
| } else if (shape.draggable === 'vertical') { |
| dx = 0; |
| } |
| if (!shape.ondrift || shape.ondrift && !shape.ondrift(dx, dy)) { |
| shape.drift(dx, dy); |
| } |
| } |
| return this; |
| }; |
| Storage.prototype.addHover = function (shape) { |
| shape.updateNeedTransform(); |
| this._hoverElements.push(shape); |
| return this; |
| }; |
| Storage.prototype.delHover = function () { |
| this._hoverElements = []; |
| return this; |
| }; |
| Storage.prototype.hasHoverShape = function () { |
| return this._hoverElements.length > 0; |
| }; |
| Storage.prototype.addRoot = function (el) { |
| if (el instanceof Group) { |
| el.addChildrenToStorage(this); |
| } |
| this.addToMap(el); |
| this._roots.push(el); |
| }; |
| Storage.prototype.delRoot = function (elId) { |
| if (typeof elId == 'undefined') { |
| for (var i = 0; i < this._roots.length; i++) { |
| var root = this._roots[i]; |
| if (root instanceof Group) { |
| root.delChildrenFromStorage(this); |
| } |
| } |
| this._elements = {}; |
| this._hoverElements = []; |
| this._roots = []; |
| this._shapeList = []; |
| this._shapeListOffset = 0; |
| return; |
| } |
| if (elId instanceof Array) { |
| for (var i = 0, l = elId.length; i < l; i++) { |
| this.delRoot(elId[i]); |
| } |
| return; |
| } |
| var el; |
| if (typeof elId == 'string') { |
| el = this._elements[elId]; |
| } else { |
| el = elId; |
| } |
| var idx = util.indexOf(this._roots, el); |
| if (idx >= 0) { |
| this.delFromMap(el.id); |
| this._roots.splice(idx, 1); |
| if (el instanceof Group) { |
| el.delChildrenFromStorage(this); |
| } |
| } |
| }; |
| Storage.prototype.addToMap = function (el) { |
| if (el instanceof Group) { |
| el._storage = this; |
| } |
| el.modSelf(); |
| this._elements[el.id] = el; |
| return this; |
| }; |
| Storage.prototype.get = function (elId) { |
| return this._elements[elId]; |
| }; |
| Storage.prototype.delFromMap = function (elId) { |
| var el = this._elements[elId]; |
| if (el) { |
| delete this._elements[elId]; |
| if (el instanceof Group) { |
| el._storage = null; |
| } |
| } |
| return this; |
| }; |
| Storage.prototype.dispose = function () { |
| this._elements = this._renderList = this._roots = this._hoverElements = null; |
| }; |
| return Storage; |
| });define('zrender/animation/Animation', [ |
| 'require', |
| './Clip', |
| '../tool/color', |
| '../tool/util', |
| '../tool/event' |
| ], function (require) { |
| 'use strict'; |
| var Clip = require('./Clip'); |
| var color = require('../tool/color'); |
| var util = require('../tool/util'); |
| var Dispatcher = require('../tool/event').Dispatcher; |
| var requestAnimationFrame = window.requestAnimationFrame || window.msRequestAnimationFrame || window.mozRequestAnimationFrame || window.webkitRequestAnimationFrame || function (func) { |
| setTimeout(func, 16); |
| }; |
| var arraySlice = Array.prototype.slice; |
| var Animation = function (options) { |
| options = options || {}; |
| this.stage = options.stage || {}; |
| this.onframe = options.onframe || function () { |
| }; |
| this._clips = []; |
| this._running = false; |
| this._time = 0; |
| Dispatcher.call(this); |
| }; |
| Animation.prototype = { |
| add: function (clip) { |
| this._clips.push(clip); |
| }, |
| remove: function (clip) { |
| var idx = util.indexOf(this._clips, clip); |
| if (idx >= 0) { |
| this._clips.splice(idx, 1); |
| } |
| }, |
| _update: function () { |
| var time = new Date().getTime(); |
| var delta = time - this._time; |
| var clips = this._clips; |
| var len = clips.length; |
| var deferredEvents = []; |
| var deferredClips = []; |
| for (var i = 0; i < len; i++) { |
| var clip = clips[i]; |
| var e = clip.step(time); |
| if (e) { |
| deferredEvents.push(e); |
| deferredClips.push(clip); |
| } |
| } |
| if (this.stage.update) { |
| this.stage.update(); |
| } |
| for (var i = 0; i < len;) { |
| if (clips[i]._needsRemove) { |
| clips[i] = clips[len - 1]; |
| clips.pop(); |
| len--; |
| } else { |
| i++; |
| } |
| } |
| len = deferredEvents.length; |
| for (var i = 0; i < len; i++) { |
| deferredClips[i].fire(deferredEvents[i]); |
| } |
| this._time = time; |
| this.onframe(delta); |
| this.dispatch('frame', delta); |
| }, |
| start: function () { |
| var self = this; |
| this._running = true; |
| function step() { |
| if (self._running) { |
| self._update(); |
| requestAnimationFrame(step); |
| } |
| } |
| this._time = new Date().getTime(); |
| requestAnimationFrame(step); |
| }, |
| stop: function () { |
| this._running = false; |
| }, |
| clear: function () { |
| this._clips = []; |
| }, |
| animate: function (target, options) { |
| options = options || {}; |
| var deferred = new Animator(target, options.loop, options.getter, options.setter); |
| deferred.animation = this; |
| return deferred; |
| }, |
| constructor: Animation |
| }; |
| util.merge(Animation.prototype, Dispatcher.prototype, true); |
| function _defaultGetter(target, key) { |
| return target[key]; |
| } |
| function _defaultSetter(target, key, value) { |
| target[key] = value; |
| } |
| function _interpolateNumber(p0, p1, percent) { |
| return (p1 - p0) * percent + p0; |
| } |
| function _interpolateArray(p0, p1, percent, out, arrDim) { |
| var len = p0.length; |
| if (arrDim == 1) { |
| for (var i = 0; i < len; i++) { |
| out[i] = _interpolateNumber(p0[i], p1[i], percent); |
| } |
| } else { |
| var len2 = p0[0].length; |
| for (var i = 0; i < len; i++) { |
| for (var j = 0; j < len2; j++) { |
| out[i][j] = _interpolateNumber(p0[i][j], p1[i][j], percent); |
| } |
| } |
| } |
| } |
| function _isArrayLike(data) { |
| switch (typeof data) { |
| case 'undefined': |
| case 'string': |
| return false; |
| } |
| return typeof data.length !== 'undefined'; |
| } |
| function _catmullRomInterpolateArray(p0, p1, p2, p3, t, t2, t3, out, arrDim) { |
| var len = p0.length; |
| if (arrDim == 1) { |
| for (var i = 0; i < len; i++) { |
| out[i] = _catmullRomInterpolate(p0[i], p1[i], p2[i], p3[i], t, t2, t3); |
| } |
| } else { |
| var len2 = p0[0].length; |
| for (var i = 0; i < len; i++) { |
| for (var j = 0; j < len2; j++) { |
| out[i][j] = _catmullRomInterpolate(p0[i][j], p1[i][j], p2[i][j], p3[i][j], t, t2, t3); |
| } |
| } |
| } |
| } |
| function _catmullRomInterpolate(p0, p1, p2, p3, t, t2, t3) { |
| var v0 = (p2 - p0) * 0.5; |
| var v1 = (p3 - p1) * 0.5; |
| return (2 * (p1 - p2) + v0 + v1) * t3 + (-3 * (p1 - p2) - 2 * v0 - v1) * t2 + v0 * t + p1; |
| } |
| function _cloneValue(value) { |
| if (_isArrayLike(value)) { |
| var len = value.length; |
| if (_isArrayLike(value[0])) { |
| var ret = []; |
| for (var i = 0; i < len; i++) { |
| ret.push(arraySlice.call(value[i])); |
| } |
| return ret; |
| } else { |
| return arraySlice.call(value); |
| } |
| } else { |
| return value; |
| } |
| } |
| function rgba2String(rgba) { |
| rgba[0] = Math.floor(rgba[0]); |
| rgba[1] = Math.floor(rgba[1]); |
| rgba[2] = Math.floor(rgba[2]); |
| return 'rgba(' + rgba.join(',') + ')'; |
| } |
| var Animator = function (target, loop, getter, setter) { |
| this._tracks = {}; |
| this._target = target; |
| this._loop = loop || false; |
| this._getter = getter || _defaultGetter; |
| this._setter = setter || _defaultSetter; |
| this._clipCount = 0; |
| this._delay = 0; |
| this._doneList = []; |
| this._onframeList = []; |
| this._clipList = []; |
| }; |
| Animator.prototype = { |
| when: function (time, props) { |
| for (var propName in props) { |
| if (!this._tracks[propName]) { |
| this._tracks[propName] = []; |
| if (time !== 0) { |
| this._tracks[propName].push({ |
| time: 0, |
| value: _cloneValue(this._getter(this._target, propName)) |
| }); |
| } |
| } |
| this._tracks[propName].push({ |
| time: parseInt(time, 10), |
| value: props[propName] |
| }); |
| } |
| return this; |
| }, |
| during: function (callback) { |
| this._onframeList.push(callback); |
| return this; |
| }, |
| start: function (easing) { |
| var self = this; |
| var setter = this._setter; |
| var getter = this._getter; |
| var useSpline = easing === 'spline'; |
| var ondestroy = function () { |
| self._clipCount--; |
| if (self._clipCount === 0) { |
| self._tracks = {}; |
| var len = self._doneList.length; |
| for (var i = 0; i < len; i++) { |
| self._doneList[i].call(self); |
| } |
| } |
| }; |
| var createTrackClip = function (keyframes, propName) { |
| var trackLen = keyframes.length; |
| if (!trackLen) { |
| return; |
| } |
| var firstVal = keyframes[0].value; |
| var isValueArray = _isArrayLike(firstVal); |
| var isValueColor = false; |
| var arrDim = isValueArray && _isArrayLike(firstVal[0]) ? 2 : 1; |
| keyframes.sort(function (a, b) { |
| return a.time - b.time; |
| }); |
| var trackMaxTime; |
| if (trackLen) { |
| trackMaxTime = keyframes[trackLen - 1].time; |
| } else { |
| return; |
| } |
| var kfPercents = []; |
| var kfValues = []; |
| for (var i = 0; i < trackLen; i++) { |
| kfPercents.push(keyframes[i].time / trackMaxTime); |
| var value = keyframes[i].value; |
| if (typeof value == 'string') { |
| value = color.toArray(value); |
| if (value.length === 0) { |
| value[0] = value[1] = value[2] = 0; |
| value[3] = 1; |
| } |
| isValueColor = true; |
| } |
| kfValues.push(value); |
| } |
| var cacheKey = 0; |
| var cachePercent = 0; |
| var start; |
| var i; |
| var w; |
| var p0; |
| var p1; |
| var p2; |
| var p3; |
| if (isValueColor) { |
| var rgba = [ |
| 0, |
| 0, |
| 0, |
| 0 |
| ]; |
| } |
| var onframe = function (target, percent) { |
| if (percent < cachePercent) { |
| start = Math.min(cacheKey + 1, trackLen - 1); |
| for (i = start; i >= 0; i--) { |
| if (kfPercents[i] <= percent) { |
| break; |
| } |
| } |
| i = Math.min(i, trackLen - 2); |
| } else { |
| for (i = cacheKey; i < trackLen; i++) { |
| if (kfPercents[i] > percent) { |
| break; |
| } |
| } |
| i = Math.min(i - 1, trackLen - 2); |
| } |
| cacheKey = i; |
| cachePercent = percent; |
| var range = kfPercents[i + 1] - kfPercents[i]; |
| if (range === 0) { |
| return; |
| } else { |
| w = (percent - kfPercents[i]) / range; |
| } |
| if (useSpline) { |
| p1 = kfValues[i]; |
| p0 = kfValues[i === 0 ? i : i - 1]; |
| p2 = kfValues[i > trackLen - 2 ? trackLen - 1 : i + 1]; |
| p3 = kfValues[i > trackLen - 3 ? trackLen - 1 : i + 2]; |
| if (isValueArray) { |
| _catmullRomInterpolateArray(p0, p1, p2, p3, w, w * w, w * w * w, getter(target, propName), arrDim); |
| } else { |
| var value; |
| if (isValueColor) { |
| value = _catmullRomInterpolateArray(p0, p1, p2, p3, w, w * w, w * w * w, rgba, 1); |
| value = rgba2String(rgba); |
| } else { |
| value = _catmullRomInterpolate(p0, p1, p2, p3, w, w * w, w * w * w); |
| } |
| setter(target, propName, value); |
| } |
| } else { |
| if (isValueArray) { |
| _interpolateArray(kfValues[i], kfValues[i + 1], w, getter(target, propName), arrDim); |
| } else { |
| var value; |
| if (isValueColor) { |
| _interpolateArray(kfValues[i], kfValues[i + 1], w, rgba, 1); |
| value = rgba2String(rgba); |
| } else { |
| value = _interpolateNumber(kfValues[i], kfValues[i + 1], w); |
| } |
| setter(target, propName, value); |
| } |
| } |
| for (i = 0; i < self._onframeList.length; i++) { |
| self._onframeList[i](target, percent); |
| } |
| }; |
| var clip = new Clip({ |
| target: self._target, |
| life: trackMaxTime, |
| loop: self._loop, |
| delay: self._delay, |
| onframe: onframe, |
| ondestroy: ondestroy |
| }); |
| if (easing && easing !== 'spline') { |
| clip.easing = easing; |
| } |
| self._clipList.push(clip); |
| self._clipCount++; |
| self.animation.add(clip); |
| }; |
| for (var propName in this._tracks) { |
| createTrackClip(this._tracks[propName], propName); |
| } |
| return this; |
| }, |
| stop: function () { |
| for (var i = 0; i < this._clipList.length; i++) { |
| var clip = this._clipList[i]; |
| this.animation.remove(clip); |
| } |
| this._clipList = []; |
| }, |
| delay: function (time) { |
| this._delay = time; |
| return this; |
| }, |
| done: function (cb) { |
| if (cb) { |
| this._doneList.push(cb); |
| } |
| return this; |
| } |
| }; |
| return Animation; |
| });define('zrender/tool/vector', [], function () { |
| var ArrayCtor = typeof Float32Array === 'undefined' ? Array : Float32Array; |
| var vector = { |
| create: function (x, y) { |
| var out = new ArrayCtor(2); |
| out[0] = x || 0; |
| out[1] = y || 0; |
| return out; |
| }, |
| copy: function (out, v) { |
| out[0] = v[0]; |
| out[1] = v[1]; |
| return out; |
| }, |
| set: function (out, a, b) { |
| out[0] = a; |
| out[1] = b; |
| return out; |
| }, |
| add: function (out, v1, v2) { |
| out[0] = v1[0] + v2[0]; |
| out[1] = v1[1] + v2[1]; |
| return out; |
| }, |
| scaleAndAdd: function (out, v1, v2, a) { |
| out[0] = v1[0] + v2[0] * a; |
| out[1] = v1[1] + v2[1] * a; |
| return out; |
| }, |
| sub: function (out, v1, v2) { |
| out[0] = v1[0] - v2[0]; |
| out[1] = v1[1] - v2[1]; |
| return out; |
| }, |
| len: function (v) { |
| return Math.sqrt(this.lenSquare(v)); |
| }, |
| lenSquare: function (v) { |
| return v[0] * v[0] + v[1] * v[1]; |
| }, |
| mul: function (out, v1, v2) { |
| out[0] = v1[0] * v2[0]; |
| out[1] = v1[1] * v2[1]; |
| return out; |
| }, |
| div: function (out, v1, v2) { |
| out[0] = v1[0] / v2[0]; |
| out[1] = v1[1] / v2[1]; |
| return out; |
| }, |
| dot: function (v1, v2) { |
| return v1[0] * v2[0] + v1[1] * v2[1]; |
| }, |
| scale: function (out, v, s) { |
| out[0] = v[0] * s; |
| out[1] = v[1] * s; |
| return out; |
| }, |
| normalize: function (out, v) { |
| var d = vector.len(v); |
| if (d === 0) { |
| out[0] = 0; |
| out[1] = 0; |
| } else { |
| out[0] = v[0] / d; |
| out[1] = v[1] / d; |
| } |
| return out; |
| }, |
| distance: function (v1, v2) { |
| return Math.sqrt((v1[0] - v2[0]) * (v1[0] - v2[0]) + (v1[1] - v2[1]) * (v1[1] - v2[1])); |
| }, |
| distanceSquare: function (v1, v2) { |
| return (v1[0] - v2[0]) * (v1[0] - v2[0]) + (v1[1] - v2[1]) * (v1[1] - v2[1]); |
| }, |
| negate: function (out, v) { |
| out[0] = -v[0]; |
| out[1] = -v[1]; |
| return out; |
| }, |
| lerp: function (out, v1, v2, t) { |
| out[0] = v1[0] + t * (v2[0] - v1[0]); |
| out[1] = v1[1] + t * (v2[1] - v1[1]); |
| return out; |
| }, |
| applyTransform: function (out, v, m) { |
| var x = v[0]; |
| var y = v[1]; |
| out[0] = m[0] * x + m[2] * y + m[4]; |
| out[1] = m[1] * x + m[3] * y + m[5]; |
| return out; |
| }, |
| min: function (out, v1, v2) { |
| out[0] = Math.min(v1[0], v2[0]); |
| out[1] = Math.min(v1[1], v2[1]); |
| return out; |
| }, |
| max: function (out, v1, v2) { |
| out[0] = Math.max(v1[0], v2[0]); |
| out[1] = Math.max(v1[1], v2[1]); |
| return out; |
| } |
| }; |
| vector.length = vector.len; |
| vector.lengthSquare = vector.lenSquare; |
| vector.dist = vector.distance; |
| vector.distSquare = vector.distanceSquare; |
| return vector; |
| });define('zrender/tool/matrix', [], function () { |
| var ArrayCtor = typeof Float32Array === 'undefined' ? Array : Float32Array; |
| var matrix = { |
| create: function () { |
| var out = new ArrayCtor(6); |
| matrix.identity(out); |
| return out; |
| }, |
| identity: function (out) { |
| out[0] = 1; |
| out[1] = 0; |
| out[2] = 0; |
| out[3] = 1; |
| out[4] = 0; |
| out[5] = 0; |
| return out; |
| }, |
| copy: function (out, m) { |
| out[0] = m[0]; |
| out[1] = m[1]; |
| out[2] = m[2]; |
| out[3] = m[3]; |
| out[4] = m[4]; |
| out[5] = m[5]; |
| return out; |
| }, |
| mul: function (out, m1, m2) { |
| out[0] = m1[0] * m2[0] + m1[2] * m2[1]; |
| out[1] = m1[1] * m2[0] + m1[3] * m2[1]; |
| out[2] = m1[0] * m2[2] + m1[2] * m2[3]; |
| out[3] = m1[1] * m2[2] + m1[3] * m2[3]; |
| out[4] = m1[0] * m2[4] + m1[2] * m2[5] + m1[4]; |
| out[5] = m1[1] * m2[4] + m1[3] * m2[5] + m1[5]; |
| return out; |
| }, |
| translate: function (out, a, v) { |
| out[0] = a[0]; |
| out[1] = a[1]; |
| out[2] = a[2]; |
| out[3] = a[3]; |
| out[4] = a[4] + v[0]; |
| out[5] = a[5] + v[1]; |
| return out; |
| }, |
| rotate: function (out, a, rad) { |
| var aa = a[0]; |
| var ac = a[2]; |
| var atx = a[4]; |
| var ab = a[1]; |
| var ad = a[3]; |
| var aty = a[5]; |
| var st = Math.sin(rad); |
| var ct = Math.cos(rad); |
| out[0] = aa * ct + ab * st; |
| out[1] = -aa * st + ab * ct; |
| out[2] = ac * ct + ad * st; |
| out[3] = -ac * st + ct * ad; |
| out[4] = ct * atx + st * aty; |
| out[5] = ct * aty - st * atx; |
| return out; |
| }, |
| scale: function (out, a, v) { |
| var vx = v[0]; |
| var vy = v[1]; |
| out[0] = a[0] * vx; |
| out[1] = a[1] * vy; |
| out[2] = a[2] * vx; |
| out[3] = a[3] * vy; |
| out[4] = a[4] * vx; |
| out[5] = a[5] * vy; |
| return out; |
| }, |
| invert: function (out, a) { |
| var aa = a[0]; |
| var ac = a[2]; |
| var atx = a[4]; |
| var ab = a[1]; |
| var ad = a[3]; |
| var aty = a[5]; |
| var det = aa * ad - ab * ac; |
| if (!det) { |
| return null; |
| } |
| det = 1 / det; |
| out[0] = ad * det; |
| out[1] = -ab * det; |
| out[2] = -ac * det; |
| out[3] = aa * det; |
| out[4] = (ac * aty - ad * atx) * det; |
| out[5] = (ab * atx - aa * aty) * det; |
| return out; |
| }, |
| mulVector: function (out, a, v) { |
| var aa = a[0]; |
| var ac = a[2]; |
| var atx = a[4]; |
| var ab = a[1]; |
| var ad = a[3]; |
| var aty = a[5]; |
| out[0] = v[0] * aa + v[1] * ac + atx; |
| out[1] = v[0] * ab + v[1] * ad + aty; |
| return out; |
| } |
| }; |
| return matrix; |
| });define('zrender/loadingEffect/Base', [ |
| 'require', |
| '../tool/util', |
| '../shape/Text', |
| '../shape/Rectangle' |
| ], function (require) { |
| var util = require('../tool/util'); |
| var TextShape = require('../shape/Text'); |
| var RectangleShape = require('../shape/Rectangle'); |
| var DEFAULT_TEXT = 'Loading...'; |
| var DEFAULT_TEXT_FONT = 'normal 16px Arial'; |
| function Base(options) { |
| this.setOptions(options); |
| } |
| Base.prototype.createTextShape = function (textStyle) { |
| return new TextShape({ |
| highlightStyle: util.merge({ |
| x: this.canvasWidth / 2, |
| y: this.canvasHeight / 2, |
| text: DEFAULT_TEXT, |
| textAlign: 'center', |
| textBaseline: 'middle', |
| textFont: DEFAULT_TEXT_FONT, |
| color: '#333', |
| brushType: 'fill' |
| }, textStyle, true) |
| }); |
| }; |
| Base.prototype.createBackgroundShape = function (color) { |
| return new RectangleShape({ |
| highlightStyle: { |
| x: 0, |
| y: 0, |
| width: this.canvasWidth, |
| height: this.canvasHeight, |
| brushType: 'fill', |
| color: color |
| } |
| }); |
| }; |
| Base.prototype.start = function (painter) { |
| this.canvasWidth = painter._width; |
| this.canvasHeight = painter._height; |
| function addShapeHandle(param) { |
| painter.storage.addHover(param); |
| } |
| function refreshHandle() { |
| painter.refreshHover(); |
| } |
| this.loadingTimer = this._start(addShapeHandle, refreshHandle); |
| }; |
| Base.prototype._start = function () { |
| return setInterval(function () { |
| }, 10000); |
| }; |
| Base.prototype.stop = function () { |
| clearInterval(this.loadingTimer); |
| }; |
| Base.prototype.setOptions = function (options) { |
| this.options = options || {}; |
| }; |
| Base.prototype.adjust = function (value, region) { |
| if (value <= region[0]) { |
| value = region[0]; |
| } else if (value >= region[1]) { |
| value = region[1]; |
| } |
| return value; |
| }; |
| Base.prototype.getLocation = function (loc, totalWidth, totalHeight) { |
| var x = loc.x != null ? loc.x : 'center'; |
| switch (x) { |
| case 'center': |
| x = Math.floor((this.canvasWidth - totalWidth) / 2); |
| break; |
| case 'left': |
| x = 0; |
| break; |
| case 'right': |
| x = this.canvasWidth - totalWidth; |
| break; |
| } |
| var y = loc.y != null ? loc.y : 'center'; |
| switch (y) { |
| case 'center': |
| y = Math.floor((this.canvasHeight - totalHeight) / 2); |
| break; |
| case 'top': |
| y = 0; |
| break; |
| case 'bottom': |
| y = this.canvasHeight - totalHeight; |
| break; |
| } |
| return { |
| x: x, |
| y: y, |
| width: totalWidth, |
| height: totalHeight |
| }; |
| }; |
| return Base; |
| });define('zrender/mixin/Transformable', [ |
| 'require', |
| '../tool/matrix', |
| '../tool/vector' |
| ], function (require) { |
| 'use strict'; |
| var matrix = require('../tool/matrix'); |
| var vector = require('../tool/vector'); |
| var origin = [ |
| 0, |
| 0 |
| ]; |
| var EPSILON = 0.00005; |
| function isAroundZero(val) { |
| return val > -EPSILON && val < EPSILON; |
| } |
| function isNotAroundZero(val) { |
| return val > EPSILON || val < -EPSILON; |
| } |
| var Transformable = function () { |
| if (!this.position) { |
| this.position = [ |
| 0, |
| 0 |
| ]; |
| } |
| if (typeof this.rotation == 'undefined') { |
| this.rotation = [ |
| 0, |
| 0, |
| 0 |
| ]; |
| } |
| if (!this.scale) { |
| this.scale = [ |
| 1, |
| 1, |
| 0, |
| 0 |
| ]; |
| } |
| this.needLocalTransform = false; |
| this.needTransform = false; |
| }; |
| Transformable.prototype = { |
| constructor: Transformable, |
| updateNeedTransform: function () { |
| this.needLocalTransform = isNotAroundZero(this.rotation[0]) || isNotAroundZero(this.position[0]) || isNotAroundZero(this.position[1]) || isNotAroundZero(this.scale[0] - 1) || isNotAroundZero(this.scale[1] - 1); |
| }, |
| updateTransform: function () { |
| this.updateNeedTransform(); |
| if (this.parent) { |
| this.needTransform = this.needLocalTransform || this.parent.needTransform; |
| } else { |
| this.needTransform = this.needLocalTransform; |
| } |
| if (!this.needTransform) { |
| return; |
| } |
| var m = this.transform || matrix.create(); |
| matrix.identity(m); |
| if (this.needLocalTransform) { |
| if (isNotAroundZero(this.scale[0]) || isNotAroundZero(this.scale[1])) { |
| origin[0] = -this.scale[2] || 0; |
| origin[1] = -this.scale[3] || 0; |
| var haveOrigin = isNotAroundZero(origin[0]) || isNotAroundZero(origin[1]); |
| if (haveOrigin) { |
| matrix.translate(m, m, origin); |
| } |
| matrix.scale(m, m, this.scale); |
| if (haveOrigin) { |
| origin[0] = -origin[0]; |
| origin[1] = -origin[1]; |
| matrix.translate(m, m, origin); |
| } |
| } |
| if (this.rotation instanceof Array) { |
| if (this.rotation[0] !== 0) { |
| origin[0] = -this.rotation[1] || 0; |
| origin[1] = -this.rotation[2] || 0; |
| var haveOrigin = isNotAroundZero(origin[0]) || isNotAroundZero(origin[1]); |
| if (haveOrigin) { |
| matrix.translate(m, m, origin); |
| } |
| matrix.rotate(m, m, this.rotation[0]); |
| if (haveOrigin) { |
| origin[0] = -origin[0]; |
| origin[1] = -origin[1]; |
| matrix.translate(m, m, origin); |
| } |
| } |
| } else { |
| if (this.rotation !== 0) { |
| matrix.rotate(m, m, this.rotation); |
| } |
| } |
| if (isNotAroundZero(this.position[0]) || isNotAroundZero(this.position[1])) { |
| matrix.translate(m, m, this.position); |
| } |
| } |
| this.transform = m; |
| if (this.parent && this.parent.needTransform) { |
| if (this.needLocalTransform) { |
| matrix.mul(this.transform, this.parent.transform, this.transform); |
| } else { |
| matrix.copy(this.transform, this.parent.transform); |
| } |
| } |
| }, |
| setTransform: function (ctx) { |
| if (this.needTransform) { |
| var m = this.transform; |
| ctx.transform(m[0], m[1], m[2], m[3], m[4], m[5]); |
| } |
| }, |
| lookAt: function () { |
| var v = vector.create(); |
| return function (target) { |
| if (!this.transform) { |
| this.transform = matrix.create(); |
| } |
| var m = this.transform; |
| vector.sub(v, target, this.position); |
| if (isAroundZero(v[0]) && isAroundZero(v[1])) { |
| return; |
| } |
| vector.normalize(v, v); |
| m[2] = v[0] * this.scale[1]; |
| m[3] = v[1] * this.scale[1]; |
| m[0] = v[1] * this.scale[0]; |
| m[1] = -v[0] * this.scale[0]; |
| m[4] = this.position[0]; |
| m[5] = this.position[1]; |
| this.decomposeTransform(); |
| }; |
| }(), |
| decomposeTransform: function () { |
| if (!this.transform) { |
| return; |
| } |
| var m = this.transform; |
| var sx = m[0] * m[0] + m[1] * m[1]; |
| var position = this.position; |
| var scale = this.scale; |
| var rotation = this.rotation; |
| if (isNotAroundZero(sx - 1)) { |
| sx = Math.sqrt(sx); |
| } |
| var sy = m[2] * m[2] + m[3] * m[3]; |
| if (isNotAroundZero(sy - 1)) { |
| sy = Math.sqrt(sy); |
| } |
| position[0] = m[4]; |
| position[1] = m[5]; |
| scale[0] = sx; |
| scale[1] = sy; |
| scale[2] = scale[3] = 0; |
| rotation[0] = Math.atan2(-m[1] / sy, m[0] / sx); |
| rotation[1] = rotation[2] = 0; |
| } |
| }; |
| return Transformable; |
| });define('zrender/shape/Text', [ |
| 'require', |
| '../tool/area', |
| './Base', |
| '../tool/util' |
| ], function (require) { |
| var area = require('../tool/area'); |
| var Base = require('./Base'); |
| var Text = function (options) { |
| Base.call(this, options); |
| }; |
| Text.prototype = { |
| type: 'text', |
| brush: function (ctx, isHighlight) { |
| var style = this.style; |
| if (isHighlight) { |
| style = this.getHighlightStyle(style, this.highlightStyle || {}); |
| } |
| if (typeof style.text == 'undefined' || style.text === false) { |
| return; |
| } |
| ctx.save(); |
| this.doClip(ctx); |
| this.setContext(ctx, style); |
| this.setTransform(ctx); |
| if (style.textFont) { |
| ctx.font = style.textFont; |
| } |
| ctx.textAlign = style.textAlign || 'start'; |
| ctx.textBaseline = style.textBaseline || 'middle'; |
| var text = (style.text + '').split('\n'); |
| var lineHeight = area.getTextHeight('国', style.textFont); |
| var rect = this.getRect(style); |
| var x = style.x; |
| var y; |
| if (style.textBaseline == 'top') { |
| y = rect.y; |
| } else if (style.textBaseline == 'bottom') { |
| y = rect.y + lineHeight; |
| } else { |
| y = rect.y + lineHeight / 2; |
| } |
| for (var i = 0, l = text.length; i < l; i++) { |
| if (style.maxWidth) { |
| switch (style.brushType) { |
| case 'fill': |
| ctx.fillText(text[i], x, y, style.maxWidth); |
| break; |
| case 'stroke': |
| ctx.strokeText(text[i], x, y, style.maxWidth); |
| break; |
| case 'both': |
| ctx.fillText(text[i], x, y, style.maxWidth); |
| ctx.strokeText(text[i], x, y, style.maxWidth); |
| break; |
| default: |
| ctx.fillText(text[i], x, y, style.maxWidth); |
| } |
| } else { |
| switch (style.brushType) { |
| case 'fill': |
| ctx.fillText(text[i], x, y); |
| break; |
| case 'stroke': |
| ctx.strokeText(text[i], x, y); |
| break; |
| case 'both': |
| ctx.fillText(text[i], x, y); |
| ctx.strokeText(text[i], x, y); |
| break; |
| default: |
| ctx.fillText(text[i], x, y); |
| } |
| } |
| y += lineHeight; |
| } |
| ctx.restore(); |
| return; |
| }, |
| getRect: function (style) { |
| if (style.__rect) { |
| return style.__rect; |
| } |
| var width = area.getTextWidth(style.text, style.textFont); |
| var height = area.getTextHeight(style.text, style.textFont); |
| var textX = style.x; |
| if (style.textAlign == 'end' || style.textAlign == 'right') { |
| textX -= width; |
| } else if (style.textAlign == 'center') { |
| textX -= width / 2; |
| } |
| var textY; |
| if (style.textBaseline == 'top') { |
| textY = style.y; |
| } else if (style.textBaseline == 'bottom') { |
| textY = style.y - height; |
| } else { |
| textY = style.y - height / 2; |
| } |
| style.__rect = { |
| x: textX, |
| y: textY, |
| width: width, |
| height: height |
| }; |
| return style.__rect; |
| } |
| }; |
| require('../tool/util').inherits(Text, Base); |
| return Text; |
| });define('zrender/shape/Rectangle', [ |
| 'require', |
| './Base', |
| '../tool/util' |
| ], function (require) { |
| var Base = require('./Base'); |
| var Rectangle = function (options) { |
| Base.call(this, options); |
| }; |
| Rectangle.prototype = { |
| type: 'rectangle', |
| _buildRadiusPath: function (ctx, style) { |
| var x = style.x; |
| var y = style.y; |
| var width = style.width; |
| var height = style.height; |
| var r = style.radius; |
| var r1; |
| var r2; |
| var r3; |
| var r4; |
| if (typeof r === 'number') { |
| r1 = r2 = r3 = r4 = r; |
| } else if (r instanceof Array) { |
| if (r.length === 1) { |
| r1 = r2 = r3 = r4 = r[0]; |
| } else if (r.length === 2) { |
| r1 = r3 = r[0]; |
| r2 = r4 = r[1]; |
| } else if (r.length === 3) { |
| r1 = r[0]; |
| r2 = r4 = r[1]; |
| r3 = r[2]; |
| } else { |
| r1 = r[0]; |
| r2 = r[1]; |
| r3 = r[2]; |
| r4 = r[3]; |
| } |
| } else { |
| r1 = r2 = r3 = r4 = 0; |
| } |
| var total; |
| if (r1 + r2 > width) { |
| total = r1 + r2; |
| r1 *= width / total; |
| r2 *= width / total; |
| } |
| if (r3 + r4 > width) { |
| total = r3 + r4; |
| r3 *= width / total; |
| r4 *= width / total; |
| } |
| if (r2 + r3 > height) { |
| total = r2 + r3; |
| r2 *= height / total; |
| r3 *= height / total; |
| } |
| if (r1 + r4 > height) { |
| total = r1 + r4; |
| r1 *= height / total; |
| r4 *= height / total; |
| } |
| ctx.moveTo(x + r1, y); |
| ctx.lineTo(x + width - r2, y); |
| r2 !== 0 && ctx.quadraticCurveTo(x + width, y, x + width, y + r2); |
| ctx.lineTo(x + width, y + height - r3); |
| r3 !== 0 && ctx.quadraticCurveTo(x + width, y + height, x + width - r3, y + height); |
| ctx.lineTo(x + r4, y + height); |
| r4 !== 0 && ctx.quadraticCurveTo(x, y + height, x, y + height - r4); |
| ctx.lineTo(x, y + r1); |
| r1 !== 0 && ctx.quadraticCurveTo(x, y, x + r1, y); |
| }, |
| buildPath: function (ctx, style) { |
| if (!style.radius) { |
| ctx.moveTo(style.x, style.y); |
| ctx.lineTo(style.x + style.width, style.y); |
| ctx.lineTo(style.x + style.width, style.y + style.height); |
| ctx.lineTo(style.x, style.y + style.height); |
| ctx.lineTo(style.x, style.y); |
| } else { |
| this._buildRadiusPath(ctx, style); |
| } |
| ctx.closePath(); |
| return; |
| }, |
| getRect: function (style) { |
| if (style.__rect) { |
| return style.__rect; |
| } |
| var lineWidth; |
| if (style.brushType == 'stroke' || style.brushType == 'fill') { |
| lineWidth = style.lineWidth || 1; |
| } else { |
| lineWidth = 0; |
| } |
| style.__rect = { |
| x: Math.round(style.x - lineWidth / 2), |
| y: Math.round(style.y - lineWidth / 2), |
| width: style.width + lineWidth, |
| height: style.height + lineWidth |
| }; |
| return style.__rect; |
| } |
| }; |
| require('../tool/util').inherits(Rectangle, Base); |
| return Rectangle; |
| });define('zrender/tool/area', [ |
| 'require', |
| './util', |
| './curve' |
| ], function (require) { |
| 'use strict'; |
| var util = require('./util'); |
| var curve = require('./curve'); |
| var _ctx; |
| var _textWidthCache = {}; |
| var _textHeightCache = {}; |
| var _textWidthCacheCounter = 0; |
| var _textHeightCacheCounter = 0; |
| var TEXT_CACHE_MAX = 5000; |
| var PI2 = Math.PI * 2; |
| function normalizeRadian(angle) { |
| angle %= PI2; |
| if (angle < 0) { |
| angle += PI2; |
| } |
| return angle; |
| } |
| function isInside(shape, area, x, y) { |
| if (!area || !shape) { |
| return false; |
| } |
| var zoneType = shape.type; |
| _ctx = _ctx || util.getContext(); |
| var _mathReturn = _mathMethod(shape, area, x, y); |
| if (typeof _mathReturn != 'undefined') { |
| return _mathReturn; |
| } |
| if (shape.buildPath && _ctx.isPointInPath) { |
| return _buildPathMethod(shape, _ctx, area, x, y); |
| } |
| switch (zoneType) { |
| case 'ellipse': |
| return true; |
| case 'trochoid': |
| var _r = area.location == 'out' ? area.r1 + area.r2 + area.d : area.r1 - area.r2 + area.d; |
| return isInsideCircle(area, x, y, _r); |
| case 'rose': |
| return isInsideCircle(area, x, y, area.maxr); |
| default: |
| return false; |
| } |
| } |
| function _mathMethod(shape, area, x, y) { |
| var zoneType = shape.type; |
| switch (zoneType) { |
| case 'bezier-curve': |
| if (typeof area.cpX2 === 'undefined') { |
| return isInsideQuadraticStroke(area.xStart, area.yStart, area.cpX1, area.cpY1, area.xEnd, area.yEnd, area.lineWidth, x, y); |
| } |
| return isInsideCubicStroke(area.xStart, area.yStart, area.cpX1, area.cpY1, area.cpX2, area.cpY2, area.xEnd, area.yEnd, area.lineWidth, x, y); |
| case 'line': |
| return isInsideLine(area.xStart, area.yStart, area.xEnd, area.yEnd, area.lineWidth, x, y); |
| case 'broken-line': |
| return isInsideBrokenLine(area.pointList, area.lineWidth, x, y); |
| case 'ring': |
| return isInsideRing(area.x, area.y, area.r0, area.r, x, y); |
| case 'circle': |
| return isInsideCircle(area.x, area.y, area.r, x, y); |
| case 'sector': |
| var startAngle = area.startAngle * Math.PI / 180; |
| var endAngle = area.endAngle * Math.PI / 180; |
| if (!area.clockWise) { |
| startAngle = -startAngle; |
| endAngle = -endAngle; |
| } |
| return isInsideSector(area.x, area.y, area.r0, area.r, startAngle, endAngle, !area.clockWise, x, y); |
| case 'path': |
| return isInsidePath(area.pathArray, Math.max(area.lineWidth, 5), area.brushType, x, y); |
| case 'polygon': |
| case 'star': |
| case 'isogon': |
| return isInsidePolygon(area.pointList, x, y); |
| case 'text': |
| var rect = area.__rect || shape.getRect(area); |
| return isInsideRect(rect.x, rect.y, rect.width, rect.height, x, y); |
| case 'rectangle': |
| case 'image': |
| return isInsideRect(area.x, area.y, area.width, area.height, x, y); |
| } |
| } |
| function _buildPathMethod(shape, context, area, x, y) { |
| context.beginPath(); |
| shape.buildPath(context, area); |
| context.closePath(); |
| return context.isPointInPath(x, y); |
| } |
| function isOutside(shape, area, x, y) { |
| return !isInside(shape, area, x, y); |
| } |
| function isInsideLine(x0, y0, x1, y1, lineWidth, x, y) { |
| if (lineWidth === 0) { |
| return false; |
| } |
| var _l = Math.max(lineWidth, 5); |
| var _a = 0; |
| var _b = x0; |
| if (y > y0 + _l && y > y1 + _l || y < y0 - _l && y < y1 - _l || x > x0 + _l && x > x1 + _l || x < x0 - _l && x < x1 - _l) { |
| return false; |
| } |
| if (x0 !== x1) { |
| _a = (y0 - y1) / (x0 - x1); |
| _b = (x0 * y1 - x1 * y0) / (x0 - x1); |
| } else { |
| return Math.abs(x - x0) <= _l / 2; |
| } |
| var tmp = _a * x - y + _b; |
| var _s = tmp * tmp / (_a * _a + 1); |
| return _s <= _l / 2 * _l / 2; |
| } |
| function isInsideCubicStroke(x0, y0, x1, y1, x2, y2, x3, y3, lineWidth, x, y) { |
| if (lineWidth === 0) { |
| return false; |
| } |
| var _l = Math.max(lineWidth, 5); |
| if (y > y0 + _l && y > y1 + _l && y > y2 + _l && y > y3 + _l || y < y0 - _l && y < y1 - _l && y < y2 - _l && y < y3 - _l || x > x0 + _l && x > x1 + _l && x > x2 + _l && x > x3 + _l || x < x0 - _l && x < x1 - _l && x < x2 - _l && x < x3 - _l) { |
| return false; |
| } |
| var d = curve.cubicProjectPoint(x0, y0, x1, y1, x2, y2, x3, y3, x, y, null); |
| return d <= _l / 2; |
| } |
| function isInsideQuadraticStroke(x0, y0, x1, y1, x2, y2, lineWidth, x, y) { |
| if (lineWidth === 0) { |
| return false; |
| } |
| var _l = Math.max(lineWidth, 5); |
| if (y > y0 + _l && y > y1 + _l && y > y2 + _l || y < y0 - _l && y < y1 - _l && y < y2 - _l || x > x0 + _l && x > x1 + _l && x > x2 + _l || x < x0 - _l && x < x1 - _l && x < x2 - _l) { |
| return false; |
| } |
| var d = curve.quadraticProjectPoint(x0, y0, x1, y1, x2, y2, x, y, null); |
| return d <= _l / 2; |
| } |
| function isInsideArcStroke(cx, cy, r, startAngle, endAngle, anticlockwise, lineWidth, x, y) { |
| if (lineWidth === 0) { |
| return false; |
| } |
| var _l = Math.max(lineWidth, 5); |
| x -= cx; |
| y -= cy; |
| var d = Math.sqrt(x * x + y * y); |
| if (d - _l > r || d + _l < r) { |
| return false; |
| } |
| if (Math.abs(startAngle - endAngle) >= PI2) { |
| return true; |
| } |
| if (anticlockwise) { |
| var tmp = startAngle; |
| startAngle = normalizeRadian(endAngle); |
| endAngle = normalizeRadian(tmp); |
| } else { |
| startAngle = normalizeRadian(startAngle); |
| endAngle = normalizeRadian(endAngle); |
| } |
| if (startAngle > endAngle) { |
| endAngle += PI2; |
| } |
| var angle = Math.atan2(y, x); |
| if (angle < 0) { |
| angle += PI2; |
| } |
| return angle >= startAngle && angle <= endAngle || angle + PI2 >= startAngle && angle + PI2 <= endAngle; |
| } |
| function isInsideBrokenLine(points, lineWidth, x, y) { |
| var lineWidth = Math.max(lineWidth, 10); |
| for (var i = 0, l = points.length - 1; i < l; i++) { |
| var x0 = points[i][0]; |
| var y0 = points[i][1]; |
| var x1 = points[i + 1][0]; |
| var y1 = points[i + 1][1]; |
| if (isInsideLine(x0, y0, x1, y1, lineWidth, x, y)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| function isInsideRing(cx, cy, r0, r, x, y) { |
| var d = (x - cx) * (x - cx) + (y - cy) * (y - cy); |
| return d < r * r && d > r0 * r0; |
| } |
| function isInsideRect(x0, y0, width, height, x, y) { |
| return x >= x0 && x <= x0 + width && y >= y0 && y <= y0 + height; |
| } |
| function isInsideCircle(x0, y0, r, x, y) { |
| return (x - x0) * (x - x0) + (y - y0) * (y - y0) < r * r; |
| } |
| function isInsideSector(cx, cy, r0, r, startAngle, endAngle, anticlockwise, x, y) { |
| return isInsideArcStroke(cx, cy, (r0 + r) / 2, startAngle, endAngle, anticlockwise, r - r0, x, y); |
| } |
| function isInsidePolygon(points, x, y) { |
| var N = points.length; |
| var w = 0; |
| for (var i = 0, j = N - 1; i < N; i++) { |
| var x0 = points[j][0]; |
| var y0 = points[j][1]; |
| var x1 = points[i][0]; |
| var y1 = points[i][1]; |
| w += windingLine(x0, y0, x1, y1, x, y); |
| j = i; |
| } |
| return w !== 0; |
| } |
| function windingLine(x0, y0, x1, y1, x, y) { |
| if (y > y0 && y > y1 || y < y0 && y < y1) { |
| return 0; |
| } |
| if (y1 == y0) { |
| return 0; |
| } |
| var dir = y1 < y0 ? 1 : -1; |
| var t = (y - y0) / (y1 - y0); |
| var x_ = t * (x1 - x0) + x0; |
| return x_ > x ? dir : 0; |
| } |
| var roots = [ |
| -1, |
| -1, |
| -1 |
| ]; |
| var extrema = [ |
| -1, |
| -1 |
| ]; |
| function swapExtrema() { |
| var tmp = extrema[0]; |
| extrema[0] = extrema[1]; |
| extrema[1] = tmp; |
| } |
| function windingCubic(x0, y0, x1, y1, x2, y2, x3, y3, x, y) { |
| if (y > y0 && y > y1 && y > y2 && y > y3 || y < y0 && y < y1 && y < y2 && y < y3) { |
| return 0; |
| } |
| var nRoots = curve.cubicRootAt(y0, y1, y2, y3, y, roots); |
| if (nRoots === 0) { |
| return 0; |
| } else { |
| var w = 0; |
| var nExtrema = -1; |
| var y0_, y1_; |
| for (var i = 0; i < nRoots; i++) { |
| var t = roots[i]; |
| var x_ = curve.cubicAt(x0, x1, x2, x3, t); |
| if (x_ < x) { |
| continue; |
| } |
| if (nExtrema < 0) { |
| nExtrema = curve.cubicExtrema(y0, y1, y2, y3, extrema); |
| if (extrema[1] < extrema[0] && nExtrema > 1) { |
| swapExtrema(); |
| } |
| y0_ = curve.cubicAt(y0, y1, y2, y3, extrema[0]); |
| if (nExtrema > 1) { |
| y1_ = curve.cubicAt(y0, y1, y2, y3, extrema[1]); |
| } |
| } |
| if (nExtrema == 2) { |
| if (t < extrema[0]) { |
| w += y0_ < y0 ? 1 : -1; |
| } else if (t < extrema[1]) { |
| w += y1_ < y0_ ? 1 : -1; |
| } else { |
| w += y3 < y1_ ? 1 : -1; |
| } |
| } else { |
| if (t < extrema[0]) { |
| w += y0_ < y0 ? 1 : -1; |
| } else { |
| w += y3 < y0_ ? 1 : -1; |
| } |
| } |
| } |
| return w; |
| } |
| } |
| function windingQuadratic(x0, y0, x1, y1, x2, y2, x, y) { |
| if (y > y0 && y > y1 && y > y2 || y < y0 && y < y1 && y < y2) { |
| return 0; |
| } |
| var nRoots = curve.quadraticRootAt(y0, y1, y2, y, roots); |
| if (nRoots === 0) { |
| return 0; |
| } else { |
| var t = curve.quadraticExtremum(y0, y1, y2); |
| if (t >= 0 && t <= 1) { |
| var w = 0; |
| var y_ = curve.quadraticAt(y0, y1, y2, t); |
| for (var i = 0; i < nRoots; i++) { |
| var x_ = curve.quadraticAt(x0, x1, x2, roots[i]); |
| if (x_ > x) { |
| continue; |
| } |
| if (roots[i] < t) { |
| w += y_ < y0 ? 1 : -1; |
| } else { |
| w += y2 < y_ ? 1 : -1; |
| } |
| } |
| return w; |
| } else { |
| var x_ = curve.quadraticAt(x0, x1, x2, roots[0]); |
| if (x_ > x) { |
| return 0; |
| } |
| return y2 < y0 ? 1 : -1; |
| } |
| } |
| } |
| function windingArc(cx, cy, r, startAngle, endAngle, anticlockwise, x, y) { |
| y -= cy; |
| if (y > r || y < -r) { |
| return 0; |
| } |
| var tmp = Math.sqrt(r * r - y * y); |
| roots[0] = -tmp; |
| roots[1] = tmp; |
| if (Math.abs(startAngle - endAngle) >= PI2) { |
| startAngle = 0; |
| endAngle = PI2; |
| var dir = anticlockwise ? 1 : -1; |
| if (x >= roots[0] + cx && x <= roots[1] + cx) { |
| return dir; |
| } else { |
| return 0; |
| } |
| } |
| if (anticlockwise) { |
| var tmp = startAngle; |
| startAngle = normalizeRadian(endAngle); |
| endAngle = normalizeRadian(tmp); |
| } else { |
| startAngle = normalizeRadian(startAngle); |
| endAngle = normalizeRadian(endAngle); |
| } |
| if (startAngle > endAngle) { |
| endAngle += PI2; |
| } |
| var w = 0; |
| for (var i = 0; i < 2; i++) { |
| var x_ = roots[i]; |
| if (x_ + cx > x) { |
| var angle = Math.atan2(y, x_); |
| var dir = anticlockwise ? 1 : -1; |
| if (angle < 0) { |
| angle = PI2 + angle; |
| } |
| if (angle >= startAngle && angle <= endAngle || angle + PI2 >= startAngle && angle + PI2 <= endAngle) { |
| if (angle > Math.PI / 2 && angle < Math.PI * 1.5) { |
| dir = -dir; |
| } |
| w += dir; |
| } |
| } |
| } |
| return w; |
| } |
| function isInsidePath(pathArray, lineWidth, brushType, x, y) { |
| var w = 0; |
| var xi = 0; |
| var yi = 0; |
| var x0 = 0; |
| var y0 = 0; |
| var beginSubpath = true; |
| var firstCmd = true; |
| brushType = brushType || 'fill'; |
| var hasStroke = brushType === 'stroke' || brushType === 'both'; |
| var hasFill = brushType === 'fill' || brushType === 'both'; |
| for (var i = 0; i < pathArray.length; i++) { |
| var seg = pathArray[i]; |
| var p = seg.points; |
| if (beginSubpath || seg.command === 'M') { |
| if (i > 0) { |
| if (hasFill) { |
| w += windingLine(xi, yi, x0, y0, x, y); |
| } |
| if (w !== 0) { |
| return true; |
| } |
| } |
| x0 = p[p.length - 2]; |
| y0 = p[p.length - 1]; |
| beginSubpath = false; |
| if (firstCmd && seg.command !== 'A') { |
| firstCmd = false; |
| xi = x0; |
| yi = y0; |
| } |
| } |
| switch (seg.command) { |
| case 'M': |
| xi = p[0]; |
| yi = p[1]; |
| break; |
| case 'L': |
| if (hasStroke) { |
| if (isInsideLine(xi, yi, p[0], p[1], lineWidth, x, y)) { |
| return true; |
| } |
| } |
| if (hasFill) { |
| w += windingLine(xi, yi, p[0], p[1], x, y); |
| } |
| xi = p[0]; |
| yi = p[1]; |
| break; |
| case 'C': |
| if (hasStroke) { |
| if (isInsideCubicStroke(xi, yi, p[0], p[1], p[2], p[3], p[4], p[5], lineWidth, x, y)) { |
| return true; |
| } |
| } |
| if (hasFill) { |
| w += windingCubic(xi, yi, p[0], p[1], p[2], p[3], p[4], p[5], x, y); |
| } |
| xi = p[4]; |
| yi = p[5]; |
| break; |
| case 'Q': |
| if (hasStroke) { |
| if (isInsideQuadraticStroke(xi, yi, p[0], p[1], p[2], p[3], lineWidth, x, y)) { |
| return true; |
| } |
| } |
| if (hasFill) { |
| w += windingQuadratic(xi, yi, p[0], p[1], p[2], p[3], x, y); |
| } |
| xi = p[2]; |
| yi = p[3]; |
| break; |
| case 'A': |
| var cx = p[0]; |
| var cy = p[1]; |
| var rx = p[2]; |
| var ry = p[3]; |
| var theta = p[4]; |
| var dTheta = p[5]; |
| var x1 = Math.cos(theta) * rx + cx; |
| var y1 = Math.sin(theta) * ry + cy; |
| if (!firstCmd) { |
| w += windingLine(xi, yi, x1, y1); |
| } else { |
| firstCmd = false; |
| x0 = x1; |
| y0 = y1; |
| } |
| var _x = (x - cx) * ry / rx + cx; |
| if (hasStroke) { |
| if (isInsideArcStroke(cx, cy, ry, theta, theta + dTheta, 1 - p[7], lineWidth, _x, y)) { |
| return true; |
| } |
| } |
| if (hasFill) { |
| w += windingArc(cx, cy, ry, theta, theta + dTheta, 1 - p[7], _x, y); |
| } |
| xi = Math.cos(theta + dTheta) * rx + cx; |
| yi = Math.sin(theta + dTheta) * ry + cy; |
| break; |
| case 'z': |
| if (hasStroke) { |
| if (isInsideLine(xi, yi, x0, y0, lineWidth, x, y)) { |
| return true; |
| } |
| } |
| beginSubpath = true; |
| break; |
| } |
| } |
| if (hasFill) { |
| w += windingLine(xi, yi, x0, y0, x, y); |
| } |
| return w !== 0; |
| } |
| function getTextWidth(text, textFont) { |
| var key = text + ':' + textFont; |
| if (_textWidthCache[key]) { |
| return _textWidthCache[key]; |
| } |
| _ctx = _ctx || util.getContext(); |
| _ctx.save(); |
| if (textFont) { |
| _ctx.font = textFont; |
| } |
| text = (text + '').split('\n'); |
| var width = 0; |
| for (var i = 0, l = text.length; i < l; i++) { |
| width = Math.max(_ctx.measureText(text[i]).width, width); |
| } |
| _ctx.restore(); |
| _textWidthCache[key] = width; |
| if (++_textWidthCacheCounter > TEXT_CACHE_MAX) { |
| _textWidthCacheCounter = 0; |
| _textWidthCache = {}; |
| } |
| return width; |
| } |
| function getTextHeight(text, textFont) { |
| var key = text + ':' + textFont; |
| if (_textHeightCache[key]) { |
| return _textHeightCache[key]; |
| } |
| _ctx = _ctx || util.getContext(); |
| _ctx.save(); |
| if (textFont) { |
| _ctx.font = textFont; |
| } |
| text = (text + '').split('\n'); |
| var height = (_ctx.measureText('国').width + 2) * text.length; |
| _ctx.restore(); |
| _textHeightCache[key] = height; |
| if (++_textHeightCacheCounter > TEXT_CACHE_MAX) { |
| _textHeightCacheCounter = 0; |
| _textHeightCache = {}; |
| } |
| return height; |
| } |
| return { |
| isInside: isInside, |
| isOutside: isOutside, |
| getTextWidth: getTextWidth, |
| getTextHeight: getTextHeight, |
| isInsidePath: isInsidePath, |
| isInsidePolygon: isInsidePolygon, |
| isInsideSector: isInsideSector, |
| isInsideCircle: isInsideCircle, |
| isInsideLine: isInsideLine, |
| isInsideRect: isInsideRect, |
| isInsideBrokenLine: isInsideBrokenLine, |
| isInsideCubicStroke: isInsideCubicStroke, |
| isInsideQuadraticStroke: isInsideQuadraticStroke |
| }; |
| });define('zrender/shape/Base', [ |
| 'require', |
| '../tool/matrix', |
| '../tool/guid', |
| '../tool/util', |
| '../tool/log', |
| '../mixin/Transformable', |
| '../mixin/Eventful', |
| '../tool/area', |
| '../tool/color' |
| ], function (require) { |
| var vmlCanvasManager = window['G_vmlCanvasManager']; |
| var matrix = require('../tool/matrix'); |
| var guid = require('../tool/guid'); |
| var util = require('../tool/util'); |
| var log = require('../tool/log'); |
| var Transformable = require('../mixin/Transformable'); |
| var Eventful = require('../mixin/Eventful'); |
| function _fillText(ctx, text, x, y, textFont, textAlign, textBaseline) { |
| if (textFont) { |
| ctx.font = textFont; |
| } |
| ctx.textAlign = textAlign; |
| ctx.textBaseline = textBaseline; |
| var rect = _getTextRect(text, x, y, textFont, textAlign, textBaseline); |
| text = (text + '').split('\n'); |
| var lineHeight = require('../tool/area').getTextHeight('国', textFont); |
| switch (textBaseline) { |
| case 'top': |
| y = rect.y; |
| break; |
| case 'bottom': |
| y = rect.y + lineHeight; |
| break; |
| default: |
| y = rect.y + lineHeight / 2; |
| } |
| for (var i = 0, l = text.length; i < l; i++) { |
| ctx.fillText(text[i], x, y); |
| y += lineHeight; |
| } |
| } |
| function _getTextRect(text, x, y, textFont, textAlign, textBaseline) { |
| var area = require('../tool/area'); |
| var width = area.getTextWidth(text, textFont); |
| var lineHeight = area.getTextHeight('国', textFont); |
| text = (text + '').split('\n'); |
| switch (textAlign) { |
| case 'end': |
| case 'right': |
| x -= width; |
| break; |
| case 'center': |
| x -= width / 2; |
| break; |
| } |
| switch (textBaseline) { |
| case 'top': |
| break; |
| case 'bottom': |
| y -= lineHeight * text.length; |
| break; |
| default: |
| y -= lineHeight * text.length / 2; |
| } |
| return { |
| x: x, |
| y: y, |
| width: width, |
| height: lineHeight * text.length |
| }; |
| } |
| var Base = function (options) { |
| options = options || {}; |
| this.id = options.id || guid(); |
| for (var key in options) { |
| this[key] = options[key]; |
| } |
| this.style = this.style || {}; |
| this.highlightStyle = this.highlightStyle || null; |
| this.parent = null; |
| this.__dirty = true; |
| this.__clipShapes = []; |
| Transformable.call(this); |
| Eventful.call(this); |
| }; |
| Base.prototype.invisible = false; |
| Base.prototype.ignore = false; |
| Base.prototype.zlevel = 0; |
| Base.prototype.draggable = false; |
| Base.prototype.clickable = false; |
| Base.prototype.hoverable = true; |
| Base.prototype.z = 0; |
| Base.prototype.brush = function (ctx, isHighlight) { |
| var style = this.beforeBrush(ctx, isHighlight); |
| ctx.beginPath(); |
| this.buildPath(ctx, style); |
| switch (style.brushType) { |
| case 'both': |
| ctx.fill(); |
| case 'stroke': |
| style.lineWidth > 0 && ctx.stroke(); |
| break; |
| default: |
| ctx.fill(); |
| } |
| this.drawText(ctx, style, this.style); |
| this.afterBrush(ctx); |
| }; |
| Base.prototype.beforeBrush = function (ctx, isHighlight) { |
| var style = this.style; |
| if (this.brushTypeOnly) { |
| style.brushType = this.brushTypeOnly; |
| } |
| if (isHighlight) { |
| style = this.getHighlightStyle(style, this.highlightStyle || {}, this.brushTypeOnly); |
| } |
| if (this.brushTypeOnly == 'stroke') { |
| style.strokeColor = style.strokeColor || style.color; |
| } |
| ctx.save(); |
| this.doClip(ctx); |
| this.setContext(ctx, style); |
| this.setTransform(ctx); |
| return style; |
| }; |
| Base.prototype.afterBrush = function (ctx) { |
| ctx.restore(); |
| }; |
| var STYLE_CTX_MAP = [ |
| [ |
| 'color', |
| 'fillStyle' |
| ], |
| [ |
| 'strokeColor', |
| 'strokeStyle' |
| ], |
| [ |
| 'opacity', |
| 'globalAlpha' |
| ], |
| [ |
| 'lineCap', |
| 'lineCap' |
| ], |
| [ |
| 'lineJoin', |
| 'lineJoin' |
| ], |
| [ |
| 'miterLimit', |
| 'miterLimit' |
| ], |
| [ |
| 'lineWidth', |
| 'lineWidth' |
| ], |
| [ |
| 'shadowBlur', |
| 'shadowBlur' |
| ], |
| [ |
| 'shadowColor', |
| 'shadowColor' |
| ], |
| [ |
| 'shadowOffsetX', |
| 'shadowOffsetX' |
| ], |
| [ |
| 'shadowOffsetY', |
| 'shadowOffsetY' |
| ] |
| ]; |
| Base.prototype.setContext = function (ctx, style) { |
| for (var i = 0, len = STYLE_CTX_MAP.length; i < len; i++) { |
| var styleProp = STYLE_CTX_MAP[i][0]; |
| var styleValue = style[styleProp]; |
| var ctxProp = STYLE_CTX_MAP[i][1]; |
| if (typeof styleValue != 'undefined') { |
| ctx[ctxProp] = styleValue; |
| } |
| } |
| }; |
| var clipShapeInvTransform = matrix.create(); |
| Base.prototype.doClip = function (ctx) { |
| if (this.__clipShapes && !vmlCanvasManager) { |
| for (var i = 0; i < this.__clipShapes.length; i++) { |
| var clipShape = this.__clipShapes[i]; |
| if (clipShape.needTransform) { |
| var m = clipShape.transform; |
| matrix.invert(clipShapeInvTransform, m); |
| ctx.transform(m[0], m[1], m[2], m[3], m[4], m[5]); |
| } |
| ctx.beginPath(); |
| clipShape.buildPath(ctx, clipShape.style); |
| ctx.clip(); |
| if (clipShape.needTransform) { |
| var m = clipShapeInvTransform; |
| ctx.transform(m[0], m[1], m[2], m[3], m[4], m[5]); |
| } |
| } |
| } |
| }; |
| Base.prototype.getHighlightStyle = function (style, highlightStyle, brushTypeOnly) { |
| var newStyle = {}; |
| for (var k in style) { |
| newStyle[k] = style[k]; |
| } |
| var color = require('../tool/color'); |
| var highlightColor = color.getHighlightColor(); |
| if (style.brushType != 'stroke') { |
| newStyle.strokeColor = highlightColor; |
| newStyle.lineWidth = (style.lineWidth || 1) + this.getHighlightZoom(); |
| newStyle.brushType = 'both'; |
| } else { |
| if (brushTypeOnly != 'stroke') { |
| newStyle.strokeColor = highlightColor; |
| newStyle.lineWidth = (style.lineWidth || 1) + this.getHighlightZoom(); |
| } else { |
| newStyle.strokeColor = highlightStyle.strokeColor || color.mix(style.strokeColor, color.toRGB(highlightColor)); |
| } |
| } |
| for (var k in highlightStyle) { |
| if (typeof highlightStyle[k] != 'undefined') { |
| newStyle[k] = highlightStyle[k]; |
| } |
| } |
| return newStyle; |
| }; |
| Base.prototype.getHighlightZoom = function () { |
| return this.type != 'text' ? 6 : 2; |
| }; |
| Base.prototype.drift = function (dx, dy) { |
| this.position[0] += dx; |
| this.position[1] += dy; |
| }; |
| Base.prototype.getTansform = function () { |
| var invTransform = []; |
| return function (x, y) { |
| var originPos = [ |
| x, |
| y |
| ]; |
| if (this.needTransform && this.transform) { |
| matrix.invert(invTransform, this.transform); |
| matrix.mulVector(originPos, invTransform, [ |
| x, |
| y, |
| 1 |
| ]); |
| if (x == originPos[0] && y == originPos[1]) { |
| this.updateNeedTransform(); |
| } |
| } |
| return originPos; |
| }; |
| }(); |
| Base.prototype.buildPath = function (ctx, style) { |
| log('buildPath not implemented in ' + this.type); |
| }; |
| Base.prototype.getRect = function (style) { |
| log('getRect not implemented in ' + this.type); |
| }; |
| Base.prototype.isCover = function (x, y) { |
| var originPos = this.getTansform(x, y); |
| x = originPos[0]; |
| y = originPos[1]; |
| var rect = this.style.__rect; |
| if (!rect) { |
| rect = this.style.__rect = this.getRect(this.style); |
| } |
| if (x >= rect.x && x <= rect.x + rect.width && y >= rect.y && y <= rect.y + rect.height) { |
| return require('../tool/area').isInside(this, this.style, x, y); |
| } |
| return false; |
| }; |
| Base.prototype.drawText = function (ctx, style, normalStyle) { |
| if (typeof style.text == 'undefined' || style.text === false) { |
| return; |
| } |
| var textColor = style.textColor || style.color || style.strokeColor; |
| ctx.fillStyle = textColor; |
| var dd = 10; |
| var al; |
| var bl; |
| var tx; |
| var ty; |
| var textPosition = style.textPosition || this.textPosition || 'top'; |
| switch (textPosition) { |
| case 'inside': |
| case 'top': |
| case 'bottom': |
| case 'left': |
| case 'right': |
| if (this.getRect) { |
| var rect = (normalStyle || style).__rect || this.getRect(normalStyle || style); |
| switch (textPosition) { |
| case 'inside': |
| tx = rect.x + rect.width / 2; |
| ty = rect.y + rect.height / 2; |
| al = 'center'; |
| bl = 'middle'; |
| if (style.brushType != 'stroke' && textColor == style.color) { |
| ctx.fillStyle = '#fff'; |
| } |
| break; |
| case 'left': |
| tx = rect.x - dd; |
| ty = rect.y + rect.height / 2; |
| al = 'end'; |
| bl = 'middle'; |
| break; |
| case 'right': |
| tx = rect.x + rect.width + dd; |
| ty = rect.y + rect.height / 2; |
| al = 'start'; |
| bl = 'middle'; |
| break; |
| case 'top': |
| tx = rect.x + rect.width / 2; |
| ty = rect.y - dd; |
| al = 'center'; |
| bl = 'bottom'; |
| break; |
| case 'bottom': |
| tx = rect.x + rect.width / 2; |
| ty = rect.y + rect.height + dd; |
| al = 'center'; |
| bl = 'top'; |
| break; |
| } |
| } |
| break; |
| case 'start': |
| case 'end': |
| var xStart; |
| var xEnd; |
| var yStart; |
| var yEnd; |
| if (typeof style.pointList != 'undefined') { |
| var pointList = style.pointList; |
| if (pointList.length < 2) { |
| return; |
| } |
| var length = pointList.length; |
| switch (textPosition) { |
| case 'start': |
| xStart = pointList[0][0]; |
| xEnd = pointList[1][0]; |
| yStart = pointList[0][1]; |
| yEnd = pointList[1][1]; |
| break; |
| case 'end': |
| xStart = pointList[length - 2][0]; |
| xEnd = pointList[length - 1][0]; |
| yStart = pointList[length - 2][1]; |
| yEnd = pointList[length - 1][1]; |
| break; |
| } |
| } else { |
| xStart = style.xStart || 0; |
| xEnd = style.xEnd || 0; |
| yStart = style.yStart || 0; |
| yEnd = style.yEnd || 0; |
| } |
| switch (textPosition) { |
| case 'start': |
| al = xStart < xEnd ? 'end' : 'start'; |
| bl = yStart < yEnd ? 'bottom' : 'top'; |
| tx = xStart; |
| ty = yStart; |
| break; |
| case 'end': |
| al = xStart < xEnd ? 'start' : 'end'; |
| bl = yStart < yEnd ? 'top' : 'bottom'; |
| tx = xEnd; |
| ty = yEnd; |
| break; |
| } |
| dd -= 4; |
| if (xStart != xEnd) { |
| tx -= al == 'end' ? dd : -dd; |
| } else { |
| al = 'center'; |
| } |
| if (yStart != yEnd) { |
| ty -= bl == 'bottom' ? dd : -dd; |
| } else { |
| bl = 'middle'; |
| } |
| break; |
| case 'specific': |
| tx = style.textX || 0; |
| ty = style.textY || 0; |
| al = 'start'; |
| bl = 'middle'; |
| break; |
| } |
| if (tx != null && ty != null) { |
| _fillText(ctx, style.text, tx, ty, style.textFont, style.textAlign || al, style.textBaseline || bl); |
| } |
| }; |
| Base.prototype.modSelf = function () { |
| this.__dirty = true; |
| if (this.style) { |
| this.style.__rect = null; |
| } |
| if (this.highlightStyle) { |
| this.highlightStyle.__rect = null; |
| } |
| }; |
| Base.prototype.isSilent = function () { |
| return !(this.hoverable || this.draggable || this.clickable || this.onmousemove || this.onmouseover || this.onmouseout || this.onmousedown || this.onmouseup || this.onclick || this.ondragenter || this.ondragover || this.ondragleave || this.ondrop); |
| }; |
| util.merge(Base.prototype, Transformable.prototype, true); |
| util.merge(Base.prototype, Eventful.prototype, true); |
| return Base; |
| });define('zrender/tool/curve', [ |
| 'require', |
| './vector' |
| ], function (require) { |
| var vector = require('./vector'); |
| 'use strict'; |
| var EPSILON = 0.0001; |
| var THREE_SQRT = Math.sqrt(3); |
| var ONE_THIRD = 1 / 3; |
| var _v0 = vector.create(); |
| var _v1 = vector.create(); |
| var _v2 = vector.create(); |
| function isAroundZero(val) { |
| return val > -EPSILON && val < EPSILON; |
| } |
| function isNotAroundZero(val) { |
| return val > EPSILON || val < -EPSILON; |
| } |
| function cubicAt(p0, p1, p2, p3, t) { |
| var onet = 1 - t; |
| return onet * onet * (onet * p0 + 3 * t * p1) + t * t * (t * p3 + 3 * onet * p2); |
| } |
| function cubicDerivativeAt(p0, p1, p2, p3, t) { |
| var onet = 1 - t; |
| return 3 * (((p1 - p0) * onet + 2 * (p2 - p1) * t) * onet + (p3 - p2) * t * t); |
| } |
| function cubicRootAt(p0, p1, p2, p3, val, roots) { |
| var a = p3 + 3 * (p1 - p2) - p0; |
| var b = 3 * (p2 - p1 * 2 + p0); |
| var c = 3 * (p1 - p0); |
| var d = p0 - val; |
| var A = b * b - 3 * a * c; |
| var B = b * c - 9 * a * d; |
| var C = c * c - 3 * b * d; |
| var n = 0; |
| if (isAroundZero(A) && isAroundZero(B)) { |
| if (isAroundZero(b)) { |
| roots[0] = 0; |
| } else { |
| var t1 = -c / b; |
| if (t1 >= 0 && t1 <= 1) { |
| roots[n++] = t1; |
| } |
| } |
| } else { |
| var disc = B * B - 4 * A * C; |
| if (isAroundZero(disc)) { |
| var K = B / A; |
| var t1 = -b / a + K; |
| var t2 = -K / 2; |
| if (t1 >= 0 && t1 <= 1) { |
| roots[n++] = t1; |
| } |
| if (t2 >= 0 && t2 <= 1) { |
| roots[n++] = t2; |
| } |
| } else if (disc > 0) { |
| var discSqrt = Math.sqrt(disc); |
| var Y1 = A * b + 1.5 * a * (-B + discSqrt); |
| var Y2 = A * b + 1.5 * a * (-B - discSqrt); |
| if (Y1 < 0) { |
| Y1 = -Math.pow(-Y1, ONE_THIRD); |
| } else { |
| Y1 = Math.pow(Y1, ONE_THIRD); |
| } |
| if (Y2 < 0) { |
| Y2 = -Math.pow(-Y2, ONE_THIRD); |
| } else { |
| Y2 = Math.pow(Y2, ONE_THIRD); |
| } |
| var t1 = (-b - (Y1 + Y2)) / (3 * a); |
| if (t1 >= 0 && t1 <= 1) { |
| roots[n++] = t1; |
| } |
| } else { |
| var T = (2 * A * b - 3 * a * B) / (2 * Math.sqrt(A * A * A)); |
| var theta = Math.acos(T) / 3; |
| var ASqrt = Math.sqrt(A); |
| var tmp = Math.cos(theta); |
| var t1 = (-b - 2 * ASqrt * tmp) / (3 * a); |
| var t2 = (-b + ASqrt * (tmp + THREE_SQRT * Math.sin(theta))) / (3 * a); |
| var t3 = (-b + ASqrt * (tmp - THREE_SQRT * Math.sin(theta))) / (3 * a); |
| if (t1 >= 0 && t1 <= 1) { |
| roots[n++] = t1; |
| } |
| if (t2 >= 0 && t2 <= 1) { |
| roots[n++] = t2; |
| } |
| if (t3 >= 0 && t3 <= 1) { |
| roots[n++] = t3; |
| } |
| } |
| } |
| return n; |
| } |
| function cubicExtrema(p0, p1, p2, p3, extrema) { |
| var b = 6 * p2 - 12 * p1 + 6 * p0; |
| var a = 9 * p1 + 3 * p3 - 3 * p0 - 9 * p2; |
| var c = 3 * p1 - 3 * p0; |
| var n = 0; |
| if (isAroundZero(a)) { |
| if (isNotAroundZero(b)) { |
| var t1 = -c / b; |
| if (t1 >= 0 && t1 <= 1) { |
| extrema[n++] = t1; |
| } |
| } |
| } else { |
| var disc = b * b - 4 * a * c; |
| if (isAroundZero(disc)) { |
| extrema[0] = -b / (2 * a); |
| } else if (disc > 0) { |
| var discSqrt = Math.sqrt(disc); |
| var t1 = (-b + discSqrt) / (2 * a); |
| var t2 = (-b - discSqrt) / (2 * a); |
| if (t1 >= 0 && t1 <= 1) { |
| extrema[n++] = t1; |
| } |
| if (t2 >= 0 && t2 <= 1) { |
| extrema[n++] = t2; |
| } |
| } |
| } |
| return n; |
| } |
| function cubicSubdivide(p0, p1, p2, p3, t, out) { |
| var p01 = (p1 - p0) * t + p0; |
| var p12 = (p2 - p1) * t + p1; |
| var p23 = (p3 - p2) * t + p2; |
| var p012 = (p12 - p01) * t + p01; |
| var p123 = (p23 - p12) * t + p12; |
| var p0123 = (p123 - p012) * t + p012; |
| out[0] = p0; |
| out[1] = p01; |
| out[2] = p012; |
| out[3] = p0123; |
| out[4] = p0123; |
| out[5] = p123; |
| out[6] = p23; |
| out[7] = p3; |
| } |
| function cubicProjectPoint(x0, y0, x1, y1, x2, y2, x3, y3, x, y, out) { |
| var t; |
| var interval = 0.005; |
| var d = Infinity; |
| _v0[0] = x; |
| _v0[1] = y; |
| for (var _t = 0; _t < 1; _t += 0.05) { |
| _v1[0] = cubicAt(x0, x1, x2, x3, _t); |
| _v1[1] = cubicAt(y0, y1, y2, y3, _t); |
| var d1 = vector.distSquare(_v0, _v1); |
| if (d1 < d) { |
| t = _t; |
| d = d1; |
| } |
| } |
| d = Infinity; |
| for (var i = 0; i < 32; i++) { |
| if (interval < EPSILON) { |
| break; |
| } |
| var prev = t - interval; |
| var next = t + interval; |
| _v1[0] = cubicAt(x0, x1, x2, x3, prev); |
| _v1[1] = cubicAt(y0, y1, y2, y3, prev); |
| var d1 = vector.distSquare(_v1, _v0); |
| if (prev >= 0 && d1 < d) { |
| t = prev; |
| d = d1; |
| } else { |
| _v2[0] = cubicAt(x0, x1, x2, x3, next); |
| _v2[1] = cubicAt(y0, y1, y2, y3, next); |
| var d2 = vector.distSquare(_v2, _v0); |
| if (next <= 1 && d2 < d) { |
| t = next; |
| d = d2; |
| } else { |
| interval *= 0.5; |
| } |
| } |
| } |
| if (out) { |
| out[0] = cubicAt(x0, x1, x2, x3, t); |
| out[1] = cubicAt(y0, y1, y2, y3, t); |
| } |
| return Math.sqrt(d); |
| } |
| function quadraticAt(p0, p1, p2, t) { |
| var onet = 1 - t; |
| return onet * (onet * p0 + 2 * t * p1) + t * t * p2; |
| } |
| function quadraticDerivativeAt(p0, p1, p2, t) { |
| return 2 * ((1 - t) * (p1 - p0) + t * (p2 - p1)); |
| } |
| function quadraticRootAt(p0, p1, p2, val, roots) { |
| var a = p0 - 2 * p1 + p2; |
| var b = 2 * (p1 - p0); |
| var c = p0 - val; |
| var n = 0; |
| if (isAroundZero(a)) { |
| if (isNotAroundZero(b)) { |
| var t1 = -c / b; |
| if (t1 >= 0 && t1 <= 1) { |
| roots[n++] = t1; |
| } |
| } |
| } else { |
| var disc = b * b - 4 * a * c; |
| if (isAroundZero(disc)) { |
| var t1 = -b / (2 * a); |
| if (t1 >= 0 && t1 <= 1) { |
| roots[n++] = t1; |
| } |
| } else if (disc > 0) { |
| var discSqrt = Math.sqrt(disc); |
| var t1 = (-b + discSqrt) / (2 * a); |
| var t2 = (-b - discSqrt) / (2 * a); |
| if (t1 >= 0 && t1 <= 1) { |
| roots[n++] = t1; |
| } |
| if (t2 >= 0 && t2 <= 1) { |
| roots[n++] = t2; |
| } |
| } |
| } |
| return n; |
| } |
| function quadraticExtremum(p0, p1, p2) { |
| var divider = p0 + p2 - 2 * p1; |
| if (divider === 0) { |
| return 0.5; |
| } else { |
| return (p0 - p1) / divider; |
| } |
| } |
| function quadraticProjectPoint(x0, y0, x1, y1, x2, y2, x, y, out) { |
| var t; |
| var interval = 0.005; |
| var d = Infinity; |
| _v0[0] = x; |
| _v0[1] = y; |
| for (var _t = 0; _t < 1; _t += 0.05) { |
| _v1[0] = quadraticAt(x0, x1, x2, _t); |
| _v1[1] = quadraticAt(y0, y1, y2, _t); |
| var d1 = vector.distSquare(_v0, _v1); |
| if (d1 < d) { |
| t = _t; |
| d = d1; |
| } |
| } |
| d = Infinity; |
| for (var i = 0; i < 32; i++) { |
| if (interval < EPSILON) { |
| break; |
| } |
| var prev = t - interval; |
| var next = t + interval; |
| _v1[0] = quadraticAt(x0, x1, x2, prev); |
| _v1[1] = quadraticAt(y0, y1, y2, prev); |
| var d1 = vector.distSquare(_v1, _v0); |
| if (prev >= 0 && d1 < d) { |
| t = prev; |
| d = d1; |
| } else { |
| _v2[0] = quadraticAt(x0, x1, x2, next); |
| _v2[1] = quadraticAt(y0, y1, y2, next); |
| var d2 = vector.distSquare(_v2, _v0); |
| if (next <= 1 && d2 < d) { |
| t = next; |
| d = d2; |
| } else { |
| interval *= 0.5; |
| } |
| } |
| } |
| if (out) { |
| out[0] = quadraticAt(x0, x1, x2, t); |
| out[1] = quadraticAt(y0, y1, y2, t); |
| } |
| return Math.sqrt(d); |
| } |
| return { |
| cubicAt: cubicAt, |
| cubicDerivativeAt: cubicDerivativeAt, |
| cubicRootAt: cubicRootAt, |
| cubicExtrema: cubicExtrema, |
| cubicSubdivide: cubicSubdivide, |
| cubicProjectPoint: cubicProjectPoint, |
| quadraticAt: quadraticAt, |
| quadraticDerivativeAt: quadraticDerivativeAt, |
| quadraticRootAt: quadraticRootAt, |
| quadraticExtremum: quadraticExtremum, |
| quadraticProjectPoint: quadraticProjectPoint |
| }; |
| });define('zrender/Group', [ |
| 'require', |
| './tool/guid', |
| './tool/util', |
| './mixin/Transformable', |
| './mixin/Eventful' |
| ], function (require) { |
| var guid = require('./tool/guid'); |
| var util = require('./tool/util'); |
| var Transformable = require('./mixin/Transformable'); |
| var Eventful = require('./mixin/Eventful'); |
| var Group = function (options) { |
| options = options || {}; |
| this.id = options.id || guid(); |
| for (var key in options) { |
| this[key] = options[key]; |
| } |
| this.type = 'group'; |
| this.clipShape = null; |
| this._children = []; |
| this._storage = null; |
| this.__dirty = true; |
| Transformable.call(this); |
| Eventful.call(this); |
| }; |
| Group.prototype.ignore = false; |
| Group.prototype.children = function () { |
| return this._children.slice(); |
| }; |
| Group.prototype.childAt = function (idx) { |
| return this._children[idx]; |
| }; |
| Group.prototype.addChild = function (child) { |
| if (child == this) { |
| return; |
| } |
| if (child.parent == this) { |
| return; |
| } |
| if (child.parent) { |
| child.parent.removeChild(child); |
| } |
| this._children.push(child); |
| child.parent = this; |
| if (this._storage && this._storage !== child._storage) { |
| this._storage.addToMap(child); |
| if (child instanceof Group) { |
| child.addChildrenToStorage(this._storage); |
| } |
| } |
| }; |
| Group.prototype.removeChild = function (child) { |
| var idx = util.indexOf(this._children, child); |
| this._children.splice(idx, 1); |
| child.parent = null; |
| if (this._storage) { |
| this._storage.delFromMap(child.id); |
| if (child instanceof Group) { |
| child.delChildrenFromStorage(this._storage); |
| } |
| } |
| }; |
| Group.prototype.eachChild = function (cb, context) { |
| var haveContext = !!context; |
| for (var i = 0; i < this._children.length; i++) { |
| var child = this._children[i]; |
| if (haveContext) { |
| cb.call(context, child); |
| } else { |
| cb(child); |
| } |
| } |
| }; |
| Group.prototype.traverse = function (cb, context) { |
| var haveContext = !!context; |
| for (var i = 0; i < this._children.length; i++) { |
| var child = this._children[i]; |
| if (haveContext) { |
| cb.call(context, child); |
| } else { |
| cb(child); |
| } |
| if (child.type === 'group') { |
| child.traverse(cb, context); |
| } |
| } |
| }; |
| Group.prototype.addChildrenToStorage = function (storage) { |
| for (var i = 0; i < this._children.length; i++) { |
| var child = this._children[i]; |
| storage.addToMap(child); |
| if (child.type === 'group') { |
| child.addChildrenToStorage(storage); |
| } |
| } |
| }; |
| Group.prototype.delChildrenFromStorage = function (storage) { |
| for (var i = 0; i < this._children.length; i++) { |
| var child = this._children[i]; |
| storage.delFromMap(child.id); |
| if (child.type === 'group') { |
| child.delChildrenFromStorage(storage); |
| } |
| } |
| }; |
| Group.prototype.modSelf = function () { |
| this.__dirty = true; |
| }; |
| util.merge(Group.prototype, Transformable.prototype, true); |
| util.merge(Group.prototype, Eventful.prototype, true); |
| return Group; |
| });define('zrender/animation/Clip', [ |
| 'require', |
| './easing' |
| ], function (require) { |
| var Easing = require('./easing'); |
| function Clip(options) { |
| this._targetPool = options.target || {}; |
| if (!(this._targetPool instanceof Array)) { |
| this._targetPool = [this._targetPool]; |
| } |
| this._life = options.life || 1000; |
| this._delay = options.delay || 0; |
| this._startTime = new Date().getTime() + this._delay; |
| this._endTime = this._startTime + this._life * 1000; |
| this.loop = typeof options.loop == 'undefined' ? false : options.loop; |
| this.gap = options.gap || 0; |
| this.easing = options.easing || 'Linear'; |
| this.onframe = options.onframe; |
| this.ondestroy = options.ondestroy; |
| this.onrestart = options.onrestart; |
| } |
| Clip.prototype = { |
| step: function (time) { |
| var percent = (time - this._startTime) / this._life; |
| if (percent < 0) { |
| return; |
| } |
| percent = Math.min(percent, 1); |
| var easingFunc = typeof this.easing == 'string' ? Easing[this.easing] : this.easing; |
| var schedule = typeof easingFunc === 'function' ? easingFunc(percent) : percent; |
| this.fire('frame', schedule); |
| if (percent == 1) { |
| if (this.loop) { |
| this.restart(); |
| return 'restart'; |
| } |
| this._needsRemove = true; |
| return 'destroy'; |
| } |
| return null; |
| }, |
| restart: function () { |
| var time = new Date().getTime(); |
| var remainder = (time - this._startTime) % this._life; |
| this._startTime = new Date().getTime() - remainder + this.gap; |
| this._needsRemove = false; |
| }, |
| fire: function (eventType, arg) { |
| for (var i = 0, len = this._targetPool.length; i < len; i++) { |
| if (this['on' + eventType]) { |
| this['on' + eventType](this._targetPool[i], arg); |
| } |
| } |
| }, |
| constructor: Clip |
| }; |
| return Clip; |
| });define('zrender/animation/easing', [], function () { |
| var easing = { |
| Linear: function (k) { |
| return k; |
| }, |
| QuadraticIn: function (k) { |
| return k * k; |
| }, |
| QuadraticOut: function (k) { |
| return k * (2 - k); |
| }, |
| QuadraticInOut: function (k) { |
| if ((k *= 2) < 1) { |
| return 0.5 * k * k; |
| } |
| return -0.5 * (--k * (k - 2) - 1); |
| }, |
| CubicIn: function (k) { |
| return k * k * k; |
| }, |
| CubicOut: function (k) { |
| return --k * k * k + 1; |
| }, |
| CubicInOut: function (k) { |
| if ((k *= 2) < 1) { |
| return 0.5 * k * k * k; |
| } |
| return 0.5 * ((k -= 2) * k * k + 2); |
| }, |
| QuarticIn: function (k) { |
| return k * k * k * k; |
| }, |
| QuarticOut: function (k) { |
| return 1 - --k * k * k * k; |
| }, |
| QuarticInOut: function (k) { |
| if ((k *= 2) < 1) { |
| return 0.5 * k * k * k * k; |
| } |
| return -0.5 * ((k -= 2) * k * k * k - 2); |
| }, |
| QuinticIn: function (k) { |
| return k * k * k * k * k; |
| }, |
| QuinticOut: function (k) { |
| return --k * k * k * k * k + 1; |
| }, |
| QuinticInOut: function (k) { |
| if ((k *= 2) < 1) { |
| return 0.5 * k * k * k * k * k; |
| } |
| return 0.5 * ((k -= 2) * k * k * k * k + 2); |
| }, |
| SinusoidalIn: function (k) { |
| return 1 - Math.cos(k * Math.PI / 2); |
| }, |
| SinusoidalOut: function (k) { |
| return Math.sin(k * Math.PI / 2); |
| }, |
| SinusoidalInOut: function (k) { |
| return 0.5 * (1 - Math.cos(Math.PI * k)); |
| }, |
| ExponentialIn: function (k) { |
| return k === 0 ? 0 : Math.pow(1024, k - 1); |
| }, |
| ExponentialOut: function (k) { |
| return k === 1 ? 1 : 1 - Math.pow(2, -10 * k); |
| }, |
| ExponentialInOut: function (k) { |
| if (k === 0) { |
| return 0; |
| } |
| if (k === 1) { |
| return 1; |
| } |
| if ((k *= 2) < 1) { |
| return 0.5 * Math.pow(1024, k - 1); |
| } |
| return 0.5 * (-Math.pow(2, -10 * (k - 1)) + 2); |
| }, |
| CircularIn: function (k) { |
| return 1 - Math.sqrt(1 - k * k); |
| }, |
| CircularOut: function (k) { |
| return Math.sqrt(1 - --k * k); |
| }, |
| CircularInOut: function (k) { |
| if ((k *= 2) < 1) { |
| return -0.5 * (Math.sqrt(1 - k * k) - 1); |
| } |
| return 0.5 * (Math.sqrt(1 - (k -= 2) * k) + 1); |
| }, |
| ElasticIn: function (k) { |
| var s; |
| var a = 0.1; |
| var p = 0.4; |
| if (k === 0) { |
| return 0; |
| } |
| if (k === 1) { |
| return 1; |
| } |
| if (!a || a < 1) { |
| a = 1; |
| s = p / 4; |
| } else { |
| s = p * Math.asin(1 / a) / (2 * Math.PI); |
| } |
| return -(a * Math.pow(2, 10 * (k -= 1)) * Math.sin((k - s) * (2 * Math.PI) / p)); |
| }, |
| ElasticOut: function (k) { |
| var s; |
| var a = 0.1; |
| var p = 0.4; |
| if (k === 0) { |
| return 0; |
| } |
| if (k === 1) { |
| return 1; |
| } |
| if (!a || a < 1) { |
| a = 1; |
| s = p / 4; |
| } else { |
| s = p * Math.asin(1 / a) / (2 * Math.PI); |
| } |
| return a * Math.pow(2, -10 * k) * Math.sin((k - s) * (2 * Math.PI) / p) + 1; |
| }, |
| ElasticInOut: function (k) { |
| var s; |
| var a = 0.1; |
| var p = 0.4; |
| if (k === 0) { |
| return 0; |
| } |
| if (k === 1) { |
| return 1; |
| } |
| if (!a || a < 1) { |
| a = 1; |
| s = p / 4; |
| } else { |
| s = p * Math.asin(1 / a) / (2 * Math.PI); |
| } |
| if ((k *= 2) < 1) { |
| return -0.5 * (a * Math.pow(2, 10 * (k -= 1)) * Math.sin((k - s) * (2 * Math.PI) / p)); |
| } |
| return a * Math.pow(2, -10 * (k -= 1)) * Math.sin((k - s) * (2 * Math.PI) / p) * 0.5 + 1; |
| }, |
| BackIn: function (k) { |
| var s = 1.70158; |
| return k * k * ((s + 1) * k - s); |
| }, |
| BackOut: function (k) { |
| var s = 1.70158; |
| return --k * k * ((s + 1) * k + s) + 1; |
| }, |
| BackInOut: function (k) { |
| var s = 1.70158 * 1.525; |
| if ((k *= 2) < 1) { |
| return 0.5 * (k * k * ((s + 1) * k - s)); |
| } |
| return 0.5 * ((k -= 2) * k * ((s + 1) * k + s) + 2); |
| }, |
| BounceIn: function (k) { |
| return 1 - easing.BounceOut(1 - k); |
| }, |
| BounceOut: function (k) { |
| if (k < 1 / 2.75) { |
| return 7.5625 * k * k; |
| } else if (k < 2 / 2.75) { |
| return 7.5625 * (k -= 1.5 / 2.75) * k + 0.75; |
| } else if (k < 2.5 / 2.75) { |
| return 7.5625 * (k -= 2.25 / 2.75) * k + 0.9375; |
| } else { |
| return 7.5625 * (k -= 2.625 / 2.75) * k + 0.984375; |
| } |
| }, |
| BounceInOut: function (k) { |
| if (k < 0.5) { |
| return easing.BounceIn(k * 2) * 0.5; |
| } |
| return easing.BounceOut(k * 2 - 1) * 0.5 + 0.5; |
| } |
| }; |
| return easing; |
| });define('echarts/component/base', [ |
| 'require', |
| '../config', |
| '../util/ecData', |
| '../util/ecQuery', |
| '../util/number', |
| 'zrender/tool/util', |
| 'zrender/tool/env' |
| ], function (require) { |
| var ecConfig = require('../config'); |
| var ecData = require('../util/ecData'); |
| var ecQuery = require('../util/ecQuery'); |
| var number = require('../util/number'); |
| var zrUtil = require('zrender/tool/util'); |
| function Base(ecTheme, messageCenter, zr, option, myChart) { |
| this.ecTheme = ecTheme; |
| this.messageCenter = messageCenter; |
| this.zr = zr; |
| this.option = option; |
| this.series = option.series; |
| this.myChart = myChart; |
| this.component = myChart.component; |
| this._zlevelBase = this.getZlevelBase(); |
| this.shapeList = []; |
| this.effectList = []; |
| var self = this; |
| self._onlegendhoverlink = function (param) { |
| if (self.legendHoverLink) { |
| var targetName = param.target; |
| var name; |
| for (var i = self.shapeList.length - 1; i >= 0; i--) { |
| name = self.type == ecConfig.CHART_TYPE_PIE || self.type == ecConfig.CHART_TYPE_FUNNEL ? ecData.get(self.shapeList[i], 'name') : (ecData.get(self.shapeList[i], 'series') || {}).name; |
| if (name == targetName && !self.shapeList[i].invisible) { |
| self.zr.addHoverShape(self.shapeList[i]); |
| } |
| } |
| } |
| }; |
| messageCenter && messageCenter.bind(ecConfig.EVENT.LEGEND_HOVERLINK, this._onlegendhoverlink); |
| } |
| Base.prototype = { |
| canvasSupported: require('zrender/tool/env').canvasSupported, |
| getZlevelBase: function (contentType) { |
| contentType = contentType || this.type + ''; |
| switch (contentType) { |
| case ecConfig.COMPONENT_TYPE_GRID: |
| case ecConfig.COMPONENT_TYPE_AXIS_CATEGORY: |
| case ecConfig.COMPONENT_TYPE_AXIS_VALUE: |
| case ecConfig.COMPONENT_TYPE_POLAR: |
| return 0; |
| case ecConfig.CHART_TYPE_LINE: |
| case ecConfig.CHART_TYPE_BAR: |
| case ecConfig.CHART_TYPE_SCATTER: |
| case ecConfig.CHART_TYPE_PIE: |
| case ecConfig.CHART_TYPE_RADAR: |
| case ecConfig.CHART_TYPE_MAP: |
| case ecConfig.CHART_TYPE_K: |
| case ecConfig.CHART_TYPE_CHORD: |
| case ecConfig.CHART_TYPE_GUAGE: |
| case ecConfig.CHART_TYPE_FUNNEL: |
| case ecConfig.CHART_TYPE_EVENTRIVER: |
| return 2; |
| case ecConfig.COMPONENT_TYPE_LEGEND: |
| case ecConfig.COMPONENT_TYPE_DATARANGE: |
| case ecConfig.COMPONENT_TYPE_DATAZOOM: |
| case ecConfig.COMPONENT_TYPE_TIMELINE: |
| case ecConfig.COMPONENT_TYPE_ROAMCONTROLLER: |
| return 4; |
| case ecConfig.CHART_TYPE_ISLAND: |
| return 5; |
| case ecConfig.COMPONENT_TYPE_TOOLBOX: |
| case ecConfig.COMPONENT_TYPE_TITLE: |
| return 6; |
| case ecConfig.COMPONENT_TYPE_TOOLTIP: |
| return 8; |
| default: |
| return 0; |
| } |
| }, |
| reformOption: function (opt) { |
| return zrUtil.merge(opt || {}, zrUtil.clone(this.ecTheme[this.type] || {})); |
| }, |
| reformCssArray: function (p) { |
| if (p instanceof Array) { |
| switch (p.length + '') { |
| case '4': |
| return p; |
| case '3': |
| return [ |
| p[0], |
| p[1], |
| p[2], |
| p[1] |
| ]; |
| case '2': |
| return [ |
| p[0], |
| p[1], |
| p[0], |
| p[1] |
| ]; |
| case '1': |
| return [ |
| p[0], |
| p[0], |
| p[0], |
| p[0] |
| ]; |
| case '0': |
| return [ |
| 0, |
| 0, |
| 0, |
| 0 |
| ]; |
| } |
| } else { |
| return [ |
| p, |
| p, |
| p, |
| p |
| ]; |
| } |
| }, |
| getShapeById: function (id) { |
| for (var i = 0, l = this.shapeList.length; i < l; i++) { |
| if (this.shapeList[i].id === id) { |
| return this.shapeList[i]; |
| } |
| } |
| return null; |
| }, |
| getFont: function (textStyle) { |
| var finalTextStyle = zrUtil.merge(zrUtil.clone(textStyle) || {}, this.ecTheme.textStyle); |
| return finalTextStyle.fontStyle + ' ' + finalTextStyle.fontWeight + ' ' + finalTextStyle.fontSize + 'px ' + finalTextStyle.fontFamily; |
| }, |
| getItemStyleColor: function (itemColor, seriesIndex, dataIndex, data) { |
| return typeof itemColor === 'function' ? itemColor.call(this.myChart, { |
| seriesIndex: seriesIndex, |
| series: this.series[seriesIndex], |
| dataIndex: dataIndex, |
| data: data |
| }) : itemColor; |
| }, |
| subPixelOptimize: function (position, lineWidth) { |
| if (lineWidth % 2 === 1) { |
| position = Math.floor(position) + 0.5; |
| } else { |
| position = Math.round(position); |
| } |
| return position; |
| }, |
| resize: function () { |
| this.refresh && this.refresh(); |
| this.clearEffectShape && this.clearEffectShape(true); |
| var self = this; |
| setTimeout(function () { |
| self.animationEffect && self.animationEffect(); |
| }, 200); |
| }, |
| clear: function () { |
| this.clearEffectShape && this.clearEffectShape(); |
| this.zr && this.zr.delShape(this.shapeList); |
| this.shapeList = []; |
| }, |
| dispose: function () { |
| this.onbeforDispose && this.onbeforDispose(); |
| this.clear(); |
| this.shapeList = null; |
| this.effectList = null; |
| this.messageCenter && this.messageCenter.unbind(ecConfig.EVENT.LEGEND_HOVERLINK, this._onlegendhoverlink); |
| this.onafterDispose && this.onafterDispose(); |
| }, |
| query: ecQuery.query, |
| deepQuery: ecQuery.deepQuery, |
| deepMerge: ecQuery.deepMerge, |
| parsePercent: number.parsePercent, |
| parseCenter: number.parseCenter, |
| parseRadius: number.parseRadius, |
| numAddCommas: number.addCommas |
| }; |
| return Base; |
| });define('echarts/chart/base', [ |
| 'require', |
| 'zrender/shape/Image', |
| '../util/shape/Icon', |
| '../util/shape/MarkLine', |
| '../util/shape/Symbol', |
| '../config', |
| '../util/ecData', |
| '../util/ecAnimation', |
| '../util/ecEffect', |
| '../util/accMath', |
| 'zrender/tool/util', |
| 'zrender/tool/area' |
| ], function (require) { |
| var ImageShape = require('zrender/shape/Image'); |
| var IconShape = require('../util/shape/Icon'); |
| var MarkLineShape = require('../util/shape/MarkLine'); |
| var SymbolShape = require('../util/shape/Symbol'); |
| var ecConfig = require('../config'); |
| var ecData = require('../util/ecData'); |
| var ecAnimation = require('../util/ecAnimation'); |
| var ecEffect = require('../util/ecEffect'); |
| var accMath = require('../util/accMath'); |
| var zrUtil = require('zrender/tool/util'); |
| var zrArea = require('zrender/tool/area'); |
| function Base() { |
| var self = this; |
| this.selectedMap = {}; |
| this.lastShapeList = []; |
| this.shapeHandler = { |
| onclick: function () { |
| self.isClick = true; |
| }, |
| ondragover: function (param) { |
| var calculableShape = param.target; |
| calculableShape.highlightStyle = calculableShape.highlightStyle || {}; |
| var highlightStyle = calculableShape.highlightStyle; |
| var brushType = highlightStyle.brushTyep; |
| var strokeColor = highlightStyle.strokeColor; |
| var lineWidth = highlightStyle.lineWidth; |
| highlightStyle.brushType = 'stroke'; |
| highlightStyle.strokeColor = self.ecTheme.calculableColor; |
| highlightStyle.lineWidth = calculableShape.type === 'icon' ? 30 : 10; |
| self.zr.addHoverShape(calculableShape); |
| setTimeout(function () { |
| if (calculableShape.highlightStyle) { |
| calculableShape.highlightStyle.brushType = brushType; |
| calculableShape.highlightStyle.strokeColor = strokeColor; |
| calculableShape.highlightStyle.lineWidth = lineWidth; |
| } |
| }, 20); |
| }, |
| ondrop: function (param) { |
| if (ecData.get(param.dragged, 'data') != null) { |
| self.isDrop = true; |
| } |
| }, |
| ondragend: function () { |
| self.isDragend = true; |
| } |
| }; |
| } |
| Base.prototype = { |
| setCalculable: function (shape) { |
| shape.dragEnableTime = this.ecTheme.DRAG_ENABLE_TIME; |
| shape.ondragover = this.shapeHandler.ondragover; |
| shape.ondragend = this.shapeHandler.ondragend; |
| shape.ondrop = this.shapeHandler.ondrop; |
| return shape; |
| }, |
| ondrop: function (param, status) { |
| if (!this.isDrop || !param.target || status.dragIn) { |
| return; |
| } |
| var target = param.target; |
| var dragged = param.dragged; |
| var seriesIndex = ecData.get(target, 'seriesIndex'); |
| var dataIndex = ecData.get(target, 'dataIndex'); |
| var series = this.series; |
| var data; |
| var legend = this.component.legend; |
| if (dataIndex === -1) { |
| if (ecData.get(dragged, 'seriesIndex') == seriesIndex) { |
| status.dragOut = status.dragIn = status.needRefresh = true; |
| this.isDrop = false; |
| return; |
| } |
| data = { |
| value: ecData.get(dragged, 'value'), |
| name: ecData.get(dragged, 'name') |
| }; |
| if (this.type === ecConfig.CHART_TYPE_PIE && data.value < 0) { |
| data.value = 0; |
| } |
| var hasFind = false; |
| var sData = series[seriesIndex].data; |
| for (var i = 0, l = sData.length; i < l; i++) { |
| if (sData[i].name === data.name && sData[i].value === '-') { |
| series[seriesIndex].data[i].value = data.value; |
| hasFind = true; |
| } |
| } |
| !hasFind && series[seriesIndex].data.push(data); |
| legend && legend.add(data.name, dragged.style.color || dragged.style.strokeColor); |
| } else { |
| data = this.option.series[seriesIndex].data[dataIndex] || '-'; |
| if (data.value != null) { |
| if (data.value != '-') { |
| this.option.series[seriesIndex].data[dataIndex].value = accMath.accAdd(this.option.series[seriesIndex].data[dataIndex].value, ecData.get(dragged, 'value')); |
| } else { |
| this.option.series[seriesIndex].data[dataIndex].value = ecData.get(dragged, 'value'); |
| } |
| if (this.type === ecConfig.CHART_TYPE_FUNNEL || this.type === ecConfig.CHART_TYPE_PIE) { |
| legend && legend.getRelatedAmount(data.name) === 1 && this.component.legend.del(data.name); |
| data.name += this.option.nameConnector + ecData.get(dragged, 'name'); |
| legend && legend.add(data.name, dragged.style.color || dragged.style.strokeColor); |
| } |
| } else { |
| if (data != '-') { |
| this.option.series[seriesIndex].data[dataIndex] = accMath.accAdd(this.option.series[seriesIndex].data[dataIndex], ecData.get(dragged, 'value')); |
| } else { |
| this.option.series[seriesIndex].data[dataIndex] = ecData.get(dragged, 'value'); |
| } |
| } |
| } |
| status.dragIn = status.dragIn || true; |
| this.isDrop = false; |
| var self = this; |
| setTimeout(function () { |
| self.zr.trigger('mousemove', param.event); |
| }, 300); |
| return; |
| }, |
| ondragend: function (param, status) { |
| if (!this.isDragend || !param.target || status.dragOut) { |
| return; |
| } |
| var target = param.target; |
| var seriesIndex = ecData.get(target, 'seriesIndex'); |
| var dataIndex = ecData.get(target, 'dataIndex'); |
| var series = this.series; |
| if (series[seriesIndex].data[dataIndex].value != null) { |
| series[seriesIndex].data[dataIndex].value = '-'; |
| var name = series[seriesIndex].data[dataIndex].name; |
| if (this.component.legend && this.component.legend.getRelatedAmount(name) === 0) { |
| this.component.legend.del(name); |
| } |
| } else { |
| series[seriesIndex].data[dataIndex] = '-'; |
| } |
| status.dragOut = true; |
| status.needRefresh = true; |
| this.isDragend = false; |
| return; |
| }, |
| onlegendSelected: function (param, status) { |
| var legendSelected = param.selected; |
| for (var itemName in this.selectedMap) { |
| if (this.selectedMap[itemName] != legendSelected[itemName]) { |
| status.needRefresh = true; |
| } |
| this.selectedMap[itemName] = legendSelected[itemName]; |
| } |
| return; |
| }, |
| _bulidPosition: function () { |
| this._symbol = this.option.symbolList; |
| this._sIndex2ShapeMap = {}; |
| this._sIndex2ColorMap = {}; |
| this.selectedMap = {}; |
| this.xMarkMap = {}; |
| var series = this.series; |
| var _position2sIndexMap = { |
| top: [], |
| bottom: [], |
| left: [], |
| right: [], |
| other: [] |
| }; |
| var xAxisIndex; |
| var yAxisIndex; |
| var xAxis; |
| var yAxis; |
| for (var i = 0, l = series.length; i < l; i++) { |
| if (series[i].type === this.type) { |
| series[i] = this.reformOption(series[i]); |
| this.legendHoverLink = series[i].legendHoverLink || this.legendHoverLink; |
| xAxisIndex = series[i].xAxisIndex; |
| yAxisIndex = series[i].yAxisIndex; |
| xAxis = this.component.xAxis.getAxis(xAxisIndex); |
| yAxis = this.component.yAxis.getAxis(yAxisIndex); |
| if (xAxis.type === ecConfig.COMPONENT_TYPE_AXIS_CATEGORY) { |
| _position2sIndexMap[xAxis.getPosition()].push(i); |
| } else if (yAxis.type === ecConfig.COMPONENT_TYPE_AXIS_CATEGORY) { |
| _position2sIndexMap[yAxis.getPosition()].push(i); |
| } else { |
| _position2sIndexMap.other.push(i); |
| } |
| } |
| } |
| for (var position in _position2sIndexMap) { |
| if (_position2sIndexMap[position].length > 0) { |
| this._buildSinglePosition(position, _position2sIndexMap[position]); |
| } |
| } |
| this.addShapeList(); |
| }, |
| _buildSinglePosition: function (position, seriesArray) { |
| var mapData = this._mapData(seriesArray); |
| var locationMap = mapData.locationMap; |
| var maxDataLength = mapData.maxDataLength; |
| if (maxDataLength === 0 || locationMap.length === 0) { |
| return; |
| } |
| switch (position) { |
| case 'bottom': |
| case 'top': |
| this._buildHorizontal(seriesArray, maxDataLength, locationMap, this.xMarkMap); |
| break; |
| case 'left': |
| case 'right': |
| this._buildVertical(seriesArray, maxDataLength, locationMap, this.xMarkMap); |
| break; |
| case 'other': |
| this._buildOther(seriesArray, maxDataLength, locationMap, this.xMarkMap); |
| break; |
| } |
| for (var i = 0, l = seriesArray.length; i < l; i++) { |
| this.buildMark(seriesArray[i]); |
| } |
| }, |
| _mapData: function (seriesArray) { |
| var series = this.series; |
| var serie; |
| var dataIndex = 0; |
| var stackMap = {}; |
| var magicStackKey = '__kener__stack__'; |
| var stackKey; |
| var serieName; |
| var legend = this.component.legend; |
| var locationMap = []; |
| var maxDataLength = 0; |
| var iconShape; |
| for (var i = 0, l = seriesArray.length; i < l; i++) { |
| serie = series[seriesArray[i]]; |
| serieName = serie.name; |
| this._sIndex2ShapeMap[seriesArray[i]] = this._sIndex2ShapeMap[seriesArray[i]] || this.query(serie, 'symbol') || this._symbol[i % this._symbol.length]; |
| if (legend) { |
| this.selectedMap[serieName] = legend.isSelected(serieName); |
| this._sIndex2ColorMap[seriesArray[i]] = legend.getColor(serieName); |
| iconShape = legend.getItemShape(serieName); |
| if (iconShape) { |
| if (this.type == ecConfig.CHART_TYPE_LINE) { |
| iconShape.style.iconType = 'legendLineIcon'; |
| iconShape.style.symbol = this._sIndex2ShapeMap[seriesArray[i]]; |
| } else if (serie.itemStyle.normal.barBorderWidth > 0) { |
| iconShape.style.x += 1; |
| iconShape.style.y += 1; |
| iconShape.style.width -= 2; |
| iconShape.style.height -= 2; |
| iconShape.style.strokeColor = iconShape.highlightStyle.strokeColor = serie.itemStyle.normal.barBorderColor; |
| iconShape.highlightStyle.lineWidth = 3; |
| iconShape.style.brushType = 'both'; |
| } |
| legend.setItemShape(serieName, iconShape); |
| } |
| } else { |
| this.selectedMap[serieName] = true; |
| this._sIndex2ColorMap[seriesArray[i]] = this.zr.getColor(seriesArray[i]); |
| } |
| if (this.selectedMap[serieName]) { |
| stackKey = serie.stack || magicStackKey + seriesArray[i]; |
| if (stackMap[stackKey] == null) { |
| stackMap[stackKey] = dataIndex; |
| locationMap[dataIndex] = [seriesArray[i]]; |
| dataIndex++; |
| } else { |
| locationMap[stackMap[stackKey]].push(seriesArray[i]); |
| } |
| } |
| maxDataLength = Math.max(maxDataLength, serie.data.length); |
| } |
| return { |
| locationMap: locationMap, |
| maxDataLength: maxDataLength |
| }; |
| }, |
| _calculMarkMapXY: function (xMarkMap, locationMap, xy) { |
| var series = this.series; |
| for (var j = 0, k = locationMap.length; j < k; j++) { |
| for (var m = 0, n = locationMap[j].length; m < n; m++) { |
| var seriesIndex = locationMap[j][m]; |
| var valueIndex = xy == 'xy' ? 0 : ''; |
| if (xy.indexOf('x') != '-1') { |
| if (xMarkMap[seriesIndex]['counter' + valueIndex] > 0) { |
| xMarkMap[seriesIndex]['average' + valueIndex] = (xMarkMap[seriesIndex]['sum' + valueIndex] / xMarkMap[seriesIndex]['counter' + valueIndex]).toFixed(2) - 0; |
| } |
| var x = this.component.xAxis.getAxis(series[seriesIndex].xAxisIndex || 0).getCoord(xMarkMap[seriesIndex]['average' + valueIndex]); |
| xMarkMap[seriesIndex]['averageLine' + valueIndex] = [ |
| [ |
| x, |
| this.component.grid.getYend() |
| ], |
| [ |
| x, |
| this.component.grid.getY() |
| ] |
| ]; |
| xMarkMap[seriesIndex]['minLine' + valueIndex] = [ |
| [ |
| xMarkMap[seriesIndex]['minX' + valueIndex], |
| this.component.grid.getYend() |
| ], |
| [ |
| xMarkMap[seriesIndex]['minX' + valueIndex], |
| this.component.grid.getY() |
| ] |
| ]; |
| xMarkMap[seriesIndex]['maxLine' + valueIndex] = [ |
| [ |
| xMarkMap[seriesIndex]['maxX' + valueIndex], |
| this.component.grid.getYend() |
| ], |
| [ |
| xMarkMap[seriesIndex]['maxX' + valueIndex], |
| this.component.grid.getY() |
| ] |
| ]; |
| xMarkMap[seriesIndex].isHorizontal = false; |
| } |
| valueIndex = xy == 'xy' ? 1 : ''; |
| if (xy.indexOf('y') != '-1') { |
| if (xMarkMap[seriesIndex]['counter' + valueIndex] > 0) { |
| xMarkMap[seriesIndex]['average' + valueIndex] = (xMarkMap[seriesIndex]['sum' + valueIndex] / xMarkMap[seriesIndex]['counter' + valueIndex]).toFixed(2) - 0; |
| } |
| var y = this.component.yAxis.getAxis(series[seriesIndex].yAxisIndex || 0).getCoord(xMarkMap[seriesIndex]['average' + valueIndex]); |
| xMarkMap[seriesIndex]['averageLine' + valueIndex] = [ |
| [ |
| this.component.grid.getX(), |
| y |
| ], |
| [ |
| this.component.grid.getXend(), |
| y |
| ] |
| ]; |
| xMarkMap[seriesIndex]['minLine' + valueIndex] = [ |
| [ |
| this.component.grid.getX(), |
| xMarkMap[seriesIndex]['minY' + valueIndex] |
| ], |
| [ |
| this.component.grid.getXend(), |
| xMarkMap[seriesIndex]['minY' + valueIndex] |
| ] |
| ]; |
| xMarkMap[seriesIndex]['maxLine' + valueIndex] = [ |
| [ |
| this.component.grid.getX(), |
| xMarkMap[seriesIndex]['maxY' + valueIndex] |
| ], |
| [ |
| this.component.grid.getXend(), |
| xMarkMap[seriesIndex]['maxY' + valueIndex] |
| ] |
| ]; |
| xMarkMap[seriesIndex].isHorizontal = true; |
| } |
| } |
| } |
| }, |
| addLabel: function (tarShape, serie, data, name, orient) { |
| var queryTarget = [ |
| data, |
| serie |
| ]; |
| var nLabel = this.deepMerge(queryTarget, 'itemStyle.normal.label'); |
| var eLabel = this.deepMerge(queryTarget, 'itemStyle.emphasis.label'); |
| var nTextStyle = nLabel.textStyle || {}; |
| var eTextStyle = eLabel.textStyle || {}; |
| if (nLabel.show) { |
| tarShape.style.text = this._getLabelText(serie, data, name, 'normal'); |
| tarShape.style.textPosition = nLabel.position == null ? orient === 'horizontal' ? 'right' : 'top' : nLabel.position; |
| tarShape.style.textColor = nTextStyle.color; |
| tarShape.style.textFont = this.getFont(nTextStyle); |
| } |
| if (eLabel.show) { |
| tarShape.highlightStyle.text = this._getLabelText(serie, data, name, 'emphasis'); |
| tarShape.highlightStyle.textPosition = nLabel.show ? tarShape.style.textPosition : eLabel.position == null ? orient === 'horizontal' ? 'right' : 'top' : eLabel.position; |
| tarShape.highlightStyle.textColor = eTextStyle.color; |
| tarShape.highlightStyle.textFont = this.getFont(eTextStyle); |
| } |
| return tarShape; |
| }, |
| _getLabelText: function (serie, data, name, status) { |
| var formatter = this.deepQuery([ |
| data, |
| serie |
| ], 'itemStyle.' + status + '.label.formatter'); |
| if (!formatter && status === 'emphasis') { |
| formatter = this.deepQuery([ |
| data, |
| serie |
| ], 'itemStyle.normal.label.formatter'); |
| } |
| var value = data != null ? data.value != null ? data.value : data : '-'; |
| if (formatter) { |
| if (typeof formatter === 'function') { |
| return formatter.call(this.myChart, serie.name, name, value); |
| } else if (typeof formatter === 'string') { |
| formatter = formatter.replace('{a}', '{a0}').replace('{b}', '{b0}').replace('{c}', '{c0}'); |
| formatter = formatter.replace('{a0}', serie.name).replace('{b0}', name).replace('{c0}', this.numAddCommas(value)); |
| return formatter; |
| } |
| } else { |
| return this.numAddCommas(value); |
| } |
| }, |
| buildMark: function (seriesIndex) { |
| var serie = this.series[seriesIndex]; |
| if (this.selectedMap[serie.name]) { |
| serie.markPoint && this._buildMarkPoint(seriesIndex); |
| serie.markLine && this._buildMarkLine(seriesIndex); |
| } |
| }, |
| _buildMarkPoint: function (seriesIndex) { |
| var attachStyle = (this.markAttachStyle || {})[seriesIndex]; |
| var serie = this.series[seriesIndex]; |
| var _zlevelBase = this.getZlevelBase(); |
| var mpData; |
| var pos; |
| var markPoint = zrUtil.clone(serie.markPoint); |
| for (var i = 0, l = markPoint.data.length; i < l; i++) { |
| mpData = markPoint.data[i]; |
| pos = this.getMarkCoord(seriesIndex, mpData); |
| markPoint.data[i].x = mpData.x != null ? mpData.x : pos[0]; |
| markPoint.data[i].y = mpData.y != null ? mpData.y : pos[1]; |
| if (mpData.type && (mpData.type === 'max' || mpData.type === 'min')) { |
| markPoint.data[i].value = pos[3]; |
| markPoint.data[i].name = mpData.name || mpData.type; |
| markPoint.data[i].symbolSize = markPoint.data[i].symbolSize || zrArea.getTextWidth(pos[3], this.getFont()) / 2 + 5; |
| } |
| } |
| var shapeList = this._markPoint(seriesIndex, markPoint); |
| for (var i = 0, l = shapeList.length; i < l; i++) { |
| shapeList[i].zlevel = _zlevelBase + 1; |
| for (var key in attachStyle) { |
| shapeList[i][key] = zrUtil.clone(attachStyle[key]); |
| } |
| this.shapeList.push(shapeList[i]); |
| } |
| if (this.type === ecConfig.CHART_TYPE_FORCE || this.type === ecConfig.CHART_TYPE_CHORD) { |
| for (var i = 0, l = shapeList.length; i < l; i++) { |
| this.zr.addShape(shapeList[i]); |
| } |
| } |
| }, |
| _buildMarkLine: function (seriesIndex) { |
| var attachStyle = (this.markAttachStyle || {})[seriesIndex]; |
| var serie = this.series[seriesIndex]; |
| var _zlevelBase = this.getZlevelBase(); |
| var mlData; |
| var pos; |
| var markLine = zrUtil.clone(serie.markLine); |
| for (var i = 0, l = markLine.data.length; i < l; i++) { |
| mlData = markLine.data[i]; |
| if (mlData.type && (mlData.type === 'max' || mlData.type === 'min' || mlData.type === 'average')) { |
| pos = this.getMarkCoord(seriesIndex, mlData); |
| markLine.data[i] = [ |
| zrUtil.clone(mlData), |
| {} |
| ]; |
| markLine.data[i][0].name = mlData.name || mlData.type; |
| markLine.data[i][0].value = pos[3]; |
| pos = pos[2]; |
| mlData = [ |
| {}, |
| {} |
| ]; |
| } else { |
| pos = [ |
| this.getMarkCoord(seriesIndex, mlData[0]), |
| this.getMarkCoord(seriesIndex, mlData[1]) |
| ]; |
| } |
| if (pos == null || pos[0] == null || pos[1] == null) { |
| continue; |
| } |
| markLine.data[i][0].x = mlData[0].x != null ? mlData[0].x : pos[0][0]; |
| markLine.data[i][0].y = mlData[0].y != null ? mlData[0].y : pos[0][1]; |
| markLine.data[i][1].x = mlData[1].x != null ? mlData[1].x : pos[1][0]; |
| markLine.data[i][1].y = mlData[1].y != null ? mlData[1].y : pos[1][1]; |
| } |
| var shapeList = this._markLine(seriesIndex, markLine); |
| for (var i = 0, l = shapeList.length; i < l; i++) { |
| shapeList[i].zlevel = _zlevelBase + 1; |
| for (var key in attachStyle) { |
| shapeList[i][key] = zrUtil.clone(attachStyle[key]); |
| } |
| this.shapeList.push(shapeList[i]); |
| } |
| if (this.type === ecConfig.CHART_TYPE_FORCE || this.type === ecConfig.CHART_TYPE_CHORD) { |
| for (var i = 0, l = shapeList.length; i < l; i++) { |
| this.zr.addShape(shapeList[i]); |
| } |
| } |
| }, |
| _markPoint: function (seriesIndex, mpOption) { |
| var serie = this.series[seriesIndex]; |
| var component = this.component; |
| zrUtil.merge(mpOption, this.ecTheme.markPoint); |
| mpOption.name = serie.name; |
| var pList = []; |
| var data = mpOption.data; |
| var itemShape; |
| var dataRange = component.dataRange; |
| var legend = component.legend; |
| var color; |
| var value; |
| var queryTarget; |
| var nColor; |
| var eColor; |
| var effect; |
| var zrWidth = this.zr.getWidth(); |
| var zrHeight = this.zr.getHeight(); |
| if (!mpOption.large) { |
| for (var i = 0, l = data.length; i < l; i++) { |
| if (data[i].x == null || data[i].y == null) { |
| continue; |
| } |
| value = data[i] != null && data[i].value != null ? data[i].value : ''; |
| if (legend) { |
| color = legend.getColor(serie.name); |
| } |
| if (dataRange) { |
| color = isNaN(value) ? color : dataRange.getColor(value); |
| queryTarget = [ |
| data[i], |
| mpOption |
| ]; |
| nColor = this.deepQuery(queryTarget, 'itemStyle.normal.color') || color; |
| eColor = this.deepQuery(queryTarget, 'itemStyle.emphasis.color') || nColor; |
| if (nColor == null && eColor == null) { |
| continue; |
| } |
| } |
| color = color == null ? this.zr.getColor(seriesIndex) : color; |
| data[i].tooltip = data[i].tooltip || mpOption.tooltip || { trigger: 'item' }; |
| data[i].name = data[i].name != null ? data[i].name : ''; |
| data[i].value = value; |
| itemShape = this.getSymbolShape(mpOption, seriesIndex, data[i], i, data[i].name, this.parsePercent(data[i].x, zrWidth), this.parsePercent(data[i].y, zrHeight), 'pin', color, 'rgba(0,0,0,0)', 'horizontal'); |
| itemShape._mark = 'point'; |
| effect = this.deepMerge([ |
| data[i], |
| mpOption |
| ], 'effect'); |
| if (effect.show) { |
| itemShape.effect = effect; |
| } |
| if (serie.type === ecConfig.CHART_TYPE_MAP) { |
| itemShape._geo = this.getMarkGeo(data[i]); |
| } |
| ecData.pack(itemShape, serie, seriesIndex, data[i], i, data[i].name, value); |
| pList.push(itemShape); |
| } |
| } else { |
| itemShape = this.getLargeMarkPoingShape(seriesIndex, mpOption); |
| itemShape._mark = 'largePoint'; |
| itemShape && pList.push(itemShape); |
| } |
| return pList; |
| }, |
| _markLine: function (seriesIndex, mlOption) { |
| var serie = this.series[seriesIndex]; |
| var component = this.component; |
| zrUtil.merge(mlOption, this.ecTheme.markLine); |
| mlOption.symbol = mlOption.symbol instanceof Array ? mlOption.symbol.length > 1 ? mlOption.symbol : [ |
| mlOption.symbol[0], |
| mlOption.symbol[0] |
| ] : [ |
| mlOption.symbol, |
| mlOption.symbol |
| ]; |
| mlOption.symbolSize = mlOption.symbolSize instanceof Array ? mlOption.symbolSize.length > 1 ? mlOption.symbolSize : [ |
| mlOption.symbolSize[0], |
| mlOption.symbolSize[0] |
| ] : [ |
| mlOption.symbolSize, |
| mlOption.symbolSize |
| ]; |
| mlOption.symbolRotate = mlOption.symbolRotate instanceof Array ? mlOption.symbolRotate.length > 1 ? mlOption.symbolRotate : [ |
| mlOption.symbolRotate[0], |
| mlOption.symbolRotate[0] |
| ] : [ |
| mlOption.symbolRotate, |
| mlOption.symbolRotate |
| ]; |
| mlOption.name = serie.name; |
| var pList = []; |
| var data = mlOption.data; |
| var itemShape; |
| var dataRange = component.dataRange; |
| var legend = component.legend; |
| var color; |
| var value; |
| var queryTarget; |
| var nColor; |
| var eColor; |
| var effect; |
| var zrWidth = this.zr.getWidth(); |
| var zrHeight = this.zr.getHeight(); |
| var mergeData; |
| for (var i = 0, l = data.length; i < l; i++) { |
| if (data[i][0].x == null || data[i][0].y == null || data[i][1].x == null || data[i][1].y == null) { |
| continue; |
| } |
| color = legend ? legend.getColor(serie.name) : this.zr.getColor(seriesIndex); |
| mergeData = this.deepMerge(data[i]); |
| value = mergeData != null && mergeData.value != null ? mergeData.value : ''; |
| if (dataRange) { |
| color = isNaN(value) ? color : dataRange.getColor(value); |
| queryTarget = [ |
| mergeData, |
| mlOption |
| ]; |
| nColor = this.deepQuery(queryTarget, 'itemStyle.normal.color') || color; |
| eColor = this.deepQuery(queryTarget, 'itemStyle.emphasis.color') || nColor; |
| if (nColor == null && eColor == null) { |
| continue; |
| } |
| } |
| data[i][0].tooltip = mergeData.tooltip || { trigger: 'item' }; |
| data[i][0].name = data[i][0].name != null ? data[i][0].name : ''; |
| data[i][1].name = data[i][1].name != null ? data[i][1].name : ''; |
| data[i][0].value = data[i][0].value != null ? data[i][0].value : ''; |
| itemShape = this.getLineMarkShape(mlOption, seriesIndex, data[i], i, this.parsePercent(data[i][0].x, zrWidth), this.parsePercent(data[i][0].y, zrHeight), this.parsePercent(data[i][1].x, zrWidth), this.parsePercent(data[i][1].y, zrHeight), color); |
| itemShape._mark = 'line'; |
| effect = this.deepMerge([ |
| mergeData, |
| mlOption |
| ], 'effect'); |
| if (effect.show) { |
| itemShape.effect = effect; |
| } |
| if (serie.type === ecConfig.CHART_TYPE_MAP) { |
| itemShape._geo = [ |
| this.getMarkGeo(data[i][0]), |
| this.getMarkGeo(data[i][1]) |
| ]; |
| } |
| ecData.pack(itemShape, serie, seriesIndex, data[i][0], i, data[i][0].name + (data[i][1].name !== '' ? ' > ' + data[i][1].name : ''), value); |
| pList.push(itemShape); |
| } |
| return pList; |
| }, |
| getMarkCoord: function () { |
| return [ |
| 0, |
| 0 |
| ]; |
| }, |
| getSymbolShape: function (serie, seriesIndex, data, dataIndex, name, x, y, symbol, color, emptyColor, orient) { |
| var queryTarget = [ |
| data, |
| serie |
| ]; |
| var value = data != null ? data.value != null ? data.value : data : '-'; |
| symbol = this.deepQuery(queryTarget, 'symbol') || symbol; |
| var symbolSize = this.deepQuery(queryTarget, 'symbolSize'); |
| symbolSize = typeof symbolSize === 'function' ? symbolSize(value) : symbolSize; |
| var symbolRotate = this.deepQuery(queryTarget, 'symbolRotate'); |
| var normal = this.deepMerge(queryTarget, 'itemStyle.normal'); |
| var emphasis = this.deepMerge(queryTarget, 'itemStyle.emphasis'); |
| var nBorderWidth = normal.borderWidth != null ? normal.borderWidth : normal.lineStyle && normal.lineStyle.width; |
| if (nBorderWidth == null) { |
| nBorderWidth = symbol.match('empty') ? 2 : 0; |
| } |
| var eBorderWidth = emphasis.borderWidth != null ? emphasis.borderWidth : emphasis.lineStyle && emphasis.lineStyle.width; |
| if (eBorderWidth == null) { |
| eBorderWidth = nBorderWidth + 2; |
| } |
| var itemShape = new IconShape({ |
| style: { |
| iconType: symbol.replace('empty', '').toLowerCase(), |
| x: x - symbolSize, |
| y: y - symbolSize, |
| width: symbolSize * 2, |
| height: symbolSize * 2, |
| brushType: 'both', |
| color: symbol.match('empty') ? emptyColor : this.getItemStyleColor(normal.color, seriesIndex, dataIndex, data) || color, |
| strokeColor: normal.borderColor || this.getItemStyleColor(normal.color, seriesIndex, dataIndex, data) || color, |
| lineWidth: nBorderWidth |
| }, |
| highlightStyle: { |
| color: symbol.match('empty') ? emptyColor : this.getItemStyleColor(emphasis.color, seriesIndex, dataIndex, data), |
| strokeColor: emphasis.borderColor || normal.borderColor || this.getItemStyleColor(normal.color, seriesIndex, dataIndex, data) || color, |
| lineWidth: eBorderWidth |
| }, |
| clickable: this.deepQuery(queryTarget, 'clickable') |
| }); |
| if (symbol.match('image')) { |
| itemShape.style.image = symbol.replace(new RegExp('^image:\\/\\/'), ''); |
| itemShape = new ImageShape({ |
| style: itemShape.style, |
| highlightStyle: itemShape.highlightStyle, |
| clickable: this.deepQuery(queryTarget, 'clickable') |
| }); |
| } |
| if (symbolRotate != null) { |
| itemShape.rotation = [ |
| symbolRotate * Math.PI / 180, |
| x, |
| y |
| ]; |
| } |
| if (symbol.match('star')) { |
| itemShape.style.iconType = 'star'; |
| itemShape.style.n = symbol.replace('empty', '').replace('star', '') - 0 || 5; |
| } |
| if (symbol === 'none') { |
| itemShape.invisible = true; |
| itemShape.hoverable = false; |
| } |
| itemShape = this.addLabel(itemShape, serie, data, name, orient); |
| if (symbol.match('empty')) { |
| if (itemShape.style.textColor == null) { |
| itemShape.style.textColor = itemShape.style.strokeColor; |
| } |
| if (itemShape.highlightStyle.textColor == null) { |
| itemShape.highlightStyle.textColor = itemShape.highlightStyle.strokeColor; |
| } |
| } |
| ecData.pack(itemShape, serie, seriesIndex, data, dataIndex, name); |
| itemShape._x = x; |
| itemShape._y = y; |
| itemShape._dataIndex = dataIndex; |
| itemShape._seriesIndex = seriesIndex; |
| return itemShape; |
| }, |
| getLineMarkShape: function (mlOption, seriesIndex, data, dataIndex, xStart, yStart, xEnd, yEnd, color) { |
| var value0 = data[0] != null ? data[0].value != null ? data[0].value : data[0] : '-'; |
| var value1 = data[1] != null ? data[1].value != null ? data[1].value : data[1] : '-'; |
| var symbol = [ |
| this.query(data[0], 'symbol') || mlOption.symbol[0], |
| this.query(data[1], 'symbol') || mlOption.symbol[1] |
| ]; |
| var symbolSize = [ |
| this.query(data[0], 'symbolSize') || mlOption.symbolSize[0], |
| this.query(data[1], 'symbolSize') || mlOption.symbolSize[1] |
| ]; |
| symbolSize[0] = typeof symbolSize[0] === 'function' ? symbolSize[0](value0) : symbolSize[0]; |
| symbolSize[1] = typeof symbolSize[1] === 'function' ? symbolSize[1](value1) : symbolSize[1]; |
| var symbolRotate = [ |
| this.query(data[0], 'symbolRotate') || mlOption.symbolRotate[0], |
| this.query(data[1], 'symbolRotate') || mlOption.symbolRotate[1] |
| ]; |
| var queryTarget = [ |
| data[0], |
| mlOption |
| ]; |
| var normal = this.deepMerge(queryTarget, 'itemStyle.normal'); |
| normal.color = this.getItemStyleColor(normal.color, seriesIndex, dataIndex, data); |
| var emphasis = this.deepMerge(queryTarget, 'itemStyle.emphasis'); |
| emphasis.color = this.getItemStyleColor(emphasis.color, seriesIndex, dataIndex, data); |
| var nlineStyle = normal.lineStyle; |
| var elineStyle = emphasis.lineStyle; |
| var nBorderWidth = nlineStyle.width; |
| if (nBorderWidth == null) { |
| nBorderWidth = normal.borderWidth; |
| } |
| var eBorderWidth = elineStyle.width; |
| if (eBorderWidth == null) { |
| eBorderWidth = emphasis.borderWidth != null ? emphasis.borderWidth : nBorderWidth + 2; |
| } |
| var itemShape = new MarkLineShape({ |
| style: { |
| smooth: mlOption.smooth ? 'spline' : false, |
| symbol: symbol, |
| symbolSize: symbolSize, |
| symbolRotate: symbolRotate, |
| xStart: xStart, |
| yStart: yStart, |
| xEnd: xEnd, |
| yEnd: yEnd, |
| brushType: 'both', |
| lineType: nlineStyle.type, |
| shadowColor: nlineStyle.shadowColor || nlineStyle.color || normal.borderColor || normal.color || color, |
| shadowBlur: nlineStyle.shadowBlur, |
| shadowOffsetX: nlineStyle.shadowOffsetX, |
| shadowOffsetY: nlineStyle.shadowOffsetY, |
| color: normal.color || color, |
| strokeColor: nlineStyle.color || normal.borderColor || normal.color || color, |
| lineWidth: nBorderWidth, |
| symbolBorderColor: normal.borderColor || normal.color || color, |
| symbolBorder: normal.borderWidth |
| }, |
| highlightStyle: { |
| shadowColor: elineStyle.shadowColor, |
| shadowBlur: elineStyle.shadowBlur, |
| shadowOffsetX: elineStyle.shadowOffsetX, |
| shadowOffsetY: elineStyle.shadowOffsetY, |
| color: emphasis.color || normal.color || color, |
| strokeColor: elineStyle.color || nlineStyle.color || emphasis.borderColor || normal.borderColor || emphasis.color || normal.color || color, |
| lineWidth: eBorderWidth, |
| symbolBorderColor: emphasis.borderColor || normal.borderColor || emphasis.color || normal.color || color, |
| symbolBorder: emphasis.borderWidth == null ? normal.borderWidth + 2 : emphasis.borderWidth |
| }, |
| clickable: this.deepQuery(queryTarget, 'clickable') |
| }); |
| itemShape = this.addLabel(itemShape, mlOption, data[0], data[0].name + ' : ' + data[1].name); |
| itemShape._x = xEnd; |
| itemShape._y = yEnd; |
| return itemShape; |
| }, |
| getLargeMarkPoingShape: function (seriesIndex, mpOption) { |
| var serie = this.series[seriesIndex]; |
| var component = this.component; |
| var data = mpOption.data; |
| var itemShape; |
| var dataRange = component.dataRange; |
| var legend = component.legend; |
| var color; |
| var value; |
| var queryTarget = [ |
| data[0], |
| mpOption |
| ]; |
| var nColor; |
| var eColor; |
| var effect; |
| if (legend) { |
| color = legend.getColor(serie.name); |
| } |
| if (dataRange) { |
| value = data[0] != null ? data[0].value != null ? data[0].value : data[0] : '-'; |
| color = isNaN(value) ? color : dataRange.getColor(value); |
| nColor = this.deepQuery(queryTarget, 'itemStyle.normal.color') || color; |
| eColor = this.deepQuery(queryTarget, 'itemStyle.emphasis.color') || nColor; |
| if (nColor == null && eColor == null) { |
| return; |
| } |
| } |
| color = this.deepMerge(queryTarget, 'itemStyle.normal').color || color; |
| var symbol = this.deepQuery(queryTarget, 'symbol') || 'circle'; |
| symbol = symbol.replace('empty', '').replace(/\d/g, ''); |
| effect = this.deepMerge([ |
| data[0], |
| mpOption |
| ], 'effect'); |
| var devicePixelRatio = window.devicePixelRatio || 1; |
| itemShape = new SymbolShape({ |
| style: { |
| pointList: data, |
| color: color, |
| strokeColor: color, |
| shadowColor: effect.shadowColor || color, |
| shadowBlur: (effect.shadowBlur != null ? effect.shadowBlur : 8) * devicePixelRatio, |
| size: this.deepQuery(queryTarget, 'symbolSize'), |
| iconType: symbol, |
| brushType: 'fill', |
| lineWidth: 1 |
| }, |
| draggable: false, |
| hoverable: false |
| }); |
| if (effect.show) { |
| itemShape.effect = effect; |
| } |
| return itemShape; |
| }, |
| backupShapeList: function () { |
| if (this.shapeList && this.shapeList.length > 0) { |
| this.lastShapeList = this.shapeList; |
| this.shapeList = []; |
| } else { |
| this.lastShapeList = []; |
| } |
| }, |
| addShapeList: function () { |
| var maxLenth = this.option.animationThreshold / (this.canvasSupported ? 2 : 4); |
| var lastShapeList = this.lastShapeList; |
| var shapeList = this.shapeList; |
| var duration = lastShapeList.length > 0 ? 500 : this.query(this.option, 'animationDuration'); |
| var easing = this.query(this.option, 'animationEasing'); |
| var delay; |
| var key; |
| var oldMap = {}; |
| var newMap = {}; |
| if (this.option.animation && !this.option.renderAsImage && shapeList.length < maxLenth && !this.motionlessOnce) { |
| for (var i = 0, l = lastShapeList.length; i < l; i++) { |
| key = this._getAnimationKey(lastShapeList[i]); |
| if (key.match('undefined')) { |
| this.zr.delShape(lastShapeList[i].id); |
| } else { |
| key += lastShapeList[i].type; |
| oldMap[key] = lastShapeList[i]; |
| } |
| } |
| for (var i = 0, l = shapeList.length; i < l; i++) { |
| key = this._getAnimationKey(shapeList[i]); |
| if (key.match('undefined')) { |
| this.zr.addShape(shapeList[i]); |
| } else { |
| key += shapeList[i].type; |
| newMap[key] = shapeList[i]; |
| } |
| } |
| for (key in oldMap) { |
| if (!newMap[key]) { |
| this.zr.delShape(oldMap[key].id); |
| } |
| } |
| for (key in newMap) { |
| if (oldMap[key]) { |
| this.zr.delShape(oldMap[key].id); |
| this._animateMod(oldMap[key], newMap[key], duration, easing); |
| } else { |
| delay = (this.type == ecConfig.CHART_TYPE_LINE || this.type == ecConfig.CHART_TYPE_RADAR) && key.indexOf('icon') !== 0 ? duration / 2 : 0; |
| this._animateMod(false, newMap[key], duration, easing, delay); |
| } |
| } |
| this.zr.refresh(); |
| this.animationEffect(); |
| } else { |
| this.motionlessOnce = false; |
| this.zr.delShape(lastShapeList); |
| for (var i = 0, l = shapeList.length; i < l; i++) { |
| this.zr.addShape(shapeList[i]); |
| } |
| } |
| }, |
| _getAnimationKey: function (shape) { |
| if (this.type != ecConfig.CHART_TYPE_MAP) { |
| return ecData.get(shape, 'seriesIndex') + '_' + ecData.get(shape, 'dataIndex') + (shape._mark ? shape._mark : '') + (this.type === ecConfig.CHART_TYPE_RADAR ? ecData.get(shape, 'special') : ''); |
| } else { |
| return ecData.get(shape, 'seriesIndex') + '_' + ecData.get(shape, 'dataIndex') + (shape._mark ? shape._mark : 'undefined'); |
| } |
| }, |
| _animateMod: function (oldShape, newShape, duration, easing, delay) { |
| switch (newShape.type) { |
| case 'broken-line': |
| case 'half-smooth-polygon': |
| ecAnimation.pointList(this.zr, oldShape, newShape, duration, easing); |
| break; |
| case 'rectangle': |
| ecAnimation.rectangle(this.zr, oldShape, newShape, duration, easing); |
| break; |
| case 'icon': |
| ecAnimation.icon(this.zr, oldShape, newShape, duration, easing, delay); |
| break; |
| case 'candle': |
| if (duration > 500) { |
| ecAnimation.candle(this.zr, oldShape, newShape, duration, easing); |
| } else { |
| this.zr.addShape(newShape); |
| } |
| break; |
| case 'ring': |
| case 'sector': |
| case 'circle': |
| if (duration > 500) { |
| ecAnimation.ring(this.zr, oldShape, newShape, duration + (ecData.get(newShape, 'dataIndex') || 0) % 20 * 100, easing); |
| } else if (newShape.type === 'sector') { |
| ecAnimation.sector(this.zr, oldShape, newShape, duration, easing); |
| } else { |
| this.zr.addShape(newShape); |
| } |
| break; |
| case 'text': |
| ecAnimation.text(this.zr, oldShape, newShape, duration, easing); |
| break; |
| case 'polygon': |
| if (duration > 500) { |
| ecAnimation.polygon(this.zr, oldShape, newShape, duration, easing); |
| } else { |
| ecAnimation.pointList(this.zr, oldShape, newShape, duration, easing); |
| } |
| break; |
| case 'ribbon': |
| ecAnimation.ribbon(this.zr, oldShape, newShape, duration, easing); |
| break; |
| case 'gauge-pointer': |
| ecAnimation.gaugePointer(this.zr, oldShape, newShape, duration, easing); |
| break; |
| case 'mark-line': |
| ecAnimation.markline(this.zr, oldShape, newShape, duration, easing); |
| break; |
| case 'bezier-curve': |
| case 'line': |
| ecAnimation.line(this.zr, oldShape, newShape, duration, easing); |
| break; |
| default: |
| this.zr.addShape(newShape); |
| break; |
| } |
| }, |
| animationMark: function (duration, easing, addShapeList) { |
| var shapeList = addShapeList || this.shapeList; |
| for (var i = 0, l = shapeList.length; i < l; i++) { |
| if (!shapeList[i]._mark) { |
| continue; |
| } |
| this._animateMod(false, shapeList[i], duration, easing); |
| } |
| this.animationEffect(addShapeList); |
| }, |
| animationEffect: function (addShapeList) { |
| !addShapeList && this.clearEffectShape(); |
| var shapeList = addShapeList || this.shapeList; |
| if (shapeList == null) { |
| return; |
| } |
| var zlevel = ecConfig.EFFECT_ZLEVEL; |
| if (this.canvasSupported) { |
| this.zr.modLayer(zlevel, { |
| motionBlur: true, |
| lastFrameAlpha: 0.95 |
| }); |
| } |
| var shape; |
| for (var i = 0, l = shapeList.length; i < l; i++) { |
| shape = shapeList[i]; |
| if (!(shape._mark && shape.effect && shape.effect.show && ecEffect[shape._mark])) { |
| continue; |
| } |
| ecEffect[shape._mark](this.zr, this.effectList, shape, zlevel); |
| this.effectList[this.effectList.length - 1]._mark = shape._mark; |
| } |
| }, |
| clearEffectShape: function (clearMotionBlur) { |
| if (this.zr && this.effectList && this.effectList.length > 0) { |
| clearMotionBlur && this.zr.modLayer(ecConfig.EFFECT_ZLEVEL, { motionBlur: false }); |
| this.zr.delShape(this.effectList); |
| } |
| this.effectList = []; |
| }, |
| addMark: function (seriesIndex, markData, markType) { |
| var serie = this.series[seriesIndex]; |
| if (this.selectedMap[serie.name]) { |
| var duration = 500; |
| var easing = this.query(this.option, 'animationEasing'); |
| var oriMarkData = serie[markType].data; |
| var lastLength = this.shapeList.length; |
| serie[markType].data = markData.data; |
| this['_build' + markType.replace('m', 'M')](seriesIndex); |
| if (this.option.animation && !this.option.renderAsImage) { |
| this.animationMark(duration, easing, this.shapeList.slice(lastLength)); |
| } else { |
| for (var i = lastLength, l = this.shapeList.length; i < l; i++) { |
| this.zr.addShape(this.shapeList[i]); |
| } |
| this.zr.refresh(); |
| } |
| serie[markType].data = oriMarkData; |
| } |
| }, |
| delMark: function (seriesIndex, markName, markType) { |
| markType = markType.replace('mark', '').replace('large', '').toLowerCase(); |
| var serie = this.series[seriesIndex]; |
| if (this.selectedMap[serie.name]) { |
| var needRefresh = false; |
| var shapeList = [ |
| this.shapeList, |
| this.effectList |
| ]; |
| var len = 2; |
| while (len--) { |
| for (var i = 0, l = shapeList[len].length; i < l; i++) { |
| if (shapeList[len][i]._mark == markType && ecData.get(shapeList[len][i], 'seriesIndex') == seriesIndex && ecData.get(shapeList[len][i], 'name') == markName) { |
| this.zr.delShape(shapeList[len][i].id); |
| shapeList[len].splice(i, 1); |
| needRefresh = true; |
| break; |
| } |
| } |
| } |
| needRefresh && this.zr.refresh(); |
| } |
| } |
| }; |
| return Base; |
| });define('zrender/shape/Circle', [ |
| 'require', |
| './Base', |
| '../tool/util' |
| ], function (require) { |
| 'use strict'; |
| var Base = require('./Base'); |
| var Circle = function (options) { |
| Base.call(this, options); |
| }; |
| Circle.prototype = { |
| type: 'circle', |
| buildPath: function (ctx, style) { |
| ctx.arc(style.x, style.y, style.r, 0, Math.PI * 2, true); |
| return; |
| }, |
| getRect: function (style) { |
| if (style.__rect) { |
| return style.__rect; |
| } |
| var lineWidth; |
| if (style.brushType == 'stroke' || style.brushType == 'fill') { |
| lineWidth = style.lineWidth || 1; |
| } else { |
| lineWidth = 0; |
| } |
| style.__rect = { |
| x: Math.round(style.x - style.r - lineWidth / 2), |
| y: Math.round(style.y - style.r - lineWidth / 2), |
| width: style.r * 2 + lineWidth, |
| height: style.r * 2 + lineWidth |
| }; |
| return style.__rect; |
| } |
| }; |
| require('../tool/util').inherits(Circle, Base); |
| return Circle; |
| });define('echarts/util/accMath', [], function () { |
| function accDiv(arg1, arg2) { |
| var s1 = arg1.toString(); |
| var s2 = arg2.toString(); |
| var m = 0; |
| try { |
| m = s2.split('.')[1].length; |
| } catch (e) { |
| } |
| try { |
| m -= s1.split('.')[1].length; |
| } catch (e) { |
| } |
| return (s1.replace('.', '') - 0) / (s2.replace('.', '') - 0) * Math.pow(10, m); |
| } |
| function accMul(arg1, arg2) { |
| var s1 = arg1.toString(); |
| var s2 = arg2.toString(); |
| var m = 0; |
| try { |
| m += s1.split('.')[1].length; |
| } catch (e) { |
| } |
| try { |
| m += s2.split('.')[1].length; |
| } catch (e) { |
| } |
| return (s1.replace('.', '') - 0) * (s2.replace('.', '') - 0) / Math.pow(10, m); |
| } |
| function accAdd(arg1, arg2) { |
| var r1 = 0; |
| var r2 = 0; |
| try { |
| r1 = arg1.toString().split('.')[1].length; |
| } catch (e) { |
| } |
| try { |
| r2 = arg2.toString().split('.')[1].length; |
| } catch (e) { |
| } |
| var m = Math.pow(10, Math.max(r1, r2)); |
| return (Math.round(arg1 * m) + Math.round(arg2 * m)) / m; |
| } |
| function accSub(arg1, arg2) { |
| return accAdd(arg1, -arg2); |
| } |
| return { |
| accDiv: accDiv, |
| accMul: accMul, |
| accAdd: accAdd, |
| accSub: accSub |
| }; |
| });define('echarts/util/ecQuery', [ |
| 'require', |
| 'zrender/tool/util' |
| ], function (require) { |
| var zrUtil = require('zrender/tool/util'); |
| function query(optionTarget, optionLocation) { |
| if (typeof optionTarget == 'undefined') { |
| return; |
| } |
| if (!optionLocation) { |
| return optionTarget; |
| } |
| optionLocation = optionLocation.split('.'); |
| var length = optionLocation.length; |
| var curIdx = 0; |
| while (curIdx < length) { |
| optionTarget = optionTarget[optionLocation[curIdx]]; |
| if (typeof optionTarget == 'undefined') { |
| return; |
| } |
| curIdx++; |
| } |
| return optionTarget; |
| } |
| function deepQuery(ctrList, optionLocation) { |
| var finalOption; |
| for (var i = 0, l = ctrList.length; i < l; i++) { |
| finalOption = query(ctrList[i], optionLocation); |
| if (typeof finalOption != 'undefined') { |
| return finalOption; |
| } |
| } |
| } |
| function deepMerge(ctrList, optionLocation) { |
| var finalOption; |
| var len = ctrList.length; |
| while (len--) { |
| var tempOption = query(ctrList[len], optionLocation); |
| if (typeof tempOption != 'undefined') { |
| if (typeof finalOption == 'undefined') { |
| finalOption = zrUtil.clone(tempOption); |
| } else { |
| zrUtil.merge(finalOption, tempOption, true); |
| } |
| } |
| } |
| return finalOption; |
| } |
| return { |
| query: query, |
| deepQuery: deepQuery, |
| deepMerge: deepMerge |
| }; |
| });define('echarts/util/number', [], function () { |
| function _trim(str) { |
| return str.replace(/^\s+/, '').replace(/\s+$/, ''); |
| } |
| function parsePercent(value, maxValue) { |
| if (typeof value === 'string') { |
| if (_trim(value).match(/%$/)) { |
| return parseFloat(value) / 100 * maxValue; |
| } |
| return parseFloat(value); |
| } |
| return value; |
| } |
| function parseCenter(zr, center) { |
| return [ |
| parsePercent(center[0], zr.getWidth()), |
| parsePercent(center[1], zr.getHeight()) |
| ]; |
| } |
| function parseRadius(zr, radius) { |
| if (!(radius instanceof Array)) { |
| radius = [ |
| 0, |
| radius |
| ]; |
| } |
| var zrSize = Math.min(zr.getWidth(), zr.getHeight()) / 2; |
| return [ |
| parsePercent(radius[0], zrSize), |
| parsePercent(radius[1], zrSize) |
| ]; |
| } |
| function addCommas(x) { |
| if (isNaN(x)) { |
| return '-'; |
| } |
| x = (x + '').split('.'); |
| return x[0].replace(/(\d{1,3})(?=(?:\d{3})+(?!\d))/g, '$1,') + (x.length > 1 ? '.' + x[1] : ''); |
| } |
| return { |
| parsePercent: parsePercent, |
| parseCenter: parseCenter, |
| parseRadius: parseRadius, |
| addCommas: addCommas |
| }; |
| });define('echarts/util/shape/Icon', [ |
| 'require', |
| 'zrender/tool/util', |
| 'zrender/shape/Star', |
| 'zrender/shape/Heart', |
| 'zrender/shape/Droplet', |
| 'zrender/shape/Image', |
| 'zrender/shape/Base' |
| ], function (require) { |
| var zrUtil = require('zrender/tool/util'); |
| function _iconMark(ctx, style) { |
| var x = style.x; |
| var y = style.y; |
| var dx = style.width / 16; |
| var dy = style.height / 16; |
| ctx.moveTo(x, y + style.height); |
| ctx.lineTo(x + 5 * dx, y + 14 * dy); |
| ctx.lineTo(x + style.width, y + 3 * dy); |
| ctx.lineTo(x + 13 * dx, y); |
| ctx.lineTo(x + 2 * dx, y + 11 * dy); |
| ctx.lineTo(x, y + style.height); |
| ctx.moveTo(x + 6 * dx, y + 10 * dy); |
| ctx.lineTo(x + 14 * dx, y + 2 * dy); |
| ctx.moveTo(x + 10 * dx, y + 13 * dy); |
| ctx.lineTo(x + style.width, y + 13 * dy); |
| ctx.moveTo(x + 13 * dx, y + 10 * dy); |
| ctx.lineTo(x + 13 * dx, y + style.height); |
| } |
| function _iconMarkUndo(ctx, style) { |
| var x = style.x; |
| var y = style.y; |
| var dx = style.width / 16; |
| var dy = style.height / 16; |
| ctx.moveTo(x, y + style.height); |
| ctx.lineTo(x + 5 * dx, y + 14 * dy); |
| ctx.lineTo(x + style.width, y + 3 * dy); |
| ctx.lineTo(x + 13 * dx, y); |
| ctx.lineTo(x + 2 * dx, y + 11 * dy); |
| ctx.lineTo(x, y + style.height); |
| ctx.moveTo(x + 6 * dx, y + 10 * dy); |
| ctx.lineTo(x + 14 * dx, y + 2 * dy); |
| ctx.moveTo(x + 10 * dx, y + 13 * dy); |
| ctx.lineTo(x + style.width, y + 13 * dy); |
| } |
| function _iconMarkClear(ctx, style) { |
| var x = style.x; |
| var y = style.y; |
| var dx = style.width / 16; |
| var dy = style.height / 16; |
| ctx.moveTo(x + 4 * dx, y + 15 * dy); |
| ctx.lineTo(x + 9 * dx, y + 13 * dy); |
| ctx.lineTo(x + 14 * dx, y + 8 * dy); |
| ctx.lineTo(x + 11 * dx, y + 5 * dy); |
| ctx.lineTo(x + 6 * dx, y + 10 * dy); |
| ctx.lineTo(x + 4 * dx, y + 15 * dy); |
| ctx.moveTo(x + 5 * dx, y); |
| ctx.lineTo(x + 11 * dx, y); |
| ctx.moveTo(x + 5 * dx, y + dy); |
| ctx.lineTo(x + 11 * dx, y + dy); |
| ctx.moveTo(x, y + 2 * dy); |
| ctx.lineTo(x + style.width, y + 2 * dy); |
| ctx.moveTo(x, y + 5 * dy); |
| ctx.lineTo(x + 3 * dx, y + style.height); |
| ctx.lineTo(x + 13 * dx, y + style.height); |
| ctx.lineTo(x + style.width, y + 5 * dy); |
| } |
| function _iconDataZoom(ctx, style) { |
| var x = style.x; |
| var y = style.y; |
| var dx = style.width / 16; |
| var dy = style.height / 16; |
| ctx.moveTo(x, y + 3 * dy); |
| ctx.lineTo(x + 6 * dx, y + 3 * dy); |
| ctx.moveTo(x + 3 * dx, y); |
| ctx.lineTo(x + 3 * dx, y + 6 * dy); |
| ctx.moveTo(x + 3 * dx, y + 8 * dy); |
| ctx.lineTo(x + 3 * dx, y + style.height); |
| ctx.lineTo(x + style.width, y + style.height); |
| ctx.lineTo(x + style.width, y + 3 * dy); |
| ctx.lineTo(x + 8 * dx, y + 3 * dy); |
| } |
| function _iconDataZoomReset(ctx, style) { |
| var x = style.x; |
| var y = style.y; |
| var dx = style.width / 16; |
| var dy = style.height / 16; |
| ctx.moveTo(x + 6 * dx, y); |
| ctx.lineTo(x + 2 * dx, y + 3 * dy); |
| ctx.lineTo(x + 6 * dx, y + 6 * dy); |
| ctx.moveTo(x + 2 * dx, y + 3 * dy); |
| ctx.lineTo(x + 14 * dx, y + 3 * dy); |
| ctx.lineTo(x + 14 * dx, y + 11 * dy); |
| ctx.moveTo(x + 2 * dx, y + 5 * dy); |
| ctx.lineTo(x + 2 * dx, y + 13 * dy); |
| ctx.lineTo(x + 14 * dx, y + 13 * dy); |
| ctx.moveTo(x + 10 * dx, y + 10 * dy); |
| ctx.lineTo(x + 14 * dx, y + 13 * dy); |
| ctx.lineTo(x + 10 * dx, y + style.height); |
| } |
| function _iconRestore(ctx, style) { |
| var x = style.x; |
| var y = style.y; |
| var dx = style.width / 16; |
| var dy = style.height / 16; |
| var r = style.width / 2; |
| ctx.lineWidth = 1.5; |
| ctx.arc(x + r, y + r, r - dx, 0, Math.PI * 2 / 3); |
| ctx.moveTo(x + 3 * dx, y + style.height); |
| ctx.lineTo(x + 0 * dx, y + 12 * dy); |
| ctx.lineTo(x + 5 * dx, y + 11 * dy); |
| ctx.moveTo(x, y + 8 * dy); |
| ctx.arc(x + r, y + r, r - dx, Math.PI, Math.PI * 5 / 3); |
| ctx.moveTo(x + 13 * dx, y); |
| ctx.lineTo(x + style.width, y + 4 * dy); |
| ctx.lineTo(x + 11 * dx, y + 5 * dy); |
| } |
| function _iconLineChart(ctx, style) { |
| var x = style.x; |
| var y = style.y; |
| var dx = style.width / 16; |
| var dy = style.height / 16; |
| ctx.moveTo(x, y); |
| ctx.lineTo(x, y + style.height); |
| ctx.lineTo(x + style.width, y + style.height); |
| ctx.moveTo(x + 2 * dx, y + 14 * dy); |
| ctx.lineTo(x + 7 * dx, y + 6 * dy); |
| ctx.lineTo(x + 11 * dx, y + 11 * dy); |
| ctx.lineTo(x + 15 * dx, y + 2 * dy); |
| } |
| function _iconBarChart(ctx, style) { |
| var x = style.x; |
| var y = style.y; |
| var dx = style.width / 16; |
| var dy = style.height / 16; |
| ctx.moveTo(x, y); |
| ctx.lineTo(x, y + style.height); |
| ctx.lineTo(x + style.width, y + style.height); |
| ctx.moveTo(x + 3 * dx, y + 14 * dy); |
| ctx.lineTo(x + 3 * dx, y + 6 * dy); |
| ctx.lineTo(x + 4 * dx, y + 6 * dy); |
| ctx.lineTo(x + 4 * dx, y + 14 * dy); |
| ctx.moveTo(x + 7 * dx, y + 14 * dy); |
| ctx.lineTo(x + 7 * dx, y + 2 * dy); |
| ctx.lineTo(x + 8 * dx, y + 2 * dy); |
| ctx.lineTo(x + 8 * dx, y + 14 * dy); |
| ctx.moveTo(x + 11 * dx, y + 14 * dy); |
| ctx.lineTo(x + 11 * dx, y + 9 * dy); |
| ctx.lineTo(x + 12 * dx, y + 9 * dy); |
| ctx.lineTo(x + 12 * dx, y + 14 * dy); |
| } |
| function _iconPieChart(ctx, style) { |
| var x = style.x; |
| var y = style.y; |
| var width = style.width - 2; |
| var height = style.height - 2; |
| var r = Math.min(width, height) / 2; |
| y += 2; |
| ctx.moveTo(x + r + 3, y + r - 3); |
| ctx.arc(x + r + 3, y + r - 3, r - 1, 0, -Math.PI / 2, true); |
| ctx.lineTo(x + r + 3, y + r - 3); |
| ctx.moveTo(x + r, y); |
| ctx.lineTo(x + r, y + r); |
| ctx.arc(x + r, y + r, r, -Math.PI / 2, Math.PI * 2, true); |
| ctx.lineTo(x + r, y + r); |
| ctx.lineWidth = 1.5; |
| } |
| function _iconFunnelChart(ctx, style) { |
| var x = style.x; |
| var y = style.y; |
| var dx = style.width / 16; |
| var dy = style.height / 16; |
| y -= dy; |
| ctx.moveTo(x + 1 * dx, y + 2 * dy); |
| ctx.lineTo(x + 15 * dx, y + 2 * dy); |
| ctx.lineTo(x + 14 * dx, y + 3 * dy); |
| ctx.lineTo(x + 2 * dx, y + 3 * dy); |
| ctx.moveTo(x + 3 * dx, y + 6 * dy); |
| ctx.lineTo(x + 13 * dx, y + 6 * dy); |
| ctx.lineTo(x + 12 * dx, y + 7 * dy); |
| ctx.lineTo(x + 4 * dx, y + 7 * dy); |
| ctx.moveTo(x + 5 * dx, y + 10 * dy); |
| ctx.lineTo(x + 11 * dx, y + 10 * dy); |
| ctx.lineTo(x + 10 * dx, y + 11 * dy); |
| ctx.lineTo(x + 6 * dx, y + 11 * dy); |
| ctx.moveTo(x + 7 * dx, y + 14 * dy); |
| ctx.lineTo(x + 9 * dx, y + 14 * dy); |
| ctx.lineTo(x + 8 * dx, y + 15 * dy); |
| ctx.lineTo(x + 7 * dx, y + 15 * dy); |
| } |
| function _iconForceChart(ctx, style) { |
| var x = style.x; |
| var y = style.y; |
| var width = style.width; |
| var height = style.height; |
| var dx = width / 16; |
| var dy = height / 16; |
| var r = Math.min(dx, dy) * 2; |
| ctx.moveTo(x + dx + r, y + dy + r); |
| ctx.arc(x + dx, y + dy, r, Math.PI / 4, Math.PI * 3); |
| ctx.lineTo(x + 7 * dx - r, y + 6 * dy - r); |
| ctx.arc(x + 7 * dx, y + 6 * dy, r, Math.PI / 4 * 5, Math.PI * 4); |
| ctx.arc(x + 7 * dx, y + 6 * dy, r / 2, Math.PI / 4 * 5, Math.PI * 4); |
| ctx.moveTo(x + 7 * dx - r / 2, y + 6 * dy + r); |
| ctx.lineTo(x + dx + r, y + 14 * dy - r); |
| ctx.arc(x + dx, y + 14 * dy, r, -Math.PI / 4, Math.PI * 2); |
| ctx.moveTo(x + 7 * dx + r / 2, y + 6 * dy); |
| ctx.lineTo(x + 14 * dx - r, y + 10 * dy - r / 2); |
| ctx.moveTo(x + 16 * dx, y + 10 * dy); |
| ctx.arc(x + 14 * dx, y + 10 * dy, r, 0, Math.PI * 3); |
| ctx.lineWidth = 1.5; |
| } |
| function _iconChordChart(ctx, style) { |
| var x = style.x; |
| var y = style.y; |
| var width = style.width; |
| var height = style.height; |
| var r = Math.min(width, height) / 2; |
| ctx.moveTo(x + width, y + height / 2); |
| ctx.arc(x + r, y + r, r, 0, Math.PI * 2); |
| ctx.arc(x + r, y, r, Math.PI / 4, Math.PI / 5 * 4); |
| ctx.arc(x, y + r, r, -Math.PI / 3, Math.PI / 3); |
| ctx.arc(x + width, y + height, r, Math.PI, Math.PI / 2 * 3); |
| ctx.lineWidth = 1.5; |
| } |
| function _iconStackChart(ctx, style) { |
| var x = style.x; |
| var y = style.y; |
| var width = style.width; |
| var height = style.height; |
| var dy = Math.round(height / 3); |
| var len = 3; |
| while (len--) { |
| ctx.rect(x, y + dy * len + 2, width, 2); |
| } |
| } |
| function _iconTiledChart(ctx, style) { |
| var x = style.x; |
| var y = style.y; |
| var width = style.width; |
| var height = style.height; |
| var dx = Math.round(width / 3); |
| var len = 3; |
| while (len--) { |
| ctx.rect(x + dx * len, y, 2, height); |
| } |
| } |
| function _iconDataView(ctx, style) { |
| var x = style.x; |
| var y = style.y; |
| var dx = style.width / 16; |
| ctx.moveTo(x + dx, y); |
| ctx.lineTo(x + dx, y + style.height); |
| ctx.lineTo(x + 15 * dx, y + style.height); |
| ctx.lineTo(x + 15 * dx, y); |
| ctx.lineTo(x + dx, y); |
| ctx.moveTo(x + 3 * dx, y + 3 * dx); |
| ctx.lineTo(x + 13 * dx, y + 3 * dx); |
| ctx.moveTo(x + 3 * dx, y + 6 * dx); |
| ctx.lineTo(x + 13 * dx, y + 6 * dx); |
| ctx.moveTo(x + 3 * dx, y + 9 * dx); |
| ctx.lineTo(x + 13 * dx, y + 9 * dx); |
| ctx.moveTo(x + 3 * dx, y + 12 * dx); |
| ctx.lineTo(x + 9 * dx, y + 12 * dx); |
| } |
| function _iconSave(ctx, style) { |
| var x = style.x; |
| var y = style.y; |
| var dx = style.width / 16; |
| var dy = style.height / 16; |
| ctx.moveTo(x, y); |
| ctx.lineTo(x, y + style.height); |
| ctx.lineTo(x + style.width, y + style.height); |
| ctx.lineTo(x + style.width, y); |
| ctx.lineTo(x, y); |
| ctx.moveTo(x + 4 * dx, y); |
| ctx.lineTo(x + 4 * dx, y + 8 * dy); |
| ctx.lineTo(x + 12 * dx, y + 8 * dy); |
| ctx.lineTo(x + 12 * dx, y); |
| ctx.moveTo(x + 6 * dx, y + 11 * dy); |
| ctx.lineTo(x + 6 * dx, y + 13 * dy); |
| ctx.lineTo(x + 10 * dx, y + 13 * dy); |
| ctx.lineTo(x + 10 * dx, y + 11 * dy); |
| ctx.lineTo(x + 6 * dx, y + 11 * dy); |
| } |
| function _iconCross(ctx, style) { |
| var x = style.x; |
| var y = style.y; |
| var width = style.width; |
| var height = style.height; |
| ctx.moveTo(x, y + height / 2); |
| ctx.lineTo(x + width, y + height / 2); |
| ctx.moveTo(x + width / 2, y); |
| ctx.lineTo(x + width / 2, y + height); |
| } |
| function _iconCircle(ctx, style) { |
| var width = style.width / 2; |
| var height = style.height / 2; |
| var r = Math.min(width, height); |
| ctx.moveTo(style.x + width + r, style.y + height); |
| ctx.arc(style.x + width, style.y + height, r, 0, Math.PI * 2); |
| ctx.closePath(); |
| } |
| function _iconRectangle(ctx, style) { |
| ctx.rect(style.x, style.y, style.width, style.height); |
| ctx.closePath(); |
| } |
| function _iconTriangle(ctx, style) { |
| var width = style.width / 2; |
| var height = style.height / 2; |
| var x = style.x + width; |
| var y = style.y + height; |
| var symbolSize = Math.min(width, height); |
| ctx.moveTo(x, y - symbolSize); |
| ctx.lineTo(x + symbolSize, y + symbolSize); |
| ctx.lineTo(x - symbolSize, y + symbolSize); |
| ctx.lineTo(x, y - symbolSize); |
| ctx.closePath(); |
| } |
| function _iconDiamond(ctx, style) { |
| var width = style.width / 2; |
| var height = style.height / 2; |
| var x = style.x + width; |
| var y = style.y + height; |
| var symbolSize = Math.min(width, height); |
| ctx.moveTo(x, y - symbolSize); |
| ctx.lineTo(x + symbolSize, y); |
| ctx.lineTo(x, y + symbolSize); |
| ctx.lineTo(x - symbolSize, y); |
| ctx.lineTo(x, y - symbolSize); |
| ctx.closePath(); |
| } |
| function _iconArrow(ctx, style) { |
| var x = style.x; |
| var y = style.y; |
| var dx = style.width / 16; |
| ctx.moveTo(x + 8 * dx, y); |
| ctx.lineTo(x + dx, y + style.height); |
| ctx.lineTo(x + 8 * dx, y + style.height / 4 * 3); |
| ctx.lineTo(x + 15 * dx, y + style.height); |
| ctx.lineTo(x + 8 * dx, y); |
| ctx.closePath(); |
| } |
| function _iconStar(ctx, style) { |
| var StarShape = require('zrender/shape/Star'); |
| var width = style.width / 2; |
| var height = style.height / 2; |
| StarShape.prototype.buildPath(ctx, { |
| x: style.x + width, |
| y: style.y + height, |
| r: Math.min(width, height), |
| n: style.n || 5 |
| }); |
| } |
| function _iconHeart(ctx, style) { |
| var HeartShape = require('zrender/shape/Heart'); |
| HeartShape.prototype.buildPath(ctx, { |
| x: style.x + style.width / 2, |
| y: style.y + style.height * 0.2, |
| a: style.width / 2, |
| b: style.height * 0.8 |
| }); |
| } |
| function _iconDroplet(ctx, style) { |
| var DropletShape = require('zrender/shape/Droplet'); |
| DropletShape.prototype.buildPath(ctx, { |
| x: style.x + style.width * 0.5, |
| y: style.y + style.height * 0.5, |
| a: style.width * 0.5, |
| b: style.height * 0.8 |
| }); |
| } |
| function _iconPin(ctx, style) { |
| var x = style.x; |
| var y = style.y - style.height / 2 * 1.5; |
| var width = style.width / 2; |
| var height = style.height / 2; |
| var r = Math.min(width, height); |
| ctx.arc(x + width, y + height, r, Math.PI / 5 * 4, Math.PI / 5); |
| ctx.lineTo(x + width, y + height + r * 1.5); |
| ctx.closePath(); |
| } |
| function _iconImage(ctx, style, refreshNextFrame) { |
| var ImageShape = require('zrender/shape/Image'); |
| this._imageShape = this._imageShape || new ImageShape({ style: {} }); |
| for (var name in style) { |
| this._imageShape.style[name] = style[name]; |
| } |
| this._imageShape.brush(ctx, false, refreshNextFrame); |
| } |
| var Base = require('zrender/shape/Base'); |
| function Icon(options) { |
| Base.call(this, options); |
| } |
| Icon.prototype = { |
| type: 'icon', |
| iconLibrary: { |
| mark: _iconMark, |
| markUndo: _iconMarkUndo, |
| markClear: _iconMarkClear, |
| dataZoom: _iconDataZoom, |
| dataZoomReset: _iconDataZoomReset, |
| restore: _iconRestore, |
| lineChart: _iconLineChart, |
| barChart: _iconBarChart, |
| pieChart: _iconPieChart, |
| funnelChart: _iconFunnelChart, |
| forceChart: _iconForceChart, |
| chordChart: _iconChordChart, |
| stackChart: _iconStackChart, |
| tiledChart: _iconTiledChart, |
| dataView: _iconDataView, |
| saveAsImage: _iconSave, |
| cross: _iconCross, |
| circle: _iconCircle, |
| rectangle: _iconRectangle, |
| triangle: _iconTriangle, |
| diamond: _iconDiamond, |
| arrow: _iconArrow, |
| star: _iconStar, |
| heart: _iconHeart, |
| droplet: _iconDroplet, |
| pin: _iconPin, |
| image: _iconImage |
| }, |
| brush: function (ctx, isHighlight, refreshNextFrame) { |
| var style = isHighlight ? this.highlightStyle : this.style; |
| style = style || {}; |
| var iconType = style.iconType || this.style.iconType; |
| if (iconType === 'image') { |
| var ImageShape = require('zrender/shape/Image'); |
| ImageShape.prototype.brush.call(this, ctx, isHighlight, refreshNextFrame); |
| } else { |
| var style = this.beforeBrush(ctx, isHighlight); |
| ctx.beginPath(); |
| this.buildPath(ctx, style, refreshNextFrame); |
| switch (style.brushType) { |
| case 'both': |
| ctx.fill(); |
| case 'stroke': |
| style.lineWidth > 0 && ctx.stroke(); |
| break; |
| default: |
| ctx.fill(); |
| } |
| this.drawText(ctx, style, this.style); |
| this.afterBrush(ctx); |
| } |
| }, |
| buildPath: function (ctx, style, refreshNextFrame) { |
| if (this.iconLibrary[style.iconType]) { |
| this.iconLibrary[style.iconType].call(this, ctx, style, refreshNextFrame); |
| } else { |
| ctx.moveTo(style.x, style.y); |
| ctx.lineTo(style.x + style.width, style.y); |
| ctx.lineTo(style.x + style.width, style.y + style.height); |
| ctx.lineTo(style.x, style.y + style.height); |
| ctx.lineTo(style.x, style.y); |
| ctx.closePath(); |
| } |
| return; |
| }, |
| getRect: function (style) { |
| if (style.__rect) { |
| return style.__rect; |
| } |
| style.__rect = { |
| x: Math.round(style.x), |
| y: Math.round(style.y - (style.iconType == 'pin' ? style.height / 2 * 1.5 : 0)), |
| width: style.width, |
| height: style.height |
| }; |
| return style.__rect; |
| }, |
| isCover: function (x, y) { |
| var originPos = this.getTansform(x, y); |
| x = originPos[0]; |
| y = originPos[1]; |
| var rect = this.style.__rect; |
| if (!rect) { |
| rect = this.style.__rect = this.getRect(this.style); |
| } |
| var delta = rect.height < 8 || rect.width < 8 ? 4 : 0; |
| if (x >= rect.x - delta && x <= rect.x + rect.width + delta && y >= rect.y - delta && y <= rect.y + rect.height + delta) { |
| return true; |
| } else { |
| return false; |
| } |
| } |
| }; |
| zrUtil.inherits(Icon, Base); |
| return Icon; |
| });define('echarts/util/shape/MarkLine', [ |
| 'require', |
| 'zrender/shape/Base', |
| './Icon', |
| 'zrender/shape/Line', |
| 'zrender/shape/BrokenLine', |
| 'zrender/tool/matrix', |
| 'zrender/tool/area', |
| 'zrender/shape/util/dashedLineTo', |
| 'zrender/shape/util/smoothSpline', |
| 'zrender/tool/util' |
| ], function (require) { |
| var Base = require('zrender/shape/Base'); |
| var IconShape = require('./Icon'); |
| var LineShape = require('zrender/shape/Line'); |
| var lineInstance = new LineShape({}); |
| var BrokenLineShape = require('zrender/shape/BrokenLine'); |
| var brokenLineInstance = new BrokenLineShape({}); |
| var matrix = require('zrender/tool/matrix'); |
| var area = require('zrender/tool/area'); |
| var dashedLineTo = require('zrender/shape/util/dashedLineTo'); |
| var smoothSpline = require('zrender/shape/util/smoothSpline'); |
| var zrUtil = require('zrender/tool/util'); |
| function MarkLine(options) { |
| Base.call(this, options); |
| } |
| MarkLine.prototype = { |
| type: 'mark-line', |
| brush: function (ctx, isHighlight) { |
| var style = this.style; |
| if (isHighlight) { |
| style = this.getHighlightStyle(style, this.highlightStyle || {}); |
| } |
| ctx.save(); |
| this.setContext(ctx, style); |
| this.setTransform(ctx); |
| ctx.save(); |
| ctx.beginPath(); |
| this.buildLinePath(ctx, style, this.style.lineWidth || 1); |
| ctx.stroke(); |
| ctx.restore(); |
| this.brushSymbol(ctx, style, 0); |
| this.brushSymbol(ctx, style, 1); |
| this.drawText(ctx, style, this.style); |
| ctx.restore(); |
| }, |
| buildLinePath: function (ctx, style, lineWidth) { |
| var pointList = style.pointList || this.getPointList(style); |
| style.pointList = pointList; |
| var len = Math.min(style.pointList.length, Math.round(style.pointListLength || style.pointList.length)); |
| if (!style.lineType || style.lineType == 'solid') { |
| ctx.moveTo(pointList[0][0], pointList[0][1]); |
| for (var i = 1; i < len; i++) { |
| ctx.lineTo(pointList[i][0], pointList[i][1]); |
| } |
| } else if (style.lineType == 'dashed' || style.lineType == 'dotted') { |
| if (style.smooth !== 'spline') { |
| var dashLength = lineWidth * (style.lineType == 'dashed' ? 5 : 1); |
| ctx.moveTo(pointList[0][0], pointList[0][1]); |
| for (var i = 1; i < len; i++) { |
| dashedLineTo(ctx, pointList[i - 1][0], pointList[i - 1][1], pointList[i][0], pointList[i][1], dashLength); |
| } |
| } else { |
| for (var i = 1; i < len; i += 2) { |
| ctx.moveTo(pointList[i - 1][0], pointList[i - 1][1]); |
| ctx.lineTo(pointList[i][0], pointList[i][1]); |
| } |
| } |
| } |
| }, |
| brushSymbol: function (ctx, style, idx) { |
| if (style.symbol[idx] == 'none') { |
| return; |
| } |
| ctx.save(); |
| ctx.beginPath(); |
| ctx.lineWidth = style.symbolBorder; |
| ctx.strokeStyle = style.symbolBorderColor; |
| style.iconType = style.symbol[idx].replace('empty', '').toLowerCase(); |
| if (style.symbol[idx].match('empty')) { |
| ctx.fillStyle = '#fff'; |
| } |
| var len = Math.min(style.pointList.length, Math.round(style.pointListLength || style.pointList.length)); |
| var x = idx === 0 ? style.pointList[0][0] : style.pointList[len - 1][0]; |
| var y = idx === 0 ? style.pointList[0][1] : style.pointList[len - 1][1]; |
| var rotate = typeof style.symbolRotate[idx] != 'undefined' ? style.symbolRotate[idx] - 0 : 0; |
| var transform; |
| if (rotate !== 0) { |
| transform = matrix.create(); |
| matrix.identity(transform); |
| if (x || y) { |
| matrix.translate(transform, transform, [ |
| -x, |
| -y |
| ]); |
| } |
| matrix.rotate(transform, transform, rotate * Math.PI / 180); |
| if (x || y) { |
| matrix.translate(transform, transform, [ |
| x, |
| y |
| ]); |
| } |
| ctx.transform.apply(ctx, transform); |
| } |
| if (style.iconType == 'arrow' && rotate === 0) { |
| this.buildArrawPath(ctx, style, idx); |
| } else { |
| var symbolSize = style.symbolSize[idx]; |
| style.x = x - symbolSize; |
| style.y = y - symbolSize, style.width = symbolSize * 2; |
| style.height = symbolSize * 2; |
| IconShape.prototype.buildPath(ctx, style); |
| } |
| ctx.closePath(); |
| ctx.fill(); |
| ctx.stroke(); |
| ctx.restore(); |
| }, |
| buildArrawPath: function (ctx, style, idx) { |
| var len = Math.min(style.pointList.length, Math.round(style.pointListLength || style.pointList.length)); |
| var symbolSize = style.symbolSize[idx] * 2; |
| var xStart = style.pointList[0][0]; |
| var xEnd = style.pointList[len - 1][0]; |
| var yStart = style.pointList[0][1]; |
| var yEnd = style.pointList[len - 1][1]; |
| var delta = 0; |
| if (style.smooth === 'spline') { |
| delta = 0.2; |
| } |
| var rotate = Math.atan(Math.abs((yEnd - yStart) / (xStart - xEnd))); |
| if (idx === 0) { |
| if (xEnd > xStart) { |
| if (yEnd > yStart) { |
| rotate = Math.PI * 2 - rotate + delta; |
| } else { |
| rotate += delta; |
| } |
| } else { |
| if (yEnd > yStart) { |
| rotate += Math.PI - delta; |
| } else { |
| rotate = Math.PI - rotate - delta; |
| } |
| } |
| } else { |
| if (xStart > xEnd) { |
| if (yStart > yEnd) { |
| rotate = Math.PI * 2 - rotate + delta; |
| } else { |
| rotate += delta; |
| } |
| } else { |
| if (yStart > yEnd) { |
| rotate += Math.PI - delta; |
| } else { |
| rotate = Math.PI - rotate - delta; |
| } |
| } |
| } |
| var halfRotate = Math.PI / 8; |
| var x = idx === 0 ? xStart : xEnd; |
| var y = idx === 0 ? yStart : yEnd; |
| var point = [ |
| [ |
| x + symbolSize * Math.cos(rotate - halfRotate), |
| y - symbolSize * Math.sin(rotate - halfRotate) |
| ], |
| [ |
| x + symbolSize * 0.6 * Math.cos(rotate), |
| y - symbolSize * 0.6 * Math.sin(rotate) |
| ], |
| [ |
| x + symbolSize * Math.cos(rotate + halfRotate), |
| y - symbolSize * Math.sin(rotate + halfRotate) |
| ] |
| ]; |
| ctx.moveTo(x, y); |
| for (var i = 0, l = point.length; i < l; i++) { |
| ctx.lineTo(point[i][0], point[i][1]); |
| } |
| ctx.lineTo(x, y); |
| }, |
| getPointList: function (style) { |
| var pointList = [ |
| [ |
| style.xStart, |
| style.yStart |
| ], |
| [ |
| style.xEnd, |
| style.yEnd |
| ] |
| ]; |
| if (style.smooth === 'spline') { |
| var lastPointX = pointList[1][0]; |
| var lastPointY = pointList[1][1]; |
| pointList[3] = [ |
| lastPointX, |
| lastPointY |
| ]; |
| pointList[1] = this.getOffetPoint(pointList[0], pointList[3]); |
| pointList[2] = this.getOffetPoint(pointList[3], pointList[0]); |
| pointList = smoothSpline(pointList, false); |
| pointList[pointList.length - 1] = [ |
| lastPointX, |
| lastPointY |
| ]; |
| } |
| return pointList; |
| }, |
| getOffetPoint: function (sp, ep) { |
| var distance = Math.sqrt(Math.round((sp[0] - ep[0]) * (sp[0] - ep[0]) + (sp[1] - ep[1]) * (sp[1] - ep[1]))) / 3; |
| var mp = [ |
| sp[0], |
| sp[1] |
| ]; |
| var angle; |
| var deltaAngle = 0.2; |
| if (sp[0] != ep[0] && sp[1] != ep[1]) { |
| var k = (ep[1] - sp[1]) / (ep[0] - sp[0]); |
| angle = Math.atan(k); |
| } else if (sp[0] == ep[0]) { |
| angle = (sp[1] <= ep[1] ? 1 : -1) * Math.PI / 2; |
| } else { |
| angle = 0; |
| } |
| var dX; |
| var dY; |
| if (sp[0] <= ep[0]) { |
| angle -= deltaAngle; |
| dX = Math.round(Math.cos(angle) * distance); |
| dY = Math.round(Math.sin(angle) * distance); |
| mp[0] += dX; |
| mp[1] += dY; |
| } else { |
| angle += deltaAngle; |
| dX = Math.round(Math.cos(angle) * distance); |
| dY = Math.round(Math.sin(angle) * distance); |
| mp[0] -= dX; |
| mp[1] -= dY; |
| } |
| return mp; |
| }, |
| getRect: function (style) { |
| if (style.__rect) { |
| return style.__rect; |
| } |
| var lineWidth = style.lineWidth || 1; |
| style.__rect = { |
| x: Math.min(style.xStart, style.xEnd) - lineWidth, |
| y: Math.min(style.yStart, style.yEnd) - lineWidth, |
| width: Math.abs(style.xStart - style.xEnd) + lineWidth, |
| height: Math.abs(style.yStart - style.yEnd) + lineWidth |
| }; |
| return style.__rect; |
| }, |
| isCover: function (x, y) { |
| var originPos = this.getTansform(x, y); |
| x = originPos[0]; |
| y = originPos[1]; |
| var rect = this.style.__rect; |
| if (!rect) { |
| rect = this.style.__rect = this.getRect(this.style); |
| } |
| if (x >= rect.x && x <= rect.x + rect.width && y >= rect.y && y <= rect.y + rect.height) { |
| return this.style.smooth !== 'spline' ? area.isInside(lineInstance, this.style, x, y) : area.isInside(brokenLineInstance, this.style, x, y); |
| } |
| return false; |
| } |
| }; |
| zrUtil.inherits(MarkLine, Base); |
| return MarkLine; |
| });define('echarts/util/shape/Symbol', [ |
| 'require', |
| 'zrender/shape/Base', |
| 'zrender/shape/Polygon', |
| 'zrender/tool/util', |
| './normalIsCover' |
| ], function (require) { |
| var Base = require('zrender/shape/Base'); |
| var PolygonShape = require('zrender/shape/Polygon'); |
| var polygonInstance = new PolygonShape({}); |
| var zrUtil = require('zrender/tool/util'); |
| function Symbol(options) { |
| Base.call(this, options); |
| } |
| Symbol.prototype = { |
| type: 'symbol', |
| buildPath: function (ctx, style) { |
| var pointList = style.pointList; |
| var len = pointList.length; |
| if (len === 0) { |
| return; |
| } |
| var subSize = 10000; |
| var subSetLength = Math.ceil(len / subSize); |
| var sub; |
| var subLen; |
| var isArray = pointList[0] instanceof Array; |
| var size = style.size ? style.size : 2; |
| var curSize = size; |
| var halfSize = size / 2; |
| var PI2 = Math.PI * 2; |
| var percent; |
| var x; |
| var y; |
| for (var j = 0; j < subSetLength; j++) { |
| ctx.beginPath(); |
| sub = j * subSize; |
| subLen = sub + subSize; |
| subLen = subLen > len ? len : subLen; |
| for (var i = sub; i < subLen; i++) { |
| if (style.random) { |
| percent = style['randomMap' + i % 20] / 100; |
| curSize = size * percent * percent; |
| halfSize = curSize / 2; |
| } |
| if (isArray) { |
| x = pointList[i][0]; |
| y = pointList[i][1]; |
| } else { |
| x = pointList[i].x; |
| y = pointList[i].y; |
| } |
| if (curSize < 3) { |
| ctx.rect(x - halfSize, y - halfSize, curSize, curSize); |
| } else { |
| switch (style.iconType) { |
| case 'circle': |
| ctx.moveTo(x, y); |
| ctx.arc(x, y, halfSize, 0, PI2, true); |
| break; |
| case 'diamond': |
| ctx.moveTo(x, y - halfSize); |
| ctx.lineTo(x + halfSize / 3, y - halfSize / 3); |
| ctx.lineTo(x + halfSize, y); |
| ctx.lineTo(x + halfSize / 3, y + halfSize / 3); |
| ctx.lineTo(x, y + halfSize); |
| ctx.lineTo(x - halfSize / 3, y + halfSize / 3); |
| ctx.lineTo(x - halfSize, y); |
| ctx.lineTo(x - halfSize / 3, y - halfSize / 3); |
| ctx.lineTo(x, y - halfSize); |
| break; |
| default: |
| ctx.rect(x - halfSize, y - halfSize, curSize, curSize); |
| } |
| } |
| } |
| ctx.closePath(); |
| if (j < subSetLength - 1) { |
| switch (style.brushType) { |
| case 'both': |
| ctx.fill(); |
| style.lineWidth > 0 && ctx.stroke(); |
| break; |
| case 'stroke': |
| style.lineWidth > 0 && ctx.stroke(); |
| break; |
| default: |
| ctx.fill(); |
| } |
| } |
| } |
| }, |
| getRect: function (style) { |
| return style.__rect || polygonInstance.getRect(style); |
| }, |
| isCover: require('./normalIsCover') |
| }; |
| zrUtil.inherits(Symbol, Base); |
| return Symbol; |
| });define('echarts/util/ecAnimation', [ |
| 'require', |
| 'zrender/tool/util', |
| 'zrender/shape/Polygon' |
| ], function (require) { |
| var zrUtil = require('zrender/tool/util'); |
| function pointList(zr, oldShape, newShape, duration, easing) { |
| var newPointList = newShape.style.pointList; |
| var newPointListLen = newPointList.length; |
| var oldPointList; |
| if (!oldShape) { |
| oldPointList = []; |
| if (newShape._orient != 'vertical') { |
| var y = newPointList[0][1]; |
| for (var i = 0; i < newPointListLen; i++) { |
| oldPointList[i] = [ |
| newPointList[i][0], |
| y |
| ]; |
| } |
| } else { |
| var x = newPointList[0][0]; |
| for (var i = 0; i < newPointListLen; i++) { |
| oldPointList[i] = [ |
| x, |
| newPointList[i][1] |
| ]; |
| } |
| } |
| if (newShape.type == 'half-smooth-polygon') { |
| oldPointList[newPointListLen - 1] = zrUtil.clone(newPointList[newPointListLen - 1]); |
| oldPointList[newPointListLen - 2] = zrUtil.clone(newPointList[newPointListLen - 2]); |
| } |
| oldShape = { style: { pointList: oldPointList } }; |
| } |
| oldPointList = oldShape.style.pointList; |
| var oldPointListLen = oldPointList.length; |
| if (oldPointListLen == newPointListLen) { |
| newShape.style.pointList = oldPointList; |
| } else if (oldPointListLen < newPointListLen) { |
| newShape.style.pointList = oldPointList.concat(newPointList.slice(oldPointListLen)); |
| } else { |
| newShape.style.pointList = oldPointList.slice(0, newPointListLen); |
| } |
| zr.addShape(newShape); |
| zr.animate(newShape.id, 'style').when(duration, { pointList: newPointList }).start(easing); |
| } |
| function cloneStyle(target, source) { |
| var len = arguments.length; |
| for (var i = 2; i < len; i++) { |
| var prop = arguments[i]; |
| target.style[prop] = source.style[prop]; |
| } |
| } |
| function rectangle(zr, oldShape, newShape, duration, easing) { |
| var newShapeStyle = newShape.style; |
| if (!oldShape) { |
| oldShape = { |
| position: newShape.position, |
| style: { |
| x: newShapeStyle.x, |
| y: newShape._orient == 'vertical' ? newShapeStyle.y + newShapeStyle.height : newShapeStyle.y, |
| width: newShape._orient == 'vertical' ? newShapeStyle.width : 0, |
| height: newShape._orient != 'vertical' ? newShapeStyle.height : 0 |
| } |
| }; |
| } |
| var newX = newShapeStyle.x; |
| var newY = newShapeStyle.y; |
| var newWidth = newShapeStyle.width; |
| var newHeight = newShapeStyle.height; |
| var newPosition = [ |
| newShape.position[0], |
| newShape.position[1] |
| ]; |
| cloneStyle(newShape, oldShape, 'x', 'y', 'width', 'height'); |
| newShape.position = oldShape.position; |
| zr.addShape(newShape); |
| if (newPosition[0] != oldShape.position[0] || newPosition[1] != oldShape.position[1]) { |
| zr.animate(newShape.id, '').when(duration, { position: newPosition }).start(easing); |
| } |
| zr.animate(newShape.id, 'style').when(duration, { |
| x: newX, |
| y: newY, |
| width: newWidth, |
| height: newHeight |
| }).start(easing); |
| } |
| function candle(zr, oldShape, newShape, duration, easing) { |
| if (!oldShape) { |
| var y = newShape.style.y; |
| oldShape = { |
| style: { |
| y: [ |
| y[0], |
| y[0], |
| y[0], |
| y[0] |
| ] |
| } |
| }; |
| } |
| var newY = newShape.style.y; |
| newShape.style.y = oldShape.style.y; |
| zr.addShape(newShape); |
| zr.animate(newShape.id, 'style').when(duration, { y: newY }).start(easing); |
| } |
| function ring(zr, oldShape, newShape, duration, easing) { |
| var x = newShape.style.x; |
| var y = newShape.style.y; |
| var r0 = newShape.style.r0; |
| var r = newShape.style.r; |
| if (newShape._animationAdd != 'r') { |
| newShape.style.r0 = 0; |
| newShape.style.r = 0; |
| newShape.rotation = [ |
| Math.PI * 2, |
| x, |
| y |
| ]; |
| zr.addShape(newShape); |
| zr.animate(newShape.id, 'style').when(duration, { |
| r0: r0, |
| r: r |
| }).start(easing); |
| zr.animate(newShape.id, '').when(Math.round(duration / 3 * 2), { |
| rotation: [ |
| 0, |
| x, |
| y |
| ] |
| }).start(easing); |
| } else { |
| newShape.style.r0 = newShape.style.r; |
| zr.addShape(newShape); |
| zr.animate(newShape.id, 'style').when(duration, { r0: r0 }).start(easing); |
| } |
| } |
| function sector(zr, oldShape, newShape, duration, easing) { |
| if (!oldShape) { |
| if (newShape._animationAdd != 'r') { |
| oldShape = { |
| style: { |
| startAngle: newShape.style.startAngle, |
| endAngle: newShape.style.startAngle |
| } |
| }; |
| } else { |
| oldShape = { style: { r0: newShape.style.r } }; |
| } |
| } |
| var startAngle = newShape.style.startAngle; |
| var endAngle = newShape.style.endAngle; |
| cloneStyle(newShape, oldShape, 'startAngle', 'endAngle'); |
| zr.addShape(newShape); |
| zr.animate(newShape.id, 'style').when(duration, { |
| startAngle: startAngle, |
| endAngle: endAngle |
| }).start(easing); |
| } |
| function text(zr, oldShape, newShape, duration, easing) { |
| if (!oldShape) { |
| oldShape = { |
| style: { |
| x: newShape.style.textAlign == 'left' ? newShape.style.x + 100 : newShape.style.x - 100, |
| y: newShape.style.y |
| } |
| }; |
| } |
| var x = newShape.style.x; |
| var y = newShape.style.y; |
| cloneStyle(newShape, oldShape, 'x', 'y'); |
| zr.addShape(newShape); |
| zr.animate(newShape.id, 'style').when(duration, { |
| x: x, |
| y: y |
| }).start(easing); |
| } |
| function polygon(zr, oldShape, newShape, duration, easing) { |
| var rect = require('zrender/shape/Polygon').prototype.getRect(newShape.style); |
| var x = rect.x + rect.width / 2; |
| var y = rect.y + rect.height / 2; |
| newShape.scale = [ |
| 0.1, |
| 0.1, |
| x, |
| y |
| ]; |
| zr.addShape(newShape); |
| zr.animate(newShape.id, '').when(duration, { |
| scale: [ |
| 1, |
| 1, |
| x, |
| y |
| ] |
| }).start(easing); |
| } |
| function ribbon(zr, oldShape, newShape, duration, easing) { |
| if (!oldShape) { |
| oldShape = { |
| style: { |
| source0: 0, |
| source1: newShape.style.source1 > 0 ? 360 : -360, |
| target0: 0, |
| target1: newShape.style.target1 > 0 ? 360 : -360 |
| } |
| }; |
| } |
| var source0 = newShape.style.source0; |
| var source1 = newShape.style.source1; |
| var target0 = newShape.style.target0; |
| var target1 = newShape.style.target1; |
| if (oldShape.style) { |
| cloneStyle(newShape, oldShape, 'source0', 'source1', 'target0', 'target1'); |
| } |
| zr.addShape(newShape); |
| zr.animate(newShape.id, 'style').when(duration, { |
| source0: source0, |
| source1: source1, |
| target0: target0, |
| target1: target1 |
| }).start(easing); |
| } |
| function gaugePointer(zr, oldShape, newShape, duration, easing) { |
| if (!oldShape) { |
| oldShape = { style: { angle: newShape.style.startAngle } }; |
| } |
| var angle = newShape.style.angle; |
| newShape.style.angle = oldShape.style.angle; |
| zr.addShape(newShape); |
| zr.animate(newShape.id, 'style').when(duration, { angle: angle }).start(easing); |
| } |
| function icon(zr, oldShape, newShape, duration, easing, delay) { |
| newShape.style._x = newShape.style.x; |
| newShape.style._y = newShape.style.y; |
| newShape.style._width = newShape.style.width; |
| newShape.style._height = newShape.style.height; |
| if (!oldShape) { |
| var x = newShape._x || 0; |
| var y = newShape._y || 0; |
| newShape.scale = [ |
| 0.01, |
| 0.01, |
| x, |
| y |
| ]; |
| zr.addShape(newShape); |
| zr.animate(newShape.id, '').delay(delay).when(duration, { |
| scale: [ |
| 1, |
| 1, |
| x, |
| y |
| ] |
| }).start(easing || 'QuinticOut'); |
| } else { |
| rectangle(zr, oldShape, newShape, duration, easing); |
| } |
| } |
| function line(zr, oldShape, newShape, duration, easing) { |
| if (!oldShape) { |
| oldShape = { |
| style: { |
| xStart: newShape.style.xStart, |
| yStart: newShape.style.yStart, |
| xEnd: newShape.style.xStart, |
| yEnd: newShape.style.yStart |
| } |
| }; |
| } |
| var xStart = newShape.style.xStart; |
| var xEnd = newShape.style.xEnd; |
| var yStart = newShape.style.yStart; |
| var yEnd = newShape.style.yEnd; |
| cloneStyle(newShape, oldShape, 'xStart', 'xEnd', 'yStart', 'yEnd'); |
| zr.addShape(newShape); |
| zr.animate(newShape.id, 'style').when(duration, { |
| xStart: xStart, |
| xEnd: xEnd, |
| yStart: yStart, |
| yEnd: yEnd |
| }).start(easing); |
| } |
| function markline(zr, oldShape, newShape, duration, easing) { |
| if (!newShape.style.smooth) { |
| newShape.style.pointList = !oldShape ? [ |
| [ |
| newShape.style.xStart, |
| newShape.style.yStart |
| ], |
| [ |
| newShape.style.xStart, |
| newShape.style.yStart |
| ] |
| ] : oldShape.style.pointList; |
| zr.addShape(newShape); |
| zr.animate(newShape.id, 'style').when(duration, { |
| pointList: [ |
| [ |
| newShape.style.xStart, |
| newShape.style.yStart |
| ], |
| [ |
| newShape._x || 0, |
| newShape._y || 0 |
| ] |
| ] |
| }).start(easing || 'QuinticOut'); |
| } else { |
| if (!oldShape) { |
| newShape.style.pointListLength = 1; |
| zr.addShape(newShape); |
| newShape.style.pointList = newShape.style.pointList || newShape.getPointList(newShape.style); |
| zr.animate(newShape.id, 'style').when(duration, { pointListLength: newShape.style.pointList.length }).start(easing || 'QuinticOut'); |
| } else { |
| zr.addShape(newShape); |
| } |
| } |
| } |
| return { |
| pointList: pointList, |
| rectangle: rectangle, |
| candle: candle, |
| ring: ring, |
| sector: sector, |
| text: text, |
| polygon: polygon, |
| ribbon: ribbon, |
| gaugePointer: gaugePointer, |
| icon: icon, |
| line: line, |
| markline: markline |
| }; |
| });define('echarts/util/ecEffect', [ |
| 'require', |
| '../util/ecData', |
| 'zrender/shape/Circle', |
| 'zrender/shape/Image', |
| '../util/shape/Icon', |
| '../util/shape/Symbol', |
| 'zrender/tool/env' |
| ], function (require) { |
| var ecData = require('../util/ecData'); |
| var CircleShape = require('zrender/shape/Circle'); |
| var ImageShape = require('zrender/shape/Image'); |
| var IconShape = require('../util/shape/Icon'); |
| var SymbolShape = require('../util/shape/Symbol'); |
| var canvasSupported = require('zrender/tool/env').canvasSupported; |
| function point(zr, effectList, shape, zlevel) { |
| var effect = shape.effect; |
| var color = effect.color || shape.style.strokeColor || shape.style.color; |
| var shadowColor = effect.shadowColor || color; |
| var size = effect.scaleSize; |
| var shadowBlur = typeof effect.shadowBlur != 'undefined' ? effect.shadowBlur : size; |
| var effectShape = new IconShape({ |
| zlevel: zlevel, |
| style: { |
| brushType: 'stroke', |
| iconType: shape.style.iconType != 'pin' && shape.style.iconType != 'droplet' ? shape.style.iconType : 'circle', |
| x: shadowBlur + 1, |
| y: shadowBlur + 1, |
| n: shape.style.n, |
| width: shape.style._width * size, |
| height: shape.style._height * size, |
| lineWidth: 1, |
| strokeColor: color, |
| shadowColor: shadowColor, |
| shadowBlur: shadowBlur |
| }, |
| draggable: false, |
| hoverable: false |
| }); |
| if (canvasSupported) { |
| effectShape.style.image = zr.shapeToImage(effectShape, effectShape.style.width + shadowBlur * 2 + 2, effectShape.style.height + shadowBlur * 2 + 2).style.image; |
| effectShape = new ImageShape({ |
| zlevel: effectShape.zlevel, |
| style: effectShape.style, |
| draggable: false, |
| hoverable: false |
| }); |
| } |
| ecData.clone(shape, effectShape); |
| effectShape.position = shape.position; |
| effectList.push(effectShape); |
| zr.addShape(effectShape); |
| var devicePixelRatio = window.devicePixelRatio || 1; |
| var offset = (effectShape.style.width / devicePixelRatio - shape.style._width) / 2; |
| effectShape.style.x = shape.style._x - offset; |
| effectShape.style.y = shape.style._y - offset; |
| var duration = (effect.period + Math.random() * 10) * 100; |
| zr.modShape(shape.id, { invisible: true }); |
| var centerX = effectShape.style.x + effectShape.style.width / 2 / devicePixelRatio; |
| var centerY = effectShape.style.y + effectShape.style.height / 2 / devicePixelRatio; |
| zr.modShape(effectShape.id, { |
| scale: [ |
| 0.1, |
| 0.1, |
| centerX, |
| centerY |
| ] |
| }); |
| zr.animate(effectShape.id, '', effect.loop).when(duration, { |
| scale: [ |
| 1, |
| 1, |
| centerX, |
| centerY |
| ] |
| }).done(function () { |
| shape.effect.show = false; |
| zr.delShape(effectShape.id); |
| }).start(); |
| } |
| function largePoint(zr, effectList, shape, zlevel) { |
| var effect = shape.effect; |
| var color = effect.color || shape.style.strokeColor || shape.style.color; |
| var size = effect.scaleSize; |
| var shadowColor = effect.shadowColor || color; |
| var shadowBlur = typeof effect.shadowBlur != 'undefined' ? effect.shadowBlur : size * 2; |
| var devicePixelRatio = window.devicePixelRatio || 1; |
| var effectShape = new SymbolShape({ |
| zlevel: zlevel, |
| position: shape.position, |
| scale: shape.scale, |
| style: { |
| pointList: shape.style.pointList, |
| iconType: shape.style.iconType, |
| color: color, |
| strokeColor: color, |
| shadowColor: shadowColor, |
| shadowBlur: shadowBlur * devicePixelRatio, |
| random: true, |
| brushType: 'fill', |
| lineWidth: 1, |
| size: shape.style.size |
| }, |
| draggable: false, |
| hoverable: false |
| }); |
| effectList.push(effectShape); |
| zr.addShape(effectShape); |
| zr.modShape(shape.id, { invisible: true }); |
| var duration = Math.round(effect.period * 100); |
| var clip1 = {}; |
| var clip2 = {}; |
| for (var i = 0; i < 20; i++) { |
| effectShape.style['randomMap' + i] = 0; |
| clip1 = {}; |
| clip1['randomMap' + i] = 100; |
| clip2 = {}; |
| clip2['randomMap' + i] = 0; |
| effectShape.style['randomMap' + i] = Math.random() * 100; |
| zr.animate(effectShape.id, 'style', true).when(duration, clip1).when(duration * 2, clip2).when(duration * 3, clip1).when(duration * 4, clip1).delay(Math.random() * duration * i).start(); |
| } |
| } |
| function line(zr, effectList, shape, zlevel) { |
| var effect = shape.effect; |
| var color = effect.color || shape.style.strokeColor || shape.style.color; |
| var shadowColor = effect.shadowColor || shape.style.strokeColor || color; |
| var size = shape.style.lineWidth * effect.scaleSize; |
| var shadowBlur = typeof effect.shadowBlur != 'undefined' ? effect.shadowBlur : size; |
| var effectShape = new CircleShape({ |
| zlevel: zlevel, |
| style: { |
| x: shadowBlur, |
| y: shadowBlur, |
| r: size, |
| color: color, |
| shadowColor: shadowColor, |
| shadowBlur: shadowBlur |
| }, |
| draggable: false, |
| hoverable: false |
| }); |
| var offset; |
| if (canvasSupported) { |
| effectShape.style.image = zr.shapeToImage(effectShape, (size + shadowBlur) * 2, (size + shadowBlur) * 2).style.image; |
| effectShape = new ImageShape({ |
| zlevel: effectShape.zlevel, |
| style: effectShape.style, |
| draggable: false, |
| hoverable: false |
| }); |
| offset = shadowBlur; |
| } else { |
| offset = 0; |
| } |
| ecData.clone(shape, effectShape); |
| effectShape.position = shape.position; |
| effectList.push(effectShape); |
| zr.addShape(effectShape); |
| effectShape.style.x = shape.style.xStart - offset; |
| effectShape.style.y = shape.style.yStart - offset; |
| var distance = (shape.style.xStart - shape.style.xEnd) * (shape.style.xStart - shape.style.xEnd) + (shape.style.yStart - shape.style.yEnd) * (shape.style.yStart - shape.style.yEnd); |
| var duration = Math.round(Math.sqrt(Math.round(distance * effect.period * effect.period))); |
| if (!shape.style.smooth) { |
| zr.animate(effectShape.id, 'style', effect.loop).when(duration, { |
| x: shape._x - offset, |
| y: shape._y - offset |
| }).done(function () { |
| shape.effect.show = false; |
| zr.delShape(effectShape.id); |
| }).start(); |
| } else { |
| var pointList = shape.style.pointList || shape.getPointList(shape.style); |
| var len = pointList.length; |
| duration = Math.round(duration / len); |
| var deferred = zr.animate(effectShape.id, 'style', effect.loop); |
| var step = Math.ceil(len / 8); |
| for (var j = 0; j < len - step; j += step) { |
| deferred.when(duration * (j + 1), { |
| x: pointList[j][0] - offset, |
| y: pointList[j][1] - offset |
| }); |
| } |
| deferred.when(duration * len, { |
| x: pointList[len - 1][0] - offset, |
| y: pointList[len - 1][1] - offset |
| }); |
| deferred.done(function () { |
| shape.effect.show = false; |
| zr.delShape(effectShape.id); |
| }); |
| deferred.start('spline'); |
| } |
| } |
| return { |
| point: point, |
| largePoint: largePoint, |
| line: line |
| }; |
| });define('zrender/shape/Star', [ |
| 'require', |
| '../tool/math', |
| './Base', |
| '../tool/util' |
| ], function (require) { |
| var math = require('../tool/math'); |
| var sin = math.sin; |
| var cos = math.cos; |
| var PI = Math.PI; |
| var Base = require('./Base'); |
| var Star = function (options) { |
| Base.call(this, options); |
| }; |
| Star.prototype = { |
| type: 'star', |
| buildPath: function (ctx, style) { |
| var n = style.n; |
| if (!n || n < 2) { |
| return; |
| } |
| var x = style.x; |
| var y = style.y; |
| var r = style.r; |
| var r0 = style.r0; |
| if (r0 == null) { |
| r0 = n > 4 ? r * cos(2 * PI / n) / cos(PI / n) : r / 3; |
| } |
| var dStep = PI / n; |
| var deg = -PI / 2; |
| var xStart = x + r * cos(deg); |
| var yStart = y + r * sin(deg); |
| deg += dStep; |
| var pointList = style.pointList = []; |
| pointList.push([ |
| xStart, |
| yStart |
| ]); |
| for (var i = 0, end = n * 2 - 1, ri; i < end; i++) { |
| ri = i % 2 === 0 ? r0 : r; |
| pointList.push([ |
| x + ri * cos(deg), |
| y + ri * sin(deg) |
| ]); |
| deg += dStep; |
| } |
| pointList.push([ |
| xStart, |
| yStart |
| ]); |
| ctx.moveTo(pointList[0][0], pointList[0][1]); |
| for (var i = 0; i < pointList.length; i++) { |
| ctx.lineTo(pointList[i][0], pointList[i][1]); |
| } |
| ctx.closePath(); |
| return; |
| }, |
| getRect: function (style) { |
| if (style.__rect) { |
| return style.__rect; |
| } |
| var lineWidth; |
| if (style.brushType == 'stroke' || style.brushType == 'fill') { |
| lineWidth = style.lineWidth || 1; |
| } else { |
| lineWidth = 0; |
| } |
| style.__rect = { |
| x: Math.round(style.x - style.r - lineWidth / 2), |
| y: Math.round(style.y - style.r - lineWidth / 2), |
| width: style.r * 2 + lineWidth, |
| height: style.r * 2 + lineWidth |
| }; |
| return style.__rect; |
| } |
| }; |
| require('../tool/util').inherits(Star, Base); |
| return Star; |
| });define('zrender/shape/Heart', [ |
| 'require', |
| './Base', |
| './util/PathProxy', |
| 'zrender/tool/area', |
| '../tool/util' |
| ], function (require) { |
| 'use strict'; |
| var Base = require('./Base'); |
| var PathProxy = require('./util/PathProxy'); |
| var area = require('zrender/tool/area'); |
| var Heart = function (options) { |
| Base.call(this, options); |
| this._pathProxy = new PathProxy(); |
| }; |
| Heart.prototype = { |
| type: 'heart', |
| buildPath: function (ctx, style) { |
| var path = this._pathProxy || new PathProxy(); |
| path.begin(ctx); |
| path.moveTo(style.x, style.y); |
| path.bezierCurveTo(style.x + style.a / 2, style.y - style.b * 2 / 3, style.x + style.a * 2, style.y + style.b / 3, style.x, style.y + style.b); |
| path.bezierCurveTo(style.x - style.a * 2, style.y + style.b / 3, style.x - style.a / 2, style.y - style.b * 2 / 3, style.x, style.y); |
| path.closePath(); |
| return; |
| }, |
| getRect: function (style) { |
| if (style.__rect) { |
| return style.__rect; |
| } |
| if (!this._pathProxy.isEmpty()) { |
| this.buildPath(null, style); |
| } |
| return this._pathProxy.fastBoundingRect(); |
| }, |
| isCover: function (x, y) { |
| var originPos = this.getTansform(x, y); |
| x = originPos[0]; |
| y = originPos[1]; |
| var rect = this.getRect(this.style); |
| if (x >= rect.x && x <= rect.x + rect.width && y >= rect.y && y <= rect.y + rect.height) { |
| return area.isInsidePath(this._pathProxy.pathCommands, this.style.lineWidth, this.style.brushType, x, y); |
| } |
| } |
| }; |
| require('../tool/util').inherits(Heart, Base); |
| return Heart; |
| });define('zrender/shape/Droplet', [ |
| 'require', |
| './Base', |
| './util/PathProxy', |
| 'zrender/tool/area', |
| '../tool/util' |
| ], function (require) { |
| 'use strict'; |
| var Base = require('./Base'); |
| var PathProxy = require('./util/PathProxy'); |
| var area = require('zrender/tool/area'); |
| var Droplet = function (options) { |
| Base.call(this, options); |
| this._pathProxy = new PathProxy(); |
| }; |
| Droplet.prototype = { |
| type: 'droplet', |
| buildPath: function (ctx, style) { |
| var path = this._pathProxy || new PathProxy(); |
| path.begin(ctx); |
| path.moveTo(style.x, style.y + style.a); |
| path.bezierCurveTo(style.x + style.a, style.y + style.a, style.x + style.a * 3 / 2, style.y - style.a / 3, style.x, style.y - style.b); |
| path.bezierCurveTo(style.x - style.a * 3 / 2, style.y - style.a / 3, style.x - style.a, style.y + style.a, style.x, style.y + style.a); |
| path.closePath(); |
| }, |
| getRect: function (style) { |
| if (style.__rect) { |
| return style.__rect; |
| } |
| if (!this._pathProxy.isEmpty()) { |
| this.buildPath(null, style); |
| } |
| return this._pathProxy.fastBoundingRect(); |
| }, |
| isCover: function (x, y) { |
| var originPos = this.getTansform(x, y); |
| x = originPos[0]; |
| y = originPos[1]; |
| var rect = this.getRect(this.style); |
| if (x >= rect.x && x <= rect.x + rect.width && y >= rect.y && y <= rect.y + rect.height) { |
| return area.isInsidePath(this._pathProxy.pathCommands, this.style.lineWidth, this.style.brushType, x, y); |
| } |
| } |
| }; |
| require('../tool/util').inherits(Droplet, Base); |
| return Droplet; |
| });define('zrender/tool/math', [], function () { |
| var _radians = Math.PI / 180; |
| function sin(angle, isDegrees) { |
| return Math.sin(isDegrees ? angle * _radians : angle); |
| } |
| function cos(angle, isDegrees) { |
| return Math.cos(isDegrees ? angle * _radians : angle); |
| } |
| function degreeToRadian(angle) { |
| return angle * _radians; |
| } |
| function radianToDegree(angle) { |
| return angle / _radians; |
| } |
| return { |
| sin: sin, |
| cos: cos, |
| degreeToRadian: degreeToRadian, |
| radianToDegree: radianToDegree |
| }; |
| });define('zrender/shape/util/PathProxy', [ |
| 'require', |
| '../../tool/vector' |
| ], function (require) { |
| var vector = require('../../tool/vector'); |
| var PathSegment = function (command, points) { |
| this.command = command; |
| this.points = points || null; |
| }; |
| var PathProxy = function () { |
| this.pathCommands = []; |
| this._ctx = null; |
| this._min = []; |
| this._max = []; |
| }; |
| PathProxy.prototype.fastBoundingRect = function () { |
| var min = this._min; |
| var max = this._max; |
| min[0] = min[1] = Infinity; |
| max[0] = max[1] = -Infinity; |
| for (var i = 0; i < this.pathCommands.length; i++) { |
| var seg = this.pathCommands[i]; |
| var p = seg.points; |
| switch (seg.command) { |
| case 'M': |
| vector.min(min, min, p); |
| vector.max(max, max, p); |
| break; |
| case 'L': |
| vector.min(min, min, p); |
| vector.max(max, max, p); |
| break; |
| case 'C': |
| for (var j = 0; j < 6; j += 2) { |
| min[0] = Math.min(min[0], min[0], p[j]); |
| min[1] = Math.min(min[1], min[1], p[j + 1]); |
| max[0] = Math.max(max[0], max[0], p[j]); |
| max[1] = Math.max(max[1], max[1], p[j + 1]); |
| } |
| break; |
| case 'Q': |
| for (var j = 0; j < 4; j += 2) { |
| min[0] = Math.min(min[0], min[0], p[j]); |
| min[1] = Math.min(min[1], min[1], p[j + 1]); |
| max[0] = Math.max(max[0], max[0], p[j]); |
| max[1] = Math.max(max[1], max[1], p[j + 1]); |
| } |
| break; |
| case 'A': |
| var cx = p[0]; |
| var cy = p[1]; |
| var rx = p[2]; |
| var ry = p[3]; |
| min[0] = Math.min(min[0], min[0], cx - rx); |
| min[1] = Math.min(min[1], min[1], cy - ry); |
| max[0] = Math.max(max[0], max[0], cx + rx); |
| max[1] = Math.max(max[1], max[1], cy + ry); |
| break; |
| } |
| } |
| return { |
| x: min[0], |
| y: min[1], |
| width: max[0] - min[0], |
| height: max[1] - min[1] |
| }; |
| }; |
| PathProxy.prototype.begin = function (ctx) { |
| this._ctx = ctx || null; |
| this.pathCommands.length = 0; |
| return this; |
| }; |
| PathProxy.prototype.moveTo = function (x, y) { |
| this.pathCommands.push(new PathSegment('M', [ |
| x, |
| y |
| ])); |
| if (this._ctx) { |
| this._ctx.moveTo(x, y); |
| } |
| return this; |
| }; |
| PathProxy.prototype.lineTo = function (x, y) { |
| this.pathCommands.push(new PathSegment('L', [ |
| x, |
| y |
| ])); |
| if (this._ctx) { |
| this._ctx.lineTo(x, y); |
| } |
| return this; |
| }; |
| PathProxy.prototype.bezierCurveTo = function (x1, y1, x2, y2, x3, y3) { |
| this.pathCommands.push(new PathSegment('C', [ |
| x1, |
| y1, |
| x2, |
| y2, |
| x3, |
| y3 |
| ])); |
| if (this._ctx) { |
| this._ctx.bezierCurveTo(x1, y1, x2, y2, x3, y3); |
| } |
| return this; |
| }; |
| PathProxy.prototype.quadraticCurveTo = function (x1, y1, x2, y2) { |
| this.pathCommands.push(new PathSegment('Q', [ |
| x1, |
| y1, |
| x2, |
| y2 |
| ])); |
| if (this._ctx) { |
| this._ctx.quadraticCurveTo(x1, y1, x2, y2); |
| } |
| return this; |
| }; |
| PathProxy.prototype.arc = function (cx, cy, r, startAngle, endAngle, anticlockwise) { |
| this.pathCommands.push(new PathSegment('A', [ |
| cx, |
| cy, |
| r, |
| r, |
| startAngle, |
| endAngle - startAngle, |
| 0, |
| anticlockwise ? 0 : 1 |
| ])); |
| if (this._ctx) { |
| this._ctx.arc(cx, cy, r, startAngle, endAngle, anticlockwise); |
| } |
| return this; |
| }; |
| PathProxy.prototype.arcTo = function (x1, y1, x2, y2, radius) { |
| if (this._ctx) { |
| this._ctx.arcTo(x1, y1, x2, y2, radius); |
| } |
| return this; |
| }; |
| PathProxy.prototype.rect = function (x, y, w, h) { |
| if (this._ctx) { |
| this._ctx.rect(x, y, w, h); |
| } |
| return this; |
| }; |
| PathProxy.prototype.closePath = function () { |
| this.pathCommands.push(new PathSegment('z')); |
| if (this._ctx) { |
| this._ctx.closePath(); |
| } |
| return this; |
| }; |
| PathProxy.prototype.isEmpty = function () { |
| return this.pathCommands.length === 0; |
| }; |
| PathProxy.PathSegment = PathSegment; |
| return PathProxy; |
| });define('zrender/shape/Line', [ |
| 'require', |
| './Base', |
| './util/dashedLineTo', |
| '../tool/util' |
| ], function (require) { |
| var Base = require('./Base'); |
| var dashedLineTo = require('./util/dashedLineTo'); |
| var Line = function (options) { |
| this.brushTypeOnly = 'stroke'; |
| this.textPosition = 'end'; |
| Base.call(this, options); |
| }; |
| Line.prototype = { |
| type: 'line', |
| buildPath: function (ctx, style) { |
| if (!style.lineType || style.lineType == 'solid') { |
| ctx.moveTo(style.xStart, style.yStart); |
| ctx.lineTo(style.xEnd, style.yEnd); |
| } else if (style.lineType == 'dashed' || style.lineType == 'dotted') { |
| var dashLength = (style.lineWidth || 1) * (style.lineType == 'dashed' ? 5 : 1); |
| dashedLineTo(ctx, style.xStart, style.yStart, style.xEnd, style.yEnd, dashLength); |
| } |
| }, |
| getRect: function (style) { |
| if (style.__rect) { |
| return style.__rect; |
| } |
| var lineWidth = style.lineWidth || 1; |
| style.__rect = { |
| x: Math.min(style.xStart, style.xEnd) - lineWidth, |
| y: Math.min(style.yStart, style.yEnd) - lineWidth, |
| width: Math.abs(style.xStart - style.xEnd) + lineWidth, |
| height: Math.abs(style.yStart - style.yEnd) + lineWidth |
| }; |
| return style.__rect; |
| } |
| }; |
| require('../tool/util').inherits(Line, Base); |
| return Line; |
| });define('zrender/shape/BrokenLine', [ |
| 'require', |
| './Base', |
| './util/smoothSpline', |
| './util/smoothBezier', |
| './util/dashedLineTo', |
| './Polygon', |
| '../tool/util' |
| ], function (require) { |
| var Base = require('./Base'); |
| var smoothSpline = require('./util/smoothSpline'); |
| var smoothBezier = require('./util/smoothBezier'); |
| var dashedLineTo = require('./util/dashedLineTo'); |
| var BrokenLine = function (options) { |
| this.brushTypeOnly = 'stroke'; |
| this.textPosition = 'end'; |
| Base.call(this, options); |
| }; |
| BrokenLine.prototype = { |
| type: 'broken-line', |
| buildPath: function (ctx, style) { |
| var pointList = style.pointList; |
| if (pointList.length < 2) { |
| return; |
| } |
| var len = Math.min(style.pointList.length, Math.round(style.pointListLength || style.pointList.length)); |
| if (style.smooth && style.smooth !== 'spline') { |
| var controlPoints = smoothBezier(pointList, style.smooth, false, style.smoothConstraint); |
| ctx.moveTo(pointList[0][0], pointList[0][1]); |
| var cp1; |
| var cp2; |
| var p; |
| for (var i = 0; i < len - 1; i++) { |
| cp1 = controlPoints[i * 2]; |
| cp2 = controlPoints[i * 2 + 1]; |
| p = pointList[i + 1]; |
| ctx.bezierCurveTo(cp1[0], cp1[1], cp2[0], cp2[1], p[0], p[1]); |
| } |
| } else { |
| if (style.smooth === 'spline') { |
| pointList = smoothSpline(pointList); |
| len = pointList.length; |
| } |
| if (!style.lineType || style.lineType == 'solid') { |
| ctx.moveTo(pointList[0][0], pointList[0][1]); |
| for (var i = 1; i < len; i++) { |
| ctx.lineTo(pointList[i][0], pointList[i][1]); |
| } |
| } else if (style.lineType == 'dashed' || style.lineType == 'dotted') { |
| var dashLength = (style.lineWidth || 1) * (style.lineType == 'dashed' ? 5 : 1); |
| ctx.moveTo(pointList[0][0], pointList[0][1]); |
| for (var i = 1; i < len; i++) { |
| dashedLineTo(ctx, pointList[i - 1][0], pointList[i - 1][1], pointList[i][0], pointList[i][1], dashLength); |
| } |
| } |
| } |
| return; |
| }, |
| getRect: function (style) { |
| return require('./Polygon').prototype.getRect(style); |
| } |
| }; |
| require('../tool/util').inherits(BrokenLine, Base); |
| return BrokenLine; |
| });define('zrender/shape/util/dashedLineTo', [], function () { |
| var dashPattern = [ |
| 5, |
| 5 |
| ]; |
| return function (ctx, x1, y1, x2, y2, dashLength) { |
| if (ctx.setLineDash) { |
| dashPattern[0] = dashPattern[1] = dashLength; |
| ctx.setLineDash(dashPattern); |
| ctx.moveTo(x1, y1); |
| ctx.lineTo(x2, y2); |
| return; |
| } |
| dashLength = typeof dashLength != 'number' ? 5 : dashLength; |
| var dx = x2 - x1; |
| var dy = y2 - y1; |
| var numDashes = Math.floor(Math.sqrt(dx * dx + dy * dy) / dashLength); |
| dx = dx / numDashes; |
| dy = dy / numDashes; |
| var flag = true; |
| for (var i = 0; i < numDashes; ++i) { |
| if (flag) { |
| ctx.moveTo(x1, y1); |
| } else { |
| ctx.lineTo(x1, y1); |
| } |
| flag = !flag; |
| x1 += dx; |
| y1 += dy; |
| } |
| ctx.lineTo(x2, y2); |
| }; |
| });define('zrender/shape/util/smoothSpline', [ |
| 'require', |
| '../../tool/vector' |
| ], function (require) { |
| var vector = require('../../tool/vector'); |
| function interpolate(p0, p1, p2, p3, t, t2, t3) { |
| var v0 = (p2 - p0) * 0.5; |
| var v1 = (p3 - p1) * 0.5; |
| return (2 * (p1 - p2) + v0 + v1) * t3 + (-3 * (p1 - p2) - 2 * v0 - v1) * t2 + v0 * t + p1; |
| } |
| return function (points, isLoop, constraint) { |
| var len = points.length; |
| var ret = []; |
| var distance = 0; |
| for (var i = 1; i < len; i++) { |
| distance += vector.distance(points[i - 1], points[i]); |
| } |
| var segs = distance / 5; |
| segs = segs < len ? len : segs; |
| for (var i = 0; i < segs; i++) { |
| var pos = i / (segs - 1) * (isLoop ? len : len - 1); |
| var idx = Math.floor(pos); |
| var w = pos - idx; |
| var p0; |
| var p1 = points[idx % len]; |
| var p2; |
| var p3; |
| if (!isLoop) { |
| p0 = points[idx === 0 ? idx : idx - 1]; |
| p2 = points[idx > len - 2 ? len - 1 : idx + 1]; |
| p3 = points[idx > len - 3 ? len - 1 : idx + 2]; |
| } else { |
| p0 = points[(idx - 1 + len) % len]; |
| p2 = points[(idx + 1) % len]; |
| p3 = points[(idx + 2) % len]; |
| } |
| var w2 = w * w; |
| var w3 = w * w2; |
| ret.push([ |
| interpolate(p0[0], p1[0], p2[0], p3[0], w, w2, w3), |
| interpolate(p0[1], p1[1], p2[1], p3[1], w, w2, w3) |
| ]); |
| } |
| return ret; |
| }; |
| });define('zrender/shape/util/smoothBezier', [ |
| 'require', |
| '../../tool/vector' |
| ], function (require) { |
| var vector = require('../../tool/vector'); |
| return function (points, smooth, isLoop, constraint) { |
| var cps = []; |
| var v = []; |
| var v1 = []; |
| var v2 = []; |
| var prevPoint; |
| var nextPoint; |
| var hasConstraint = !!constraint; |
| var min, max; |
| if (hasConstraint) { |
| min = [ |
| Infinity, |
| Infinity |
| ]; |
| max = [ |
| -Infinity, |
| -Infinity |
| ]; |
| for (var i = 0, len = points.length; i < len; i++) { |
| vector.min(min, min, points[i]); |
| vector.max(max, max, points[i]); |
| } |
| vector.min(min, min, constraint[0]); |
| vector.max(max, max, constraint[1]); |
| } |
| for (var i = 0, len = points.length; i < len; i++) { |
| var point = points[i]; |
| var prevPoint; |
| var nextPoint; |
| if (isLoop) { |
| prevPoint = points[i ? i - 1 : len - 1]; |
| nextPoint = points[(i + 1) % len]; |
| } else { |
| if (i === 0 || i === len - 1) { |
| cps.push(points[i]); |
| continue; |
| } else { |
| prevPoint = points[i - 1]; |
| nextPoint = points[i + 1]; |
| } |
| } |
| vector.sub(v, nextPoint, prevPoint); |
| vector.scale(v, v, smooth); |
| var d0 = vector.distance(point, prevPoint); |
| var d1 = vector.distance(point, nextPoint); |
| var sum = d0 + d1; |
| if (sum !== 0) { |
| d0 /= sum; |
| d1 /= sum; |
| } |
| vector.scale(v1, v, -d0); |
| vector.scale(v2, v, d1); |
| var cp0 = vector.add([], point, v1); |
| var cp1 = vector.add([], point, v2); |
| if (hasConstraint) { |
| vector.max(cp0, cp0, min); |
| vector.min(cp0, cp0, max); |
| vector.max(cp1, cp1, min); |
| vector.min(cp1, cp1, max); |
| } |
| cps.push(cp0); |
| cps.push(cp1); |
| } |
| if (isLoop) { |
| cps.push(cps.shift()); |
| } |
| return cps; |
| }; |
| });define('zrender/shape/Polygon', [ |
| 'require', |
| './Base', |
| './util/smoothSpline', |
| './util/smoothBezier', |
| './util/dashedLineTo', |
| '../tool/util' |
| ], function (require) { |
| var Base = require('./Base'); |
| var smoothSpline = require('./util/smoothSpline'); |
| var smoothBezier = require('./util/smoothBezier'); |
| var dashedLineTo = require('./util/dashedLineTo'); |
| var Polygon = function (options) { |
| Base.call(this, options); |
| }; |
| Polygon.prototype = { |
| type: 'polygon', |
| brush: function (ctx, isHighlight) { |
| var style = this.style; |
| if (isHighlight) { |
| style = this.getHighlightStyle(style, this.highlightStyle || {}); |
| } |
| ctx.save(); |
| this.setContext(ctx, style); |
| this.setTransform(ctx); |
| var hasPath = false; |
| if (style.brushType == 'fill' || style.brushType == 'both' || typeof style.brushType == 'undefined') { |
| ctx.beginPath(); |
| if (style.lineType == 'dashed' || style.lineType == 'dotted') { |
| this.buildPath(ctx, { |
| lineType: 'solid', |
| lineWidth: style.lineWidth, |
| pointList: style.pointList |
| }); |
| hasPath = false; |
| } else { |
| this.buildPath(ctx, style); |
| hasPath = true; |
| } |
| ctx.closePath(); |
| ctx.fill(); |
| } |
| if (style.lineWidth > 0 && (style.brushType == 'stroke' || style.brushType == 'both')) { |
| if (!hasPath) { |
| ctx.beginPath(); |
| this.buildPath(ctx, style); |
| } |
| ctx.stroke(); |
| } |
| this.drawText(ctx, style, this.style); |
| ctx.restore(); |
| return; |
| }, |
| buildPath: function (ctx, style) { |
| var pointList = style.pointList; |
| if (pointList.length < 2) { |
| return; |
| } |
| if (style.smooth && style.smooth !== 'spline') { |
| var controlPoints = smoothBezier(pointList, style.smooth, true, style.smoothConstraint); |
| ctx.moveTo(pointList[0][0], pointList[0][1]); |
| var cp1; |
| var cp2; |
| var p; |
| var len = pointList.length; |
| for (var i = 0; i < len; i++) { |
| cp1 = controlPoints[i * 2]; |
| cp2 = controlPoints[i * 2 + 1]; |
| p = pointList[(i + 1) % len]; |
| ctx.bezierCurveTo(cp1[0], cp1[1], cp2[0], cp2[1], p[0], p[1]); |
| } |
| } else { |
| if (style.smooth === 'spline') { |
| pointList = smoothSpline(pointList, true); |
| } |
| if (!style.lineType || style.lineType == 'solid') { |
| ctx.moveTo(pointList[0][0], pointList[0][1]); |
| for (var i = 1, l = pointList.length; i < l; i++) { |
| ctx.lineTo(pointList[i][0], pointList[i][1]); |
| } |
| ctx.lineTo(pointList[0][0], pointList[0][1]); |
| } else if (style.lineType == 'dashed' || style.lineType == 'dotted') { |
| var dashLength = style._dashLength || (style.lineWidth || 1) * (style.lineType == 'dashed' ? 5 : 1); |
| style._dashLength = dashLength; |
| ctx.moveTo(pointList[0][0], pointList[0][1]); |
| for (var i = 1, l = pointList.length; i < l; i++) { |
| dashedLineTo(ctx, pointList[i - 1][0], pointList[i - 1][1], pointList[i][0], pointList[i][1], dashLength); |
| } |
| dashedLineTo(ctx, pointList[pointList.length - 1][0], pointList[pointList.length - 1][1], pointList[0][0], pointList[0][1], dashLength); |
| } |
| } |
| return; |
| }, |
| getRect: function (style) { |
| if (style.__rect) { |
| return style.__rect; |
| } |
| var minX = Number.MAX_VALUE; |
| var maxX = Number.MIN_VALUE; |
| var minY = Number.MAX_VALUE; |
| var maxY = Number.MIN_VALUE; |
| var pointList = style.pointList; |
| for (var i = 0, l = pointList.length; i < l; i++) { |
| if (pointList[i][0] < minX) { |
| minX = pointList[i][0]; |
| } |
| if (pointList[i][0] > maxX) { |
| maxX = pointList[i][0]; |
| } |
| if (pointList[i][1] < minY) { |
| minY = pointList[i][1]; |
| } |
| if (pointList[i][1] > maxY) { |
| maxY = pointList[i][1]; |
| } |
| } |
| var lineWidth; |
| if (style.brushType == 'stroke' || style.brushType == 'fill') { |
| lineWidth = style.lineWidth || 1; |
| } else { |
| lineWidth = 0; |
| } |
| style.__rect = { |
| x: Math.round(minX - lineWidth / 2), |
| y: Math.round(minY - lineWidth / 2), |
| width: maxX - minX + lineWidth, |
| height: maxY - minY + lineWidth |
| }; |
| return style.__rect; |
| } |
| }; |
| require('../tool/util').inherits(Polygon, Base); |
| return Polygon; |
| });define('echarts/util/shape/normalIsCover', [], function () { |
| return function (x, y) { |
| var originPos = this.getTansform(x, y); |
| x = originPos[0]; |
| y = originPos[1]; |
| var rect = this.style.__rect; |
| if (!rect) { |
| rect = this.style.__rect = this.getRect(this.style); |
| } |
| return x >= rect.x && x <= rect.x + rect.width && y >= rect.y && y <= rect.y + rect.height; |
| }; |
| });define('echarts/component/dataView', [ |
| 'require', |
| './base', |
| '../config', |
| 'zrender/tool/util', |
| '../component' |
| ], function (require) { |
| var Base = require('./base'); |
| var ecConfig = require('../config'); |
| var zrUtil = require('zrender/tool/util'); |
| function DataView(ecTheme, messageCenter, zr, option, myChart) { |
| Base.call(this, ecTheme, messageCenter, zr, option, myChart); |
| this.dom = myChart.dom; |
| this._tDom = document.createElement('div'); |
| this._textArea = document.createElement('textArea'); |
| this._buttonRefresh = document.createElement('button'); |
| this._buttonClose = document.createElement('button'); |
| this._hasShow = false; |
| this._zrHeight = zr.getHeight(); |
| this._zrWidth = zr.getWidth(); |
| this._tDom.className = 'echarts-dataview', this.hide(); |
| this.dom.firstChild.appendChild(this._tDom); |
| if (window.addEventListener) { |
| this._tDom.addEventListener('click', this._stop); |
| this._tDom.addEventListener('mousewheel', this._stop); |
| this._tDom.addEventListener('mousemove', this._stop); |
| this._tDom.addEventListener('mousedown', this._stop); |
| this._tDom.addEventListener('mouseup', this._stop); |
| this._tDom.addEventListener('touchstart', this._stop); |
| this._tDom.addEventListener('touchmove', this._stop); |
| this._tDom.addEventListener('touchend', this._stop); |
| } else { |
| this._tDom.attachEvent('onclick', this._stop); |
| this._tDom.attachEvent('onmousewheel', this._stop); |
| this._tDom.attachEvent('onmousemove', this._stop); |
| this._tDom.attachEvent('onmousedown', this._stop); |
| this._tDom.attachEvent('onmouseup', this._stop); |
| } |
| } |
| DataView.prototype = { |
| type: ecConfig.COMPONENT_TYPE_DATAVIEW, |
| _lang: [ |
| 'Data View', |
| 'close', |
| 'refresh' |
| ], |
| _gCssText: 'position:absolute;' + 'display:block;' + 'overflow:hidden;' + 'transition:height 0.8s,background-color 1s;' + '-moz-transition:height 0.8s,background-color 1s;' + '-webkit-transition:height 0.8s,background-color 1s;' + '-o-transition:height 0.8s,background-color 1s;' + 'z-index:1;' + 'left:0;' + 'top:0;', |
| hide: function () { |
| this._sizeCssText = 'width:' + this._zrWidth + 'px;' + 'height:' + 0 + 'px;' + 'background-color:#f0ffff;'; |
| this._tDom.style.cssText = this._gCssText + this._sizeCssText; |
| }, |
| show: function (newOption) { |
| this._hasShow = true; |
| var lang = this.query(this.option, 'toolbox.feature.dataView.lang') || this._lang; |
| this.option = newOption; |
| this._tDom.innerHTML = '<p style="padding:8px 0;margin:0 0 10px 0;' + 'border-bottom:1px solid #eee">' + (lang[0] || this._lang[0]) + '</p>'; |
| this._textArea.style.cssText = 'display:block;margin:0 0 8px 0;padding:4px 6px;overflow:auto;' + 'width:' + (this._zrWidth - 15) + 'px;' + 'height:' + (this._zrHeight - 100) + 'px;'; |
| var customContent = this.query(this.option, 'toolbox.feature.dataView.optionToContent'); |
| if (typeof customContent != 'function') { |
| this._textArea.value = this._optionToContent(); |
| } else { |
| this._textArea.value = customContent(this.option); |
| } |
| this._tDom.appendChild(this._textArea); |
| this._buttonClose.style.cssText = 'float:right;padding:1px 6px;'; |
| this._buttonClose.innerHTML = lang[1] || this._lang[1]; |
| var self = this; |
| this._buttonClose.onclick = function () { |
| self.hide(); |
| }; |
| this._tDom.appendChild(this._buttonClose); |
| if (this.query(this.option, 'toolbox.feature.dataView.readOnly') === false) { |
| this._buttonRefresh.style.cssText = 'float:right;margin-right:10px;padding:1px 6px;'; |
| this._buttonRefresh.innerHTML = lang[2] || this._lang[2]; |
| this._buttonRefresh.onclick = function () { |
| self._save(); |
| }; |
| this._tDom.appendChild(this._buttonRefresh); |
| this._textArea.readOnly = false; |
| this._textArea.style.cursor = 'default'; |
| } else { |
| this._textArea.readOnly = true; |
| this._textArea.style.cursor = 'text'; |
| } |
| this._sizeCssText = 'width:' + this._zrWidth + 'px;' + 'height:' + this._zrHeight + 'px;' + 'background-color:#fff;'; |
| this._tDom.style.cssText = this._gCssText + this._sizeCssText; |
| }, |
| _optionToContent: function () { |
| var i; |
| var j; |
| var k; |
| var len; |
| var data; |
| var valueList; |
| var axisList = []; |
| var content = ''; |
| if (this.option.xAxis) { |
| if (this.option.xAxis instanceof Array) { |
| axisList = this.option.xAxis; |
| } else { |
| axisList = [this.option.xAxis]; |
| } |
| for (i = 0, len = axisList.length; i < len; i++) { |
| if ((axisList[i].type || 'category') == 'category') { |
| valueList = []; |
| for (j = 0, k = axisList[i].data.length; j < k; j++) { |
| data = axisList[i].data[j]; |
| valueList.push(typeof data.value != 'undefined' ? data.value : data); |
| } |
| content += valueList.join(', ') + '\n\n'; |
| } |
| } |
| } |
| if (this.option.yAxis) { |
| if (this.option.yAxis instanceof Array) { |
| axisList = this.option.yAxis; |
| } else { |
| axisList = [this.option.yAxis]; |
| } |
| for (i = 0, len = axisList.length; i < len; i++) { |
| if (axisList[i].type == 'category') { |
| valueList = []; |
| for (j = 0, k = axisList[i].data.length; j < k; j++) { |
| data = axisList[i].data[j]; |
| valueList.push(typeof data.value != 'undefined' ? data.value : data); |
| } |
| content += valueList.join(', ') + '\n\n'; |
| } |
| } |
| } |
| var series = this.option.series; |
| var itemName; |
| for (i = 0, len = series.length; i < len; i++) { |
| valueList = []; |
| for (j = 0, k = series[i].data.length; j < k; j++) { |
| data = series[i].data[j]; |
| if (series[i].type == ecConfig.CHART_TYPE_PIE || series[i].type == ecConfig.CHART_TYPE_MAP) { |
| itemName = (data.name || '-') + ':'; |
| } else { |
| itemName = ''; |
| } |
| if (series[i].type == ecConfig.CHART_TYPE_SCATTER) { |
| data = typeof data.value != 'undefined' ? data.value : data; |
| data = data.join(', '); |
| } |
| valueList.push(itemName + (typeof data.value != 'undefined' ? data.value : data)); |
| } |
| content += (series[i].name || '-') + ' : \n'; |
| content += valueList.join(series[i].type == ecConfig.CHART_TYPE_SCATTER ? '\n' : ', '); |
| content += '\n\n'; |
| } |
| return content; |
| }, |
| _save: function () { |
| var text = this._textArea.value; |
| var customContent = this.query(this.option, 'toolbox.feature.dataView.contentToOption'); |
| if (typeof customContent != 'function') { |
| text = text.split('\n'); |
| var content = []; |
| for (var i = 0, l = text.length; i < l; i++) { |
| text[i] = this._trim(text[i]); |
| if (text[i] !== '') { |
| content.push(text[i]); |
| } |
| } |
| this._contentToOption(content); |
| } else { |
| customContent(text, this.option); |
| } |
| this.hide(); |
| var self = this; |
| setTimeout(function () { |
| self.messageCenter && self.messageCenter.dispatch(ecConfig.EVENT.DATA_VIEW_CHANGED, null, { option: self.option }, self.myChart); |
| }, self.canvasSupported ? 800 : 100); |
| }, |
| _contentToOption: function (content) { |
| var i; |
| var j; |
| var k; |
| var len; |
| var data; |
| var axisList = []; |
| var contentIdx = 0; |
| var contentValueList; |
| var value; |
| if (this.option.xAxis) { |
| if (this.option.xAxis instanceof Array) { |
| axisList = this.option.xAxis; |
| } else { |
| axisList = [this.option.xAxis]; |
| } |
| for (i = 0, len = axisList.length; i < len; i++) { |
| if ((axisList[i].type || 'category') == 'category') { |
| contentValueList = content[contentIdx].split(','); |
| for (j = 0, k = axisList[i].data.length; j < k; j++) { |
| value = this._trim(contentValueList[j] || ''); |
| data = axisList[i].data[j]; |
| if (typeof axisList[i].data[j].value != 'undefined') { |
| axisList[i].data[j].value = value; |
| } else { |
| axisList[i].data[j] = value; |
| } |
| } |
| contentIdx++; |
| } |
| } |
| } |
| if (this.option.yAxis) { |
| if (this.option.yAxis instanceof Array) { |
| axisList = this.option.yAxis; |
| } else { |
| axisList = [this.option.yAxis]; |
| } |
| for (i = 0, len = axisList.length; i < len; i++) { |
| if (axisList[i].type == 'category') { |
| contentValueList = content[contentIdx].split(','); |
| for (j = 0, k = axisList[i].data.length; j < k; j++) { |
| value = this._trim(contentValueList[j] || ''); |
| data = axisList[i].data[j]; |
| if (typeof axisList[i].data[j].value != 'undefined') { |
| axisList[i].data[j].value = value; |
| } else { |
| axisList[i].data[j] = value; |
| } |
| } |
| contentIdx++; |
| } |
| } |
| } |
| var series = this.option.series; |
| for (i = 0, len = series.length; i < len; i++) { |
| contentIdx++; |
| if (series[i].type == ecConfig.CHART_TYPE_SCATTER) { |
| for (var j = 0, k = series[i].data.length; j < k; j++) { |
| contentValueList = content[contentIdx]; |
| value = contentValueList.replace(' ', '').split(','); |
| if (typeof series[i].data[j].value != 'undefined') { |
| series[i].data[j].value = value; |
| } else { |
| series[i].data[j] = value; |
| } |
| contentIdx++; |
| } |
| } else { |
| contentValueList = content[contentIdx].split(','); |
| for (var j = 0, k = series[i].data.length; j < k; j++) { |
| value = (contentValueList[j] || '').replace(/.*:/, ''); |
| value = this._trim(value); |
| value = value != '-' && value !== '' ? value - 0 : '-'; |
| if (typeof series[i].data[j].value != 'undefined') { |
| series[i].data[j].value = value; |
| } else { |
| series[i].data[j] = value; |
| } |
| } |
| contentIdx++; |
| } |
| } |
| }, |
| _trim: function (str) { |
| var trimer = new RegExp('(^[\\s\\t\\xa0\\u3000]+)|([\\u3000\\xa0\\s\\t]+$)', 'g'); |
| return str.replace(trimer, ''); |
| }, |
| _stop: function (e) { |
| e = e || window.event; |
| if (e.stopPropagation) { |
| e.stopPropagation(); |
| } else { |
| e.cancelBubble = true; |
| } |
| }, |
| resize: function () { |
| this._zrHeight = this.zr.getHeight(); |
| this._zrWidth = this.zr.getWidth(); |
| if (this._tDom.offsetHeight > 10) { |
| this._sizeCssText = 'width:' + this._zrWidth + 'px;' + 'height:' + this._zrHeight + 'px;' + 'background-color:#fff;'; |
| this._tDom.style.cssText = this._gCssText + this._sizeCssText; |
| this._textArea.style.cssText = 'display:block;margin:0 0 8px 0;' + 'padding:4px 6px;overflow:auto;' + 'width:' + (this._zrWidth - 15) + 'px;' + 'height:' + (this._zrHeight - 100) + 'px;'; |
| } |
| }, |
| dispose: function () { |
| if (window.removeEventListener) { |
| this._tDom.removeEventListener('click', this._stop); |
| this._tDom.removeEventListener('mousewheel', this._stop); |
| this._tDom.removeEventListener('mousemove', this._stop); |
| this._tDom.removeEventListener('mousedown', this._stop); |
| this._tDom.removeEventListener('mouseup', this._stop); |
| this._tDom.removeEventListener('touchstart', this._stop); |
| this._tDom.removeEventListener('touchmove', this._stop); |
| this._tDom.removeEventListener('touchend', this._stop); |
| } else { |
| this._tDom.detachEvent('onclick', this._stop); |
| this._tDom.detachEvent('onmousewheel', this._stop); |
| this._tDom.detachEvent('onmousemove', this._stop); |
| this._tDom.detachEvent('onmousedown', this._stop); |
| this._tDom.detachEvent('onmouseup', this._stop); |
| } |
| this._buttonRefresh.onclick = null; |
| this._buttonClose.onclick = null; |
| if (this._hasShow) { |
| this._tDom.removeChild(this._textArea); |
| this._tDom.removeChild(this._buttonRefresh); |
| this._tDom.removeChild(this._buttonClose); |
| } |
| this._textArea = null; |
| this._buttonRefresh = null; |
| this._buttonClose = null; |
| this.dom.firstChild.removeChild(this._tDom); |
| this._tDom = null; |
| } |
| }; |
| zrUtil.inherits(DataView, Base); |
| require('../component').define('dataView', DataView); |
| return DataView; |
| });define('echarts/util/shape/Cross', [ |
| 'require', |
| 'zrender/shape/Base', |
| 'zrender/shape/Line', |
| 'zrender/tool/util', |
| './normalIsCover' |
| ], function (require) { |
| var Base = require('zrender/shape/Base'); |
| var LineShape = require('zrender/shape/Line'); |
| var zrUtil = require('zrender/tool/util'); |
| function Cross(options) { |
| Base.call(this, options); |
| } |
| Cross.prototype = { |
| type: 'cross', |
| buildPath: function (ctx, style) { |
| var rect = style.rect; |
| style.xStart = rect.x; |
| style.xEnd = rect.x + rect.width; |
| style.yStart = style.yEnd = style.y; |
| LineShape.prototype.buildPath(ctx, style); |
| style.xStart = style.xEnd = style.x; |
| style.yStart = rect.y; |
| style.yEnd = rect.y + rect.height; |
| LineShape.prototype.buildPath(ctx, style); |
| }, |
| getRect: function (style) { |
| return style.rect; |
| }, |
| isCover: require('./normalIsCover') |
| }; |
| zrUtil.inherits(Cross, Base); |
| return Cross; |
| });define('zrender/shape/Sector', [ |
| 'require', |
| '../tool/math', |
| '../tool/computeBoundingBox', |
| '../tool/vector', |
| './Base', |
| '../tool/util' |
| ], function (require) { |
| var math = require('../tool/math'); |
| var computeBoundingBox = require('../tool/computeBoundingBox'); |
| var vec2 = require('../tool/vector'); |
| var Base = require('./Base'); |
| var min0 = vec2.create(); |
| var min1 = vec2.create(); |
| var max0 = vec2.create(); |
| var max1 = vec2.create(); |
| var Sector = function (options) { |
| Base.call(this, options); |
| }; |
| Sector.prototype = { |
| type: 'sector', |
| buildPath: function (ctx, style) { |
| var x = style.x; |
| var y = style.y; |
| var r0 = style.r0 || 0; |
| var r = style.r; |
| var startAngle = style.startAngle; |
| var endAngle = style.endAngle; |
| var clockWise = style.clockWise || false; |
| startAngle = math.degreeToRadian(startAngle); |
| endAngle = math.degreeToRadian(endAngle); |
| if (!clockWise) { |
| startAngle = -startAngle; |
| endAngle = -endAngle; |
| } |
| var unitX = math.cos(startAngle); |
| var unitY = math.sin(startAngle); |
| ctx.moveTo(unitX * r0 + x, unitY * r0 + y); |
| ctx.lineTo(unitX * r + x, unitY * r + y); |
| ctx.arc(x, y, r, startAngle, endAngle, !clockWise); |
| ctx.lineTo(math.cos(endAngle) * r0 + x, math.sin(endAngle) * r0 + y); |
| if (r0 !== 0) { |
| ctx.arc(x, y, r0, endAngle, startAngle, clockWise); |
| } |
| ctx.closePath(); |
| return; |
| }, |
| getRect: function (style) { |
| if (style.__rect) { |
| return style.__rect; |
| } |
| var x = style.x; |
| var y = style.y; |
| var r0 = style.r0 || 0; |
| var r = style.r; |
| var startAngle = math.degreeToRadian(style.startAngle); |
| var endAngle = math.degreeToRadian(style.endAngle); |
| var clockWise = style.clockWise; |
| if (!clockWise) { |
| startAngle = -startAngle; |
| endAngle = -endAngle; |
| } |
| if (r0 > 1) { |
| computeBoundingBox.arc(x, y, r0, startAngle, endAngle, !clockWise, min0, max0); |
| } else { |
| min0[0] = max0[0] = x; |
| min0[1] = max0[1] = y; |
| } |
| computeBoundingBox.arc(x, y, r, startAngle, endAngle, !clockWise, min1, max1); |
| vec2.min(min0, min0, min1); |
| vec2.max(max0, max0, max1); |
| style.__rect = { |
| x: min0[0], |
| y: min0[1], |
| width: max0[0] - min0[0], |
| height: max0[1] - min0[1] |
| }; |
| return style.__rect; |
| } |
| }; |
| require('../tool/util').inherits(Sector, Base); |
| return Sector; |
| });define('echarts/util/shape/Candle', [ |
| 'require', |
| 'zrender/shape/Base', |
| 'zrender/tool/util', |
| './normalIsCover' |
| ], function (require) { |
| var Base = require('zrender/shape/Base'); |
| var zrUtil = require('zrender/tool/util'); |
| function Candle(options) { |
| Base.call(this, options); |
| } |
| Candle.prototype = { |
| type: 'candle', |
| _numberOrder: function (a, b) { |
| return b - a; |
| }, |
| buildPath: function (ctx, style) { |
| var yList = zrUtil.clone(style.y).sort(this._numberOrder); |
| ctx.moveTo(style.x, yList[3]); |
| ctx.lineTo(style.x, yList[2]); |
| ctx.moveTo(style.x - style.width / 2, yList[2]); |
| ctx.rect(style.x - style.width / 2, yList[2], style.width, yList[1] - yList[2]); |
| ctx.moveTo(style.x, yList[1]); |
| ctx.lineTo(style.x, yList[0]); |
| }, |
| getRect: function (style) { |
| if (!style.__rect) { |
| var lineWidth = 0; |
| if (style.brushType == 'stroke' || style.brushType == 'fill') { |
| lineWidth = style.lineWidth || 1; |
| } |
| var yList = zrUtil.clone(style.y).sort(this._numberOrder); |
| style.__rect = { |
| x: Math.round(style.x - style.width / 2 - lineWidth / 2), |
| y: Math.round(yList[3] - lineWidth / 2), |
| width: style.width + lineWidth, |
| height: yList[0] - yList[3] + lineWidth |
| }; |
| } |
| return style.__rect; |
| }, |
| isCover: require('./normalIsCover') |
| }; |
| zrUtil.inherits(Candle, Base); |
| return Candle; |
| });define('zrender/tool/computeBoundingBox', [ |
| 'require', |
| './vector', |
| './curve' |
| ], function (require) { |
| var vec2 = require('./vector'); |
| var curve = require('./curve'); |
| function computeBoundingBox(points, min, max) { |
| if (points.length === 0) { |
| return; |
| } |
| var left = points[0][0]; |
| var right = points[0][0]; |
| var top = points[0][1]; |
| var bottom = points[0][1]; |
| for (var i = 1; i < points.length; i++) { |
| var p = points[i]; |
| if (p[0] < left) { |
| left = p[0]; |
| } |
| if (p[0] > right) { |
| right = p[0]; |
| } |
| if (p[1] < top) { |
| top = p[1]; |
| } |
| if (p[1] > bottom) { |
| bottom = p[1]; |
| } |
| } |
| min[0] = left; |
| min[1] = top; |
| max[0] = right; |
| max[1] = bottom; |
| } |
| function computeCubeBezierBoundingBox(p0, p1, p2, p3, min, max) { |
| var xDim = []; |
| curve.cubicExtrema(p0[0], p1[0], p2[0], p3[0], xDim); |
| for (var i = 0; i < xDim.length; i++) { |
| xDim[i] = curve.cubicAt(p0[0], p1[0], p2[0], p3[0], xDim[i]); |
| } |
| var yDim = []; |
| curve.cubicExtrema(p0[1], p1[1], p2[1], p3[1], yDim); |
| for (var i = 0; i < yDim.length; i++) { |
| yDim[i] = curve.cubicAt(p0[1], p1[1], p2[1], p3[1], yDim[i]); |
| } |
| xDim.push(p0[0], p3[0]); |
| yDim.push(p0[1], p3[1]); |
| var left = Math.min.apply(null, xDim); |
| var right = Math.max.apply(null, xDim); |
| var top = Math.min.apply(null, yDim); |
| var bottom = Math.max.apply(null, yDim); |
| min[0] = left; |
| min[1] = top; |
| max[0] = right; |
| max[1] = bottom; |
| } |
| function computeQuadraticBezierBoundingBox(p0, p1, p2, min, max) { |
| var t1 = curve.quadraticExtremum(p0[0], p1[0], p2[0]); |
| var t2 = curve.quadraticExtremum(p0[1], p1[1], p2[1]); |
| t1 = Math.max(Math.min(t1, 1), 0); |
| t2 = Math.max(Math.min(t2, 1), 0); |
| var ct1 = 1 - t1; |
| var ct2 = 1 - t2; |
| var x1 = ct1 * ct1 * p0[0] + 2 * ct1 * t1 * p1[0] + t1 * t1 * p2[0]; |
| var y1 = ct1 * ct1 * p0[1] + 2 * ct1 * t1 * p1[1] + t1 * t1 * p2[1]; |
| var x2 = ct2 * ct2 * p0[0] + 2 * ct2 * t2 * p1[0] + t2 * t2 * p2[0]; |
| var y2 = ct2 * ct2 * p0[1] + 2 * ct2 * t2 * p1[1] + t2 * t2 * p2[1]; |
| min[0] = Math.min(p0[0], p2[0], x1, x2); |
| min[1] = Math.min(p0[1], p2[1], y1, y2); |
| max[0] = Math.max(p0[0], p2[0], x1, x2); |
| max[1] = Math.max(p0[1], p2[1], y1, y2); |
| } |
| var start = vec2.create(); |
| var end = vec2.create(); |
| var extremity = vec2.create(); |
| var computeArcBoundingBox = function (x, y, r, startAngle, endAngle, anticlockwise, min, max) { |
| start[0] = Math.cos(startAngle) * r + x; |
| start[1] = Math.sin(startAngle) * r + y; |
| end[0] = Math.cos(endAngle) * r + x; |
| end[1] = Math.sin(endAngle) * r + y; |
| vec2.min(min, start, end); |
| vec2.max(max, start, end); |
| startAngle = startAngle % (Math.PI * 2); |
| if (startAngle < 0) { |
| startAngle = startAngle + Math.PI * 2; |
| } |
| endAngle = endAngle % (Math.PI * 2); |
| if (endAngle < 0) { |
| endAngle = endAngle + Math.PI * 2; |
| } |
| if (startAngle > endAngle && !anticlockwise) { |
| endAngle += Math.PI * 2; |
| } else if (startAngle < endAngle && anticlockwise) { |
| startAngle += Math.PI * 2; |
| } |
| if (anticlockwise) { |
| var tmp = endAngle; |
| endAngle = startAngle; |
| startAngle = tmp; |
| } |
| for (var angle = 0; angle < endAngle; angle += Math.PI / 2) { |
| if (angle > startAngle) { |
| extremity[0] = Math.cos(angle) * r + x; |
| extremity[1] = Math.sin(angle) * r + y; |
| vec2.min(min, extremity, min); |
| vec2.max(max, extremity, max); |
| } |
| } |
| }; |
| computeBoundingBox.cubeBezier = computeCubeBezierBoundingBox; |
| computeBoundingBox.quadraticBezier = computeQuadraticBezierBoundingBox; |
| computeBoundingBox.arc = computeArcBoundingBox; |
| return computeBoundingBox; |
| });define('echarts/util/shape/Chain', [ |
| 'require', |
| 'zrender/shape/Base', |
| './Icon', |
| 'zrender/shape/util/dashedLineTo', |
| 'zrender/tool/util', |
| 'zrender/tool/matrix' |
| ], function (require) { |
| var Base = require('zrender/shape/Base'); |
| var IconShape = require('./Icon'); |
| var dashedLineTo = require('zrender/shape/util/dashedLineTo'); |
| var zrUtil = require('zrender/tool/util'); |
| var matrix = require('zrender/tool/matrix'); |
| function Chain(options) { |
| Base.call(this, options); |
| } |
| Chain.prototype = { |
| type: 'chain', |
| brush: function (ctx, isHighlight) { |
| var style = this.style; |
| if (isHighlight) { |
| style = this.getHighlightStyle(style, this.highlightStyle || {}); |
| } |
| ctx.save(); |
| this.setContext(ctx, style); |
| this.setTransform(ctx); |
| ctx.save(); |
| ctx.beginPath(); |
| this.buildLinePath(ctx, style); |
| ctx.stroke(); |
| ctx.restore(); |
| this.brushSymbol(ctx, style); |
| ctx.restore(); |
| return; |
| }, |
| buildLinePath: function (ctx, style) { |
| var x = style.x; |
| var y = style.y + 5; |
| var width = style.width; |
| var height = style.height / 2 - 10; |
| ctx.moveTo(x, y); |
| ctx.lineTo(x, y + height); |
| ctx.moveTo(x + width, y); |
| ctx.lineTo(x + width, y + height); |
| ctx.moveTo(x, y + height / 2); |
| if (!style.lineType || style.lineType == 'solid') { |
| ctx.lineTo(x + width, y + height / 2); |
| } else if (style.lineType == 'dashed' || style.lineType == 'dotted') { |
| var dashLength = (style.lineWidth || 1) * (style.lineType == 'dashed' ? 5 : 1); |
| dashedLineTo(ctx, x, y + height / 2, x + width, y + height / 2, dashLength); |
| } |
| }, |
| brushSymbol: function (ctx, style) { |
| var y = style.y + style.height / 4; |
| ctx.save(); |
| var chainPoint = style.chainPoint; |
| var curPoint; |
| for (var idx = 0, l = chainPoint.length; idx < l; idx++) { |
| curPoint = chainPoint[idx]; |
| if (curPoint.symbol != 'none') { |
| ctx.beginPath(); |
| var symbolSize = curPoint.symbolSize; |
| IconShape.prototype.buildPath(ctx, { |
| iconType: curPoint.symbol, |
| x: curPoint.x - symbolSize, |
| y: y - symbolSize, |
| width: symbolSize * 2, |
| height: symbolSize * 2, |
| n: curPoint.n |
| }); |
| ctx.fillStyle = curPoint.isEmpty ? '#fff' : style.strokeColor; |
| ctx.closePath(); |
| ctx.fill(); |
| ctx.stroke(); |
| } |
| if (curPoint.showLabel) { |
| ctx.font = curPoint.textFont; |
| ctx.fillStyle = curPoint.textColor; |
| ctx.textAlign = curPoint.textAlign; |
| ctx.textBaseline = curPoint.textBaseline; |
| if (curPoint.rotation) { |
| ctx.save(); |
| this._updateTextTransform(ctx, curPoint.rotation); |
| ctx.fillText(curPoint.name, curPoint.textX, curPoint.textY); |
| ctx.restore(); |
| } else { |
| ctx.fillText(curPoint.name, curPoint.textX, curPoint.textY); |
| } |
| } |
| } |
| ctx.restore(); |
| }, |
| _updateTextTransform: function (ctx, rotation) { |
| var _transform = matrix.create(); |
| matrix.identity(_transform); |
| if (rotation[0] !== 0) { |
| var originX = rotation[1] || 0; |
| var originY = rotation[2] || 0; |
| if (originX || originY) { |
| matrix.translate(_transform, _transform, [ |
| -originX, |
| -originY |
| ]); |
| } |
| matrix.rotate(_transform, _transform, rotation[0]); |
| if (originX || originY) { |
| matrix.translate(_transform, _transform, [ |
| originX, |
| originY |
| ]); |
| } |
| } |
| ctx.transform.apply(ctx, _transform); |
| }, |
| isCover: function (x, y) { |
| var rect = this.style; |
| if (x >= rect.x && x <= rect.x + rect.width && y >= rect.y && y <= rect.y + rect.height) { |
| return true; |
| } else { |
| return false; |
| } |
| } |
| }; |
| zrUtil.inherits(Chain, Base); |
| return Chain; |
| });define('zrender/shape/Ring', [ |
| 'require', |
| './Base', |
| '../tool/util' |
| ], function (require) { |
| var Base = require('./Base'); |
| var Ring = function (options) { |
| Base.call(this, options); |
| }; |
| Ring.prototype = { |
| type: 'ring', |
| buildPath: function (ctx, style) { |
| ctx.arc(style.x, style.y, style.r, 0, Math.PI * 2, false); |
| ctx.moveTo(style.x + style.r0, style.y); |
| ctx.arc(style.x, style.y, style.r0, 0, Math.PI * 2, true); |
| return; |
| }, |
| getRect: function (style) { |
| if (style.__rect) { |
| return style.__rect; |
| } |
| var lineWidth; |
| if (style.brushType == 'stroke' || style.brushType == 'fill') { |
| lineWidth = style.lineWidth || 1; |
| } else { |
| lineWidth = 0; |
| } |
| style.__rect = { |
| x: Math.round(style.x - style.r - lineWidth / 2), |
| y: Math.round(style.y - style.r - lineWidth / 2), |
| width: style.r * 2 + lineWidth, |
| height: style.r * 2 + lineWidth |
| }; |
| return style.__rect; |
| } |
| }; |
| require('../tool/util').inherits(Ring, Base); |
| return Ring; |
| });define('echarts/component/axis', [ |
| 'require', |
| './base', |
| 'zrender/shape/Line', |
| '../config', |
| '../util/ecData', |
| 'zrender/tool/util', |
| 'zrender/tool/color', |
| './categoryAxis', |
| './valueAxis', |
| '../component' |
| ], function (require) { |
| var Base = require('./base'); |
| var LineShape = require('zrender/shape/Line'); |
| var ecConfig = require('../config'); |
| var ecData = require('../util/ecData'); |
| var zrUtil = require('zrender/tool/util'); |
| var zrColor = require('zrender/tool/color'); |
| function Axis(ecTheme, messageCenter, zr, option, myChart, axisType) { |
| Base.call(this, ecTheme, messageCenter, zr, option, myChart); |
| this.axisType = axisType; |
| this._axisList = []; |
| this.refresh(option); |
| } |
| Axis.prototype = { |
| type: ecConfig.COMPONENT_TYPE_AXIS, |
| axisBase: { |
| _buildAxisLine: function () { |
| var lineWidth = this.option.axisLine.lineStyle.width; |
| var halfLineWidth = lineWidth / 2; |
| var axShape = { |
| _axisShape: 'axisLine', |
| zlevel: this._zlevelBase + 1, |
| hoverable: false |
| }; |
| switch (this.option.position) { |
| case 'left': |
| axShape.style = { |
| xStart: this.grid.getX() - halfLineWidth, |
| yStart: this.grid.getYend(), |
| xEnd: this.grid.getX() - halfLineWidth, |
| yEnd: this.grid.getY(), |
| lineCap: 'round' |
| }; |
| break; |
| case 'right': |
| axShape.style = { |
| xStart: this.grid.getXend() + halfLineWidth, |
| yStart: this.grid.getYend(), |
| xEnd: this.grid.getXend() + halfLineWidth, |
| yEnd: this.grid.getY(), |
| lineCap: 'round' |
| }; |
| break; |
| case 'bottom': |
| axShape.style = { |
| xStart: this.grid.getX(), |
| yStart: this.grid.getYend() + halfLineWidth, |
| xEnd: this.grid.getXend(), |
| yEnd: this.grid.getYend() + halfLineWidth, |
| lineCap: 'round' |
| }; |
| break; |
| case 'top': |
| axShape.style = { |
| xStart: this.grid.getX(), |
| yStart: this.grid.getY() - halfLineWidth, |
| xEnd: this.grid.getXend(), |
| yEnd: this.grid.getY() - halfLineWidth, |
| lineCap: 'round' |
| }; |
| break; |
| } |
| if (this.option.name !== '') { |
| axShape.style.text = this.option.name; |
| axShape.style.textPosition = this.option.nameLocation; |
| axShape.style.textFont = this.getFont(this.option.nameTextStyle); |
| if (this.option.nameTextStyle.align) { |
| axShape.style.textAlign = this.option.nameTextStyle.align; |
| } |
| if (this.option.nameTextStyle.baseline) { |
| axShape.style.textBaseline = this.option.nameTextStyle.baseline; |
| } |
| if (this.option.nameTextStyle.color) { |
| axShape.style.textColor = this.option.nameTextStyle.color; |
| } |
| } |
| axShape.style.strokeColor = this.option.axisLine.lineStyle.color; |
| axShape.style.lineWidth = lineWidth; |
| if (this.isHorizontal()) { |
| axShape.style.yStart = axShape.style.yEnd = this.subPixelOptimize(axShape.style.yEnd, lineWidth); |
| } else { |
| axShape.style.xStart = axShape.style.xEnd = this.subPixelOptimize(axShape.style.xEnd, lineWidth); |
| } |
| axShape.style.lineType = this.option.axisLine.lineStyle.type; |
| axShape = new LineShape(axShape); |
| this.shapeList.push(axShape); |
| }, |
| _axisLabelClickable: function (clickable, axShape) { |
| if (clickable) { |
| ecData.pack(axShape, undefined, -1, undefined, -1, axShape.style.text); |
| axShape.hoverable = true; |
| axShape.clickable = true; |
| axShape.highlightStyle = { |
| color: zrColor.lift(axShape.style.color, 1), |
| brushType: 'fill' |
| }; |
| return axShape; |
| } else { |
| return axShape; |
| } |
| }, |
| refixAxisShape: function (zeroX, zeroY) { |
| if (!this.option.axisLine.onZero) { |
| return; |
| } |
| var tickLength; |
| if (this.isHorizontal() && zeroY != null) { |
| for (var i = 0, l = this.shapeList.length; i < l; i++) { |
| if (this.shapeList[i]._axisShape === 'axisLine') { |
| this.shapeList[i].style.yStart = this.shapeList[i].style.yEnd = this.subPixelOptimize(zeroY, this.shapeList[i].stylelineWidth); |
| this.zr.modShape(this.shapeList[i].id); |
| } else if (this.shapeList[i]._axisShape === 'axisTick') { |
| tickLength = this.shapeList[i].style.yEnd - this.shapeList[i].style.yStart; |
| this.shapeList[i].style.yStart = zeroY - tickLength; |
| this.shapeList[i].style.yEnd = zeroY; |
| this.zr.modShape(this.shapeList[i].id); |
| } |
| } |
| } |
| if (!this.isHorizontal() && zeroX != null) { |
| for (var i = 0, l = this.shapeList.length; i < l; i++) { |
| if (this.shapeList[i]._axisShape === 'axisLine') { |
| this.shapeList[i].style.xStart = this.shapeList[i].style.xEnd = this.subPixelOptimize(zeroX, this.shapeList[i].stylelineWidth); |
| this.zr.modShape(this.shapeList[i].id); |
| } else if (this.shapeList[i]._axisShape === 'axisTick') { |
| tickLength = this.shapeList[i].style.xEnd - this.shapeList[i].style.xStart; |
| this.shapeList[i].style.xStart = zeroX; |
| this.shapeList[i].style.xEnd = zeroX + tickLength; |
| this.zr.modShape(this.shapeList[i].id); |
| } |
| } |
| } |
| }, |
| getPosition: function () { |
| return this.option.position; |
| }, |
| isHorizontal: function () { |
| return this.option.position === 'bottom' || this.option.position === 'top'; |
| } |
| }, |
| reformOption: function (opt) { |
| if (!opt || opt instanceof Array && opt.length === 0) { |
| opt = [{ type: ecConfig.COMPONENT_TYPE_AXIS_VALUE }]; |
| } else if (!(opt instanceof Array)) { |
| opt = [opt]; |
| } |
| if (opt.length > 2) { |
| opt = [ |
| opt[0], |
| opt[1] |
| ]; |
| } |
| if (this.axisType === 'xAxis') { |
| if (!opt[0].position || opt[0].position != 'bottom' && opt[0].position != 'top') { |
| opt[0].position = 'bottom'; |
| } |
| if (opt.length > 1) { |
| opt[1].position = opt[0].position === 'bottom' ? 'top' : 'bottom'; |
| } |
| for (var i = 0, l = opt.length; i < l; i++) { |
| opt[i].type = opt[i].type || 'category'; |
| opt[i].xAxisIndex = i; |
| opt[i].yAxisIndex = -1; |
| } |
| } else { |
| if (!opt[0].position || opt[0].position != 'left' && opt[0].position != 'right') { |
| opt[0].position = 'left'; |
| } |
| if (opt.length > 1) { |
| opt[1].position = opt[0].position === 'left' ? 'right' : 'left'; |
| } |
| for (var i = 0, l = opt.length; i < l; i++) { |
| opt[i].type = opt[i].type || 'value'; |
| opt[i].xAxisIndex = -1; |
| opt[i].yAxisIndex = i; |
| } |
| } |
| return opt; |
| }, |
| refresh: function (newOption) { |
| var axisOption; |
| if (newOption) { |
| this.option = newOption; |
| if (this.axisType === 'xAxis') { |
| this.option.xAxis = this.reformOption(newOption.xAxis); |
| axisOption = this.option.xAxis; |
| } else { |
| this.option.yAxis = this.reformOption(newOption.yAxis); |
| axisOption = this.option.yAxis; |
| } |
| this.series = newOption.series; |
| } |
| var CategoryAxis = require('./categoryAxis'); |
| var ValueAxis = require('./valueAxis'); |
| var len = Math.max(axisOption && axisOption.length || 0, this._axisList.length); |
| for (var i = 0; i < len; i++) { |
| if (this._axisList[i] && newOption && (!axisOption[i] || this._axisList[i].type != axisOption[i].type)) { |
| this._axisList[i].dispose && this._axisList[i].dispose(); |
| this._axisList[i] = false; |
| } |
| if (this._axisList[i]) { |
| this._axisList[i].refresh && this._axisList[i].refresh(axisOption ? axisOption[i] : false, this.series); |
| } else if (axisOption && axisOption[i]) { |
| this._axisList[i] = axisOption[i].type === 'category' ? new CategoryAxis(this.ecTheme, this.messageCenter, this.zr, axisOption[i], this.myChart, this.axisBase) : new ValueAxis(this.ecTheme, this.messageCenter, this.zr, axisOption[i], this.myChart, this.axisBase, this.series); |
| } |
| } |
| }, |
| getAxis: function (idx) { |
| return this._axisList[idx]; |
| }, |
| clear: function () { |
| for (var i = 0, l = this._axisList.length; i < l; i++) { |
| this._axisList[i].dispose && this._axisList[i].dispose(); |
| } |
| this._axisList = []; |
| } |
| }; |
| zrUtil.inherits(Axis, Base); |
| require('../component').define('axis', Axis); |
| return Axis; |
| });define('echarts/component/grid', [ |
| 'require', |
| './base', |
| 'zrender/shape/Rectangle', |
| '../config', |
| 'zrender/tool/util', |
| '../component' |
| ], function (require) { |
| var Base = require('./base'); |
| var RectangleShape = require('zrender/shape/Rectangle'); |
| var ecConfig = require('../config'); |
| var zrUtil = require('zrender/tool/util'); |
| function Grid(ecTheme, messageCenter, zr, option, myChart) { |
| Base.call(this, ecTheme, messageCenter, zr, option, myChart); |
| this.refresh(option); |
| } |
| Grid.prototype = { |
| type: ecConfig.COMPONENT_TYPE_GRID, |
| getX: function () { |
| return this._x; |
| }, |
| getY: function () { |
| return this._y; |
| }, |
| getWidth: function () { |
| return this._width; |
| }, |
| getHeight: function () { |
| return this._height; |
| }, |
| getXend: function () { |
| return this._x + this._width; |
| }, |
| getYend: function () { |
| return this._y + this._height; |
| }, |
| getArea: function () { |
| return { |
| x: this._x, |
| y: this._y, |
| width: this._width, |
| height: this._height |
| }; |
| }, |
| getBbox: function () { |
| return [ |
| [ |
| this._x, |
| this._y |
| ], |
| [ |
| this.getXend(), |
| this.getYend() |
| ] |
| ]; |
| }, |
| refixAxisShape: function (component) { |
| var zeroX; |
| var zeroY; |
| var axisList = component.xAxis._axisList.concat(component.yAxis ? component.yAxis._axisList : []); |
| var len = axisList.length; |
| var axis; |
| while (len--) { |
| axis = axisList[len]; |
| if (axis.type == ecConfig.COMPONENT_TYPE_AXIS_VALUE && axis._min < 0 && axis._max >= 0) { |
| axis.isHorizontal() ? zeroX = axis.getCoord(0) : zeroY = axis.getCoord(0); |
| } |
| } |
| if (typeof zeroX != 'undefined' || typeof zeroY != 'undefined') { |
| len = axisList.length; |
| while (len--) { |
| axisList[len].refixAxisShape(zeroX, zeroY); |
| } |
| } |
| }, |
| refresh: function (newOption) { |
| if (newOption || this._zrWidth != this.zr.getWidth() || this._zrHeight != this.zr.getHeight()) { |
| this.clear(); |
| this.option = newOption || this.option; |
| this.option.grid = this.reformOption(this.option.grid); |
| var gridOption = this.option.grid; |
| this._zrWidth = this.zr.getWidth(); |
| this._zrHeight = this.zr.getHeight(); |
| this._x = this.parsePercent(gridOption.x, this._zrWidth); |
| this._y = this.parsePercent(gridOption.y, this._zrHeight); |
| var x2 = this.parsePercent(gridOption.x2, this._zrWidth); |
| var y2 = this.parsePercent(gridOption.y2, this._zrHeight); |
| if (typeof gridOption.width == 'undefined') { |
| this._width = this._zrWidth - this._x - x2; |
| } else { |
| this._width = this.parsePercent(gridOption.width, this._zrWidth); |
| } |
| this._width = this._width <= 0 ? 10 : this._width; |
| if (typeof gridOption.height == 'undefined') { |
| this._height = this._zrHeight - this._y - y2; |
| } else { |
| this._height = this.parsePercent(gridOption.height, this._zrHeight); |
| } |
| this._height = this._height <= 0 ? 10 : this._height; |
| this._x = this.subPixelOptimize(this._x, gridOption.borderWidth); |
| this._y = this.subPixelOptimize(this._y, gridOption.borderWidth); |
| this.shapeList.push(new RectangleShape({ |
| zlevel: this._zlevelBase, |
| hoverable: false, |
| style: { |
| x: this._x, |
| y: this._y, |
| width: this._width, |
| height: this._height, |
| brushType: gridOption.borderWidth > 0 ? 'both' : 'fill', |
| color: gridOption.backgroundColor, |
| strokeColor: gridOption.borderColor, |
| lineWidth: gridOption.borderWidth |
| } |
| })); |
| this.zr.addShape(this.shapeList[0]); |
| } |
| } |
| }; |
| zrUtil.inherits(Grid, Base); |
| require('../component').define('grid', Grid); |
| return Grid; |
| });define('echarts/component/dataZoom', [ |
| 'require', |
| './base', |
| 'zrender/shape/Rectangle', |
| 'zrender/shape/Polygon', |
| '../util/shape/Icon', |
| '../config', |
| '../util/date', |
| 'zrender/tool/util', |
| '../component' |
| ], function (require) { |
| var Base = require('./base'); |
| var RectangleShape = require('zrender/shape/Rectangle'); |
| var PolygonShape = require('zrender/shape/Polygon'); |
| var IconShape = require('../util/shape/Icon'); |
| var ecConfig = require('../config'); |
| var ecDate = require('../util/date'); |
| var zrUtil = require('zrender/tool/util'); |
| function DataZoom(ecTheme, messageCenter, zr, option, myChart) { |
| Base.call(this, ecTheme, messageCenter, zr, option, myChart); |
| var self = this; |
| self._ondrift = function (dx, dy) { |
| return self.__ondrift(this, dx, dy); |
| }; |
| self._ondragend = function () { |
| return self.__ondragend(); |
| }; |
| this._fillerSize = 28; |
| this._handleSize = 8; |
| this._isSilence = false; |
| this._zoom = {}; |
| this.option.dataZoom = this.reformOption(this.option.dataZoom); |
| this.zoomOption = this.option.dataZoom; |
| if (!this.myChart.canvasSupported) { |
| this.zoomOption.realtime = false; |
| } |
| this._location = this._getLocation(); |
| this._zoom = this._getZoom(); |
| this._backupData(); |
| if (this.option.dataZoom.show) { |
| this._buildShape(); |
| } |
| this._syncData(); |
| } |
| DataZoom.prototype = { |
| type: ecConfig.COMPONENT_TYPE_DATAZOOM, |
| _buildShape: function () { |
| this._buildBackground(); |
| this._buildFiller(); |
| this._buildHandle(); |
| this._buildFrame(); |
| for (var i = 0, l = this.shapeList.length; i < l; i++) { |
| this.zr.addShape(this.shapeList[i]); |
| } |
| this._syncFrameShape(); |
| }, |
| _getLocation: function () { |
| var x; |
| var y; |
| var width; |
| var height; |
| var grid = this.component.grid; |
| if (this.zoomOption.orient == 'horizontal') { |
| width = this.zoomOption.width || grid.getWidth(); |
| height = this.zoomOption.height || this._fillerSize; |
| x = this.zoomOption.x != null ? this.zoomOption.x : grid.getX(); |
| y = this.zoomOption.y != null ? this.zoomOption.y : this.zr.getHeight() - height - 2; |
| } else { |
| width = this.zoomOption.width || this._fillerSize; |
| height = this.zoomOption.height || grid.getHeight(); |
| x = this.zoomOption.x != null ? this.zoomOption.x : 2; |
| y = this.zoomOption.y != null ? this.zoomOption.y : grid.getY(); |
| } |
| return { |
| x: x, |
| y: y, |
| width: width, |
| height: height |
| }; |
| }, |
| _getZoom: function () { |
| var series = this.option.series; |
| var xAxis = this.option.xAxis; |
| if (xAxis && !(xAxis instanceof Array)) { |
| xAxis = [xAxis]; |
| this.option.xAxis = xAxis; |
| } |
| var yAxis = this.option.yAxis; |
| if (yAxis && !(yAxis instanceof Array)) { |
| yAxis = [yAxis]; |
| this.option.yAxis = yAxis; |
| } |
| var zoomSeriesIndex = []; |
| var xAxisIndex; |
| var yAxisIndex; |
| var zOptIdx = this.zoomOption.xAxisIndex; |
| if (xAxis && zOptIdx == null) { |
| xAxisIndex = []; |
| for (var i = 0, l = xAxis.length; i < l; i++) { |
| if (xAxis[i].type == 'category' || xAxis[i].type == null) { |
| xAxisIndex.push(i); |
| } |
| } |
| } else { |
| if (zOptIdx instanceof Array) { |
| xAxisIndex = zOptIdx; |
| } else if (zOptIdx != null) { |
| xAxisIndex = [zOptIdx]; |
| } else { |
| xAxisIndex = []; |
| } |
| } |
| zOptIdx = this.zoomOption.yAxisIndex; |
| if (yAxis && zOptIdx == null) { |
| yAxisIndex = []; |
| for (var i = 0, l = yAxis.length; i < l; i++) { |
| if (yAxis[i].type == 'category') { |
| yAxisIndex.push(i); |
| } |
| } |
| } else { |
| if (zOptIdx instanceof Array) { |
| yAxisIndex = zOptIdx; |
| } else if (zOptIdx != null) { |
| yAxisIndex = [zOptIdx]; |
| } else { |
| yAxisIndex = []; |
| } |
| } |
| var serie; |
| for (var i = 0, l = series.length; i < l; i++) { |
| serie = series[i]; |
| if (serie.type != ecConfig.CHART_TYPE_LINE && serie.type != ecConfig.CHART_TYPE_BAR && serie.type != ecConfig.CHART_TYPE_SCATTER && serie.type != ecConfig.CHART_TYPE_K) { |
| continue; |
| } |
| for (var j = 0, k = xAxisIndex.length; j < k; j++) { |
| if (xAxisIndex[j] == (serie.xAxisIndex || 0)) { |
| zoomSeriesIndex.push(i); |
| break; |
| } |
| } |
| for (var j = 0, k = yAxisIndex.length; j < k; j++) { |
| if (yAxisIndex[j] == (serie.yAxisIndex || 0)) { |
| zoomSeriesIndex.push(i); |
| break; |
| } |
| } |
| if (this.zoomOption.xAxisIndex == null && this.zoomOption.yAxisIndex == null && serie.data && serie.data[0] && serie.data[0] instanceof Array && (serie.type == ecConfig.CHART_TYPE_SCATTER || serie.type == ecConfig.CHART_TYPE_LINE || serie.type == ecConfig.CHART_TYPE_BAR)) { |
| zoomSeriesIndex.push(i); |
| } |
| } |
| var start = this._zoom.start != null ? this._zoom.start : this.zoomOption.start != null ? this.zoomOption.start : 0; |
| var end = this._zoom.end != null ? this._zoom.end : this.zoomOption.end != null ? this.zoomOption.end : 100; |
| if (start > end) { |
| start = start + end; |
| end = start - end; |
| start = start - end; |
| } |
| var size = Math.round((end - start) / 100 * (this.zoomOption.orient == 'horizontal' ? this._location.width : this._location.height)); |
| return { |
| start: start, |
| end: end, |
| start2: 0, |
| end2: 100, |
| size: size, |
| xAxisIndex: xAxisIndex, |
| yAxisIndex: yAxisIndex, |
| seriesIndex: zoomSeriesIndex, |
| scatterMap: this._zoom.scatterMap || {} |
| }; |
| }, |
| _backupData: function () { |
| this._originalData = { |
| xAxis: {}, |
| yAxis: {}, |
| series: {} |
| }; |
| var xAxis = this.option.xAxis; |
| var xAxisIndex = this._zoom.xAxisIndex; |
| for (var i = 0, l = xAxisIndex.length; i < l; i++) { |
| this._originalData.xAxis[xAxisIndex[i]] = xAxis[xAxisIndex[i]].data; |
| } |
| var yAxis = this.option.yAxis; |
| var yAxisIndex = this._zoom.yAxisIndex; |
| for (var i = 0, l = yAxisIndex.length; i < l; i++) { |
| this._originalData.yAxis[yAxisIndex[i]] = yAxis[yAxisIndex[i]].data; |
| } |
| var series = this.option.series; |
| var seriesIndex = this._zoom.seriesIndex; |
| var serie; |
| for (var i = 0, l = seriesIndex.length; i < l; i++) { |
| serie = series[seriesIndex[i]]; |
| this._originalData.series[seriesIndex[i]] = serie.data; |
| if (serie.data && serie.data[0] && serie.data[0] instanceof Array && (serie.type == ecConfig.CHART_TYPE_SCATTER || serie.type == ecConfig.CHART_TYPE_LINE || serie.type == ecConfig.CHART_TYPE_BAR)) { |
| this._backupScale(); |
| this._calculScatterMap(seriesIndex[i]); |
| } |
| } |
| }, |
| _calculScatterMap: function (seriesIndex) { |
| this._zoom.scatterMap = this._zoom.scatterMap || {}; |
| this._zoom.scatterMap[seriesIndex] = this._zoom.scatterMap[seriesIndex] || {}; |
| var componentLibrary = require('../component'); |
| var Axis = componentLibrary.get('axis'); |
| var axisOption = zrUtil.clone(this.option.xAxis); |
| if (axisOption[0].type == 'category') { |
| axisOption[0].type = 'value'; |
| } |
| if (axisOption[1] && axisOption[1].type == 'category') { |
| axisOption[1].type = 'value'; |
| } |
| var vAxis = new Axis(this.ecTheme, null, false, { |
| xAxis: axisOption, |
| series: this.option.series |
| }, this, 'xAxis'); |
| var axisIndex = this.option.series[seriesIndex].xAxisIndex || 0; |
| this._zoom.scatterMap[seriesIndex].x = vAxis.getAxis(axisIndex).getExtremum(); |
| vAxis.dispose(); |
| axisOption = zrUtil.clone(this.option.yAxis); |
| if (axisOption[0].type == 'category') { |
| axisOption[0].type = 'value'; |
| } |
| if (axisOption[1] && axisOption[1].type == 'category') { |
| axisOption[1].type = 'value'; |
| } |
| vAxis = new Axis(this.ecTheme, null, false, { |
| yAxis: axisOption, |
| series: this.option.series |
| }, this, 'yAxis'); |
| axisIndex = this.option.series[seriesIndex].yAxisIndex || 0; |
| this._zoom.scatterMap[seriesIndex].y = vAxis.getAxis(axisIndex).getExtremum(); |
| vAxis.dispose(); |
| }, |
| _buildBackground: function () { |
| var width = this._location.width; |
| var height = this._location.height; |
| this.shapeList.push(new RectangleShape({ |
| zlevel: this._zlevelBase, |
| hoverable: false, |
| style: { |
| x: this._location.x, |
| y: this._location.y, |
| width: width, |
| height: height, |
| color: this.zoomOption.backgroundColor |
| } |
| })); |
| var maxLength = 0; |
| var xAxis = this._originalData.xAxis; |
| var xAxisIndex = this._zoom.xAxisIndex; |
| for (var i = 0, l = xAxisIndex.length; i < l; i++) { |
| maxLength = Math.max(maxLength, xAxis[xAxisIndex[i]].length); |
| } |
| var yAxis = this._originalData.yAxis; |
| var yAxisIndex = this._zoom.yAxisIndex; |
| for (var i = 0, l = yAxisIndex.length; i < l; i++) { |
| maxLength = Math.max(maxLength, yAxis[yAxisIndex[i]].length); |
| } |
| var seriesIndex = this._zoom.seriesIndex[0]; |
| var data = this._originalData.series[seriesIndex]; |
| var maxValue = Number.MIN_VALUE; |
| var minValue = Number.MAX_VALUE; |
| var value; |
| for (var i = 0, l = data.length; i < l; i++) { |
| value = data[i] != null ? data[i].value != null ? data[i].value : data[i] : 0; |
| if (this.option.series[seriesIndex].type == ecConfig.CHART_TYPE_K) { |
| value = value[1]; |
| } |
| if (isNaN(value)) { |
| value = 0; |
| } |
| maxValue = Math.max(maxValue, value); |
| minValue = Math.min(minValue, value); |
| } |
| var valueRange = maxValue - minValue; |
| var pointList = []; |
| var x = width / (maxLength - (maxLength > 1 ? 1 : 0)); |
| var y = height / (maxLength - (maxLength > 1 ? 1 : 0)); |
| var step = 1; |
| if (this.zoomOption.orient == 'horizontal' && x < 1) { |
| step = Math.floor(maxLength * 3 / width); |
| } else if (this.zoomOption.orient == 'vertical' && y < 1) { |
| step = Math.floor(maxLength * 3 / height); |
| } |
| for (var i = 0, l = maxLength; i < l; i += step) { |
| value = data[i] != null ? data[i].value != null ? data[i].value : data[i] : 0; |
| if (this.option.series[seriesIndex].type == ecConfig.CHART_TYPE_K) { |
| value = value[1]; |
| } |
| if (isNaN(value)) { |
| value = 0; |
| } |
| if (this.zoomOption.orient == 'horizontal') { |
| pointList.push([ |
| this._location.x + x * i, |
| this._location.y + height - 1 - Math.round((value - minValue) / valueRange * (height - 10)) |
| ]); |
| } else { |
| pointList.push([ |
| this._location.x + 1 + Math.round((value - minValue) / valueRange * (width - 10)), |
| this._location.y + y * i |
| ]); |
| } |
| } |
| if (this.zoomOption.orient == 'horizontal') { |
| pointList.push([ |
| this._location.x + width, |
| this._location.y + height |
| ]); |
| pointList.push([ |
| this._location.x, |
| this._location.y + height |
| ]); |
| } else { |
| pointList.push([ |
| this._location.x, |
| this._location.y + height |
| ]); |
| pointList.push([ |
| this._location.x, |
| this._location.y |
| ]); |
| } |
| this.shapeList.push(new PolygonShape({ |
| zlevel: this._zlevelBase, |
| style: { |
| pointList: pointList, |
| color: this.zoomOption.dataBackgroundColor |
| }, |
| hoverable: false |
| })); |
| }, |
| _buildFiller: function () { |
| this._fillerShae = { |
| zlevel: this._zlevelBase, |
| draggable: true, |
| ondrift: this._ondrift, |
| ondragend: this._ondragend, |
| _type: 'filler' |
| }; |
| if (this.zoomOption.orient == 'horizontal') { |
| this._fillerShae.style = { |
| x: this._location.x + Math.round(this._zoom.start / 100 * this._location.width) + this._handleSize, |
| y: this._location.y, |
| width: this._zoom.size - this._handleSize * 2, |
| height: this._location.height, |
| color: this.zoomOption.fillerColor, |
| text: ':::', |
| textPosition: 'inside' |
| }; |
| } else { |
| this._fillerShae.style = { |
| x: this._location.x, |
| y: this._location.y + Math.round(this._zoom.start / 100 * this._location.height) + this._handleSize, |
| width: this._location.width, |
| height: this._zoom.size - this._handleSize * 2, |
| color: this.zoomOption.fillerColor, |
| text: '::', |
| textPosition: 'inside' |
| }; |
| } |
| this._fillerShae.highlightStyle = { |
| brushType: 'fill', |
| color: 'rgba(0,0,0,0)' |
| }; |
| this._fillerShae = new RectangleShape(this._fillerShae); |
| this.shapeList.push(this._fillerShae); |
| }, |
| _buildHandle: function () { |
| this._startShape = { |
| zlevel: this._zlevelBase, |
| draggable: true, |
| style: { |
| iconType: 'rectangle', |
| x: this._location.x, |
| y: this._location.y, |
| width: this._handleSize, |
| height: this._handleSize, |
| color: this.zoomOption.handleColor, |
| text: '=', |
| textPosition: 'inside' |
| }, |
| highlightStyle: { |
| text: '', |
| brushType: 'fill', |
| textPosition: 'left' |
| }, |
| ondrift: this._ondrift, |
| ondragend: this._ondragend |
| }; |
| if (this.zoomOption.orient == 'horizontal') { |
| this._startShape.style.height = this._location.height; |
| this._endShape = zrUtil.clone(this._startShape); |
| this._startShape.style.x = this._fillerShae.style.x - this._handleSize, this._endShape.style.x = this._fillerShae.style.x + this._fillerShae.style.width; |
| this._endShape.highlightStyle.textPosition = 'right'; |
| } else { |
| this._startShape.style.width = this._location.width; |
| this._endShape = zrUtil.clone(this._startShape); |
| this._startShape.style.y = this._fillerShae.style.y - this._handleSize; |
| this._startShape.highlightStyle.textPosition = 'top'; |
| this._endShape.style.y = this._fillerShae.style.y + this._fillerShae.style.height; |
| this._endShape.highlightStyle.textPosition = 'bottom'; |
| } |
| this._startShape = new IconShape(this._startShape); |
| this._endShape = new IconShape(this._endShape); |
| this.shapeList.push(this._startShape); |
| this.shapeList.push(this._endShape); |
| }, |
| _buildFrame: function () { |
| var x = this.subPixelOptimize(this._location.x, 1); |
| var y = this.subPixelOptimize(this._location.y, 1); |
| this._startFrameShape = { |
| zlevel: this._zlevelBase, |
| hoverable: false, |
| style: { |
| x: x, |
| y: y, |
| width: this._location.width - (x > this._location.x ? 1 : 0), |
| height: this._location.height - (y > this._location.y ? 1 : 0), |
| lineWidth: 1, |
| brushType: 'stroke', |
| strokeColor: this.zoomOption.handleColor |
| } |
| }; |
| this._endFrameShape = zrUtil.clone(this._startFrameShape); |
| this._startFrameShape = new RectangleShape(this._startFrameShape); |
| this._endFrameShape = new RectangleShape(this._endFrameShape); |
| this.shapeList.push(this._startFrameShape); |
| this.shapeList.push(this._endFrameShape); |
| return; |
| }, |
| _syncHandleShape: function () { |
| if (this.zoomOption.orient == 'horizontal') { |
| this._startShape.style.x = this._fillerShae.style.x - this._handleSize; |
| this._endShape.style.x = this._fillerShae.style.x + this._fillerShae.style.width; |
| this._zoom.start = Math.floor((this._startShape.style.x - this._location.x) / this._location.width * 100); |
| this._zoom.end = Math.ceil((this._endShape.style.x + this._handleSize - this._location.x) / this._location.width * 100); |
| } else { |
| this._startShape.style.y = this._fillerShae.style.y - this._handleSize; |
| this._endShape.style.y = this._fillerShae.style.y + this._fillerShae.style.height; |
| this._zoom.start = Math.floor((this._startShape.style.y - this._location.y) / this._location.height * 100); |
| this._zoom.end = Math.ceil((this._endShape.style.y + this._handleSize - this._location.y) / this._location.height * 100); |
| } |
| this.zr.modShape(this._startShape.id); |
| this.zr.modShape(this._endShape.id); |
| this._syncFrameShape(); |
| this.zr.refresh(); |
| }, |
| _syncFillerShape: function () { |
| var a; |
| var b; |
| if (this.zoomOption.orient == 'horizontal') { |
| a = this._startShape.style.x; |
| b = this._endShape.style.x; |
| this._fillerShae.style.x = Math.min(a, b) + this._handleSize; |
| this._fillerShae.style.width = Math.abs(a - b) - this._handleSize; |
| this._zoom.start = Math.floor((Math.min(a, b) - this._location.x) / this._location.width * 100); |
| this._zoom.end = Math.ceil((Math.max(a, b) + this._handleSize - this._location.x) / this._location.width * 100); |
| } else { |
| a = this._startShape.style.y; |
| b = this._endShape.style.y; |
| this._fillerShae.style.y = Math.min(a, b) + this._handleSize; |
| this._fillerShae.style.height = Math.abs(a - b) - this._handleSize; |
| this._zoom.start = Math.floor((Math.min(a, b) - this._location.y) / this._location.height * 100); |
| this._zoom.end = Math.ceil((Math.max(a, b) + this._handleSize - this._location.y) / this._location.height * 100); |
| } |
| this.zr.modShape(this._fillerShae.id); |
| this._syncFrameShape(); |
| this.zr.refresh(); |
| }, |
| _syncFrameShape: function () { |
| if (this.zoomOption.orient == 'horizontal') { |
| this._startFrameShape.style.width = this._fillerShae.style.x - this._location.x; |
| this._endFrameShape.style.x = this._fillerShae.style.x + this._fillerShae.style.width; |
| this._endFrameShape.style.width = this._location.x + this._location.width - this._endFrameShape.style.x; |
| } else { |
| this._startFrameShape.style.height = this._fillerShae.style.y - this._location.y; |
| this._endFrameShape.style.y = this._fillerShae.style.y + this._fillerShae.style.height; |
| this._endFrameShape.style.height = this._location.y + this._location.height - this._endFrameShape.style.y; |
| } |
| this.zr.modShape(this._startFrameShape.id); |
| this.zr.modShape(this._endFrameShape.id); |
| }, |
| _syncShape: function () { |
| if (!this.zoomOption.show) { |
| return; |
| } |
| if (this.zoomOption.orient == 'horizontal') { |
| this._startShape.style.x = this._location.x + this._zoom.start / 100 * this._location.width; |
| this._endShape.style.x = this._location.x + this._zoom.end / 100 * this._location.width - this._handleSize; |
| this._fillerShae.style.x = this._startShape.style.x + this._handleSize; |
| this._fillerShae.style.width = this._endShape.style.x - this._startShape.style.x - this._handleSize; |
| } else { |
| this._startShape.style.y = this._location.y + this._zoom.start / 100 * this._location.height; |
| this._endShape.style.y = this._location.y + this._zoom.end / 100 * this._location.height - this._handleSize; |
| this._fillerShae.style.y = this._startShape.style.y + this._handleSize; |
| this._fillerShae.style.height = this._endShape.style.y - this._startShape.style.y - this._handleSize; |
| } |
| this.zr.modShape(this._startShape.id); |
| this.zr.modShape(this._endShape.id); |
| this.zr.modShape(this._fillerShae.id); |
| this._syncFrameShape(); |
| this.zr.refresh(); |
| }, |
| _syncData: function (dispatchNow) { |
| var target; |
| var start; |
| var end; |
| var length; |
| var data; |
| for (var key in this._originalData) { |
| target = this._originalData[key]; |
| for (var idx in target) { |
| data = target[idx]; |
| if (data == null) { |
| continue; |
| } |
| length = data.length; |
| start = Math.floor(this._zoom.start / 100 * length); |
| end = Math.ceil(this._zoom.end / 100 * length); |
| if (!(this.option[key][idx].data[0] instanceof Array) || this.option[key][idx].type == ecConfig.CHART_TYPE_K) { |
| this.option[key][idx].data = data.slice(start, end); |
| } else { |
| this._setScale(); |
| this.option[key][idx].data = this._synScatterData(idx, data); |
| } |
| } |
| } |
| if (!this._isSilence && (this.zoomOption.realtime || dispatchNow)) { |
| this.messageCenter.dispatch(ecConfig.EVENT.DATA_ZOOM, null, { zoom: this._zoom }, this.myChart); |
| } |
| }, |
| _synScatterData: function (seriesIndex, data) { |
| if (this._zoom.start === 0 && this._zoom.end == 100 && this._zoom.start2 === 0 && this._zoom.end2 == 100) { |
| return data; |
| } |
| var newData = []; |
| var scale = this._zoom.scatterMap[seriesIndex]; |
| var total; |
| var xStart; |
| var xEnd; |
| var yStart; |
| var yEnd; |
| if (this.zoomOption.orient == 'horizontal') { |
| total = scale.x.max - scale.x.min; |
| xStart = this._zoom.start / 100 * total + scale.x.min; |
| xEnd = this._zoom.end / 100 * total + scale.x.min; |
| total = scale.y.max - scale.y.min; |
| yStart = this._zoom.start2 / 100 * total + scale.y.min; |
| yEnd = this._zoom.end2 / 100 * total + scale.y.min; |
| } else { |
| total = scale.x.max - scale.x.min; |
| xStart = this._zoom.start2 / 100 * total + scale.x.min; |
| xEnd = this._zoom.end2 / 100 * total + scale.x.min; |
| total = scale.y.max - scale.y.min; |
| yStart = this._zoom.start / 100 * total + scale.y.min; |
| yEnd = this._zoom.end / 100 * total + scale.y.min; |
| } |
| var value; |
| for (var i = 0, l = data.length; i < l; i++) { |
| value = data[i].value || data[i]; |
| if (value[0] >= xStart && value[0] <= xEnd && value[1] >= yStart && value[1] <= yEnd) { |
| newData.push(data[i]); |
| } |
| } |
| return newData; |
| }, |
| _setScale: function () { |
| var needScale = this._zoom.start !== 0 || this._zoom.end !== 100 || this._zoom.start2 !== 0 || this._zoom.end2 !== 100; |
| var axis = { |
| xAxis: this.option.xAxis, |
| yAxis: this.option.yAxis |
| }; |
| for (var key in axis) { |
| for (var i = 0, l = axis[key].length; i < l; i++) { |
| axis[key][i].scale = needScale || axis[key][i]._scale; |
| } |
| } |
| }, |
| _backupScale: function () { |
| var axis = { |
| xAxis: this.option.xAxis, |
| yAxis: this.option.yAxis |
| }; |
| for (var key in axis) { |
| for (var i = 0, l = axis[key].length; i < l; i++) { |
| axis[key][i]._scale = axis[key][i].scale; |
| } |
| } |
| }, |
| _getDetail: function () { |
| var key = this.zoomOption.orient == 'horizontal' ? 'xAxis' : 'yAxis'; |
| var target = this._originalData[key]; |
| for (var idx in target) { |
| var data = target[idx]; |
| if (data == null) { |
| continue; |
| } |
| var length = data.length; |
| var start = Math.floor(this._zoom.start / 100 * length); |
| var end = Math.ceil(this._zoom.end / 100 * length); |
| end -= end >= length ? 1 : 0; |
| return { |
| start: data[start].value != null ? data[start].value : data[start], |
| end: data[end].value != null ? data[end].value : data[end] |
| }; |
| } |
| var seriesIndex = this._zoom.seriesIndex[0]; |
| var axisIndex = this.option.series[seriesIndex][key + 'Index'] || 0; |
| var axisType = this.option[key][axisIndex].type; |
| var min = this._zoom.scatterMap[seriesIndex][key.charAt(0)].min; |
| var max = this._zoom.scatterMap[seriesIndex][key.charAt(0)].max; |
| var gap = max - min; |
| if (axisType == 'value') { |
| return { |
| start: min + gap * this._zoom.start / 100, |
| end: min + gap * this._zoom.end / 100 |
| }; |
| } else if (axisType == 'time') { |
| max = min + gap * this._zoom.end / 100; |
| min = min + gap * this._zoom.start / 100; |
| var formatter = ecDate.getAutoFormatter(min, max).formatter; |
| return { |
| start: ecDate.format(formatter, min), |
| end: ecDate.format(formatter, max) |
| }; |
| } |
| return { |
| start: '', |
| end: '' |
| }; |
| }, |
| __ondrift: function (shape, dx, dy) { |
| if (this.zoomOption.zoomLock) { |
| shape = this._fillerShae; |
| } |
| var detailSize = shape._type == 'filler' ? this._handleSize : 0; |
| if (this.zoomOption.orient == 'horizontal') { |
| if (shape.style.x + dx - detailSize <= this._location.x) { |
| shape.style.x = this._location.x + detailSize; |
| } else if (shape.style.x + dx + shape.style.width + detailSize >= this._location.x + this._location.width) { |
| shape.style.x = this._location.x + this._location.width - shape.style.width - detailSize; |
| } else { |
| shape.style.x += dx; |
| } |
| } else { |
| if (shape.style.y + dy - detailSize <= this._location.y) { |
| shape.style.y = this._location.y + detailSize; |
| } else if (shape.style.y + dy + shape.style.height + detailSize >= this._location.y + this._location.height) { |
| shape.style.y = this._location.y + this._location.height - shape.style.height - detailSize; |
| } else { |
| shape.style.y += dy; |
| } |
| } |
| if (shape._type == 'filler') { |
| this._syncHandleShape(); |
| } else { |
| this._syncFillerShape(); |
| } |
| if (this.zoomOption.realtime) { |
| this._syncData(); |
| } |
| if (this.zoomOption.showDetail) { |
| var deltail = this._getDetail(); |
| this._startShape.style.text = this._startShape.highlightStyle.text = deltail.start; |
| this._endShape.style.text = this._endShape.highlightStyle.text = deltail.end; |
| this._startShape.style.textPosition = this._startShape.highlightStyle.textPosition; |
| this._endShape.style.textPosition = this._endShape.highlightStyle.textPosition; |
| } |
| return true; |
| }, |
| __ondragend: function () { |
| if (this.zoomOption.showDetail) { |
| this._startShape.style.text = this._endShape.style.text = '='; |
| this._startShape.style.textPosition = this._endShape.style.textPosition = 'inside'; |
| this.zr.modShape(this._startShape.id); |
| this.zr.modShape(this._endShape.id); |
| this.zr.refreshNextFrame(); |
| } |
| this.isDragend = true; |
| }, |
| ondragend: function (param, status) { |
| if (!this.isDragend || !param.target) { |
| return; |
| } |
| !this.zoomOption.realtime && this._syncData(); |
| status.dragOut = true; |
| status.dragIn = true; |
| if (!this._isSilence && !this.zoomOption.realtime) { |
| this.messageCenter.dispatch(ecConfig.EVENT.DATA_ZOOM, null, { zoom: this._zoom }, this.myChart); |
| } |
| status.needRefresh = false; |
| this.isDragend = false; |
| return; |
| }, |
| ondataZoom: function (param, status) { |
| status.needRefresh = true; |
| return; |
| }, |
| absoluteZoom: function (param) { |
| this._zoom.start = param.start; |
| this._zoom.end = param.end; |
| this._zoom.start2 = param.start2; |
| this._zoom.end2 = param.end2; |
| this._syncShape(); |
| this._syncData(true); |
| return; |
| }, |
| rectZoom: function (param) { |
| if (!param) { |
| this._zoom.start = this._zoom.start2 = 0; |
| this._zoom.end = this._zoom.end2 = 100; |
| this._syncShape(); |
| this._syncData(true); |
| return this._zoom; |
| } |
| var gridArea = this.component.grid.getArea(); |
| var rect = { |
| x: param.x, |
| y: param.y, |
| width: param.width, |
| height: param.height |
| }; |
| if (rect.width < 0) { |
| rect.x += rect.width; |
| rect.width = -rect.width; |
| } |
| if (rect.height < 0) { |
| rect.y += rect.height; |
| rect.height = -rect.height; |
| } |
| if (rect.x > gridArea.x + gridArea.width || rect.y > gridArea.y + gridArea.height) { |
| return false; |
| } |
| if (rect.x < gridArea.x) { |
| rect.x = gridArea.x; |
| } |
| if (rect.x + rect.width > gridArea.x + gridArea.width) { |
| rect.width = gridArea.x + gridArea.width - rect.x; |
| } |
| if (rect.y + rect.height > gridArea.y + gridArea.height) { |
| rect.height = gridArea.y + gridArea.height - rect.y; |
| } |
| var total; |
| var sdx = (rect.x - gridArea.x) / gridArea.width; |
| var edx = 1 - (rect.x + rect.width - gridArea.x) / gridArea.width; |
| var sdy = 1 - (rect.y + rect.height - gridArea.y) / gridArea.height; |
| var edy = (rect.y - gridArea.y) / gridArea.height; |
| if (this.zoomOption.orient == 'horizontal') { |
| total = this._zoom.end - this._zoom.start; |
| this._zoom.start += total * sdx; |
| this._zoom.end -= total * edx; |
| total = this._zoom.end2 - this._zoom.start2; |
| this._zoom.start2 += total * sdy; |
| this._zoom.end2 -= total * edy; |
| } else { |
| total = this._zoom.end - this._zoom.start; |
| this._zoom.start += total * sdy; |
| this._zoom.end -= total * edy; |
| total = this._zoom.end2 - this._zoom.start2; |
| this._zoom.start2 += total * sdx; |
| this._zoom.end2 -= total * edx; |
| } |
| this._syncShape(); |
| this._syncData(true); |
| return this._zoom; |
| }, |
| syncBackupData: function (curOption) { |
| var start; |
| var target = this._originalData['series']; |
| var curSeries = curOption.series; |
| var curData; |
| for (var i = 0, l = curSeries.length; i < l; i++) { |
| curData = curSeries[i].data || curSeries[i].eventList; |
| if (target[i]) { |
| start = Math.floor(this._zoom.start / 100 * target[i].length); |
| } else { |
| start = 0; |
| } |
| for (var j = 0, k = curData.length; j < k; j++) { |
| if (target[i]) { |
| target[i][j + start] = curData[j]; |
| } |
| } |
| } |
| }, |
| syncOption: function (magicOption) { |
| this.silence(true); |
| this.option = magicOption; |
| this.option.dataZoom = this.reformOption(this.option.dataZoom); |
| this.zoomOption = this.option.dataZoom; |
| if (!this.myChart.canvasSupported) { |
| this.zoomOption.realtime = false; |
| } |
| this.clear(); |
| this._location = this._getLocation(); |
| this._zoom = this._getZoom(); |
| this._backupData(); |
| if (this.option.dataZoom && this.option.dataZoom.show) { |
| this._buildShape(); |
| } |
| this._syncData(); |
| this.silence(false); |
| }, |
| silence: function (s) { |
| this._isSilence = s; |
| }, |
| getRealDataIndex: function (sIdx, dIdx) { |
| if (!this._originalData || this._zoom.start === 0 && this._zoom.end == 100) { |
| return dIdx; |
| } |
| var sreies = this._originalData.series; |
| if (sreies[sIdx]) { |
| return Math.floor(this._zoom.start / 100 * sreies[sIdx].length) + dIdx; |
| } |
| return -1; |
| }, |
| resize: function () { |
| this.clear(); |
| this._location = this._getLocation(); |
| this._zoom = this._getZoom(); |
| if (this.option.dataZoom.show) { |
| this._buildShape(); |
| } |
| } |
| }; |
| zrUtil.inherits(DataZoom, Base); |
| require('../component').define('dataZoom', DataZoom); |
| return DataZoom; |
| });define('echarts/component/categoryAxis', [ |
| 'require', |
| './base', |
| 'zrender/shape/Text', |
| 'zrender/shape/Line', |
| 'zrender/shape/Rectangle', |
| '../config', |
| 'zrender/tool/util', |
| 'zrender/tool/area', |
| '../component' |
| ], function (require) { |
| var Base = require('./base'); |
| var TextShape = require('zrender/shape/Text'); |
| var LineShape = require('zrender/shape/Line'); |
| var RectangleShape = require('zrender/shape/Rectangle'); |
| var ecConfig = require('../config'); |
| var zrUtil = require('zrender/tool/util'); |
| var zrArea = require('zrender/tool/area'); |
| function CategoryAxis(ecTheme, messageCenter, zr, option, myChart, axisBase) { |
| if (option.data.length < 1) { |
| console.error('option.data.length < 1.'); |
| return; |
| } |
| Base.call(this, ecTheme, messageCenter, zr, option, myChart); |
| this.grid = this.component.grid; |
| for (var method in axisBase) { |
| this[method] = axisBase[method]; |
| } |
| this.refresh(option); |
| } |
| CategoryAxis.prototype = { |
| type: ecConfig.COMPONENT_TYPE_AXIS_CATEGORY, |
| _getReformedLabel: function (idx) { |
| var data = typeof this.option.data[idx].value != 'undefined' ? this.option.data[idx].value : this.option.data[idx]; |
| var formatter = this.option.data[idx].formatter || this.option.axisLabel.formatter; |
| if (formatter) { |
| if (typeof formatter == 'function') { |
| data = formatter.call(this.myChart, data); |
| } else if (typeof formatter == 'string') { |
| data = formatter.replace('{value}', data); |
| } |
| } |
| return data; |
| }, |
| _getInterval: function () { |
| var interval = this.option.axisLabel.interval; |
| if (interval == 'auto') { |
| var fontSize = this.option.axisLabel.textStyle.fontSize; |
| var data = this.option.data; |
| var dataLength = this.option.data.length; |
| if (this.isHorizontal()) { |
| if (dataLength > 3) { |
| var gap = this.getGap(); |
| var isEnough = false; |
| var labelSpace; |
| var labelSize; |
| var step = Math.floor(0.5 / gap); |
| step = step < 1 ? 1 : step; |
| interval = Math.floor(15 / gap); |
| while (!isEnough && interval < dataLength) { |
| interval += step; |
| isEnough = true; |
| labelSpace = Math.floor(gap * interval); |
| for (var i = Math.floor((dataLength - 1) / interval) * interval; i >= 0; i -= interval) { |
| if (this.option.axisLabel.rotate !== 0) { |
| labelSize = fontSize; |
| } else if (data[i].textStyle) { |
| labelSize = zrArea.getTextWidth(this._getReformedLabel(i), this.getFont(zrUtil.merge(data[i].textStyle, this.option.axisLabel.textStyle))); |
| } else { |
| var label = this._getReformedLabel(i) + ''; |
| var wLen = (label.match(/\w/g) || '').length; |
| var oLen = label.length - wLen; |
| labelSize = wLen * fontSize * 2 / 3 + oLen * fontSize; |
| } |
| if (labelSpace < labelSize) { |
| isEnough = false; |
| break; |
| } |
| } |
| } |
| } else { |
| interval = 1; |
| } |
| } else { |
| if (dataLength > 3) { |
| var gap = this.getGap(); |
| interval = Math.floor(11 / gap); |
| while (gap * interval - 6 < fontSize && interval < dataLength) { |
| interval++; |
| } |
| } else { |
| interval = 1; |
| } |
| } |
| } else { |
| interval = interval - 0 + 1; |
| } |
| return interval; |
| }, |
| _buildShape: function () { |
| this._interval = this._getInterval(); |
| if (!this.option.show) { |
| return; |
| } |
| this.option.splitArea.show && this._buildSplitArea(); |
| this.option.splitLine.show && this._buildSplitLine(); |
| this.option.axisLine.show && this._buildAxisLine(); |
| this.option.axisTick.show && this._buildAxisTick(); |
| this.option.axisLabel.show && this._buildAxisLabel(); |
| for (var i = 0, l = this.shapeList.length; i < l; i++) { |
| this.zr.addShape(this.shapeList[i]); |
| } |
| }, |
| _buildAxisTick: function () { |
| var axShape; |
| var dataLength = this.option.data.length; |
| var tickOption = this.option.axisTick; |
| var length = tickOption.length; |
| var color = tickOption.lineStyle.color; |
| var lineWidth = tickOption.lineStyle.width; |
| var interval = tickOption.interval == 'auto' ? this._interval : tickOption.interval - 0 + 1; |
| var onGap = tickOption.onGap; |
| var optGap = onGap ? this.getGap() / 2 : typeof onGap == 'undefined' ? this.option.boundaryGap ? this.getGap() / 2 : 0 : 0; |
| var startIndex = optGap > 0 ? -interval : 0; |
| if (this.isHorizontal()) { |
| var yPosition = this.option.position == 'bottom' ? tickOption.inside ? this.grid.getYend() - length - 1 : this.grid.getYend() + 1 : tickOption.inside ? this.grid.getY() + 1 : this.grid.getY() - length - 1; |
| var x; |
| for (var i = startIndex; i < dataLength; i += interval) { |
| x = this.subPixelOptimize(this.getCoordByIndex(i) + (i >= 0 ? optGap : 0), lineWidth); |
| axShape = { |
| _axisShape: 'axisTick', |
| zlevel: this._zlevelBase, |
| hoverable: false, |
| style: { |
| xStart: x, |
| yStart: yPosition, |
| xEnd: x, |
| yEnd: yPosition + length, |
| strokeColor: color, |
| lineWidth: lineWidth |
| } |
| }; |
| this.shapeList.push(new LineShape(axShape)); |
| } |
| } else { |
| var xPosition = this.option.position == 'left' ? tickOption.inside ? this.grid.getX() + 1 : this.grid.getX() - length - 1 : tickOption.inside ? this.grid.getXend() - length - 1 : this.grid.getXend() + 1; |
| var y; |
| for (var i = startIndex; i < dataLength; i += interval) { |
| y = this.subPixelOptimize(this.getCoordByIndex(i) - (i >= 0 ? optGap : 0), lineWidth); |
| axShape = { |
| _axisShape: 'axisTick', |
| zlevel: this._zlevelBase, |
| hoverable: false, |
| style: { |
| xStart: xPosition, |
| yStart: y, |
| xEnd: xPosition + length, |
| yEnd: y, |
| strokeColor: color, |
| lineWidth: lineWidth |
| } |
| }; |
| this.shapeList.push(new LineShape(axShape)); |
| } |
| } |
| }, |
| _buildAxisLabel: function () { |
| var axShape; |
| var data = this.option.data; |
| var dataLength = this.option.data.length; |
| var rotate = this.option.axisLabel.rotate; |
| var margin = this.option.axisLabel.margin; |
| var clickable = this.option.axisLabel.clickable; |
| var textStyle = this.option.axisLabel.textStyle; |
| var dataTextStyle; |
| if (this.isHorizontal()) { |
| var yPosition; |
| var baseLine; |
| if (this.option.position == 'bottom') { |
| yPosition = this.grid.getYend() + margin; |
| baseLine = 'top'; |
| } else { |
| yPosition = this.grid.getY() - margin; |
| baseLine = 'bottom'; |
| } |
| for (var i = 0; i < dataLength; i += this._interval) { |
| if (this._getReformedLabel(i) === '') { |
| continue; |
| } |
| dataTextStyle = zrUtil.merge(data[i].textStyle || {}, textStyle); |
| axShape = { |
| zlevel: this._zlevelBase, |
| hoverable: false, |
| style: { |
| x: this.getCoordByIndex(i), |
| y: yPosition, |
| color: dataTextStyle.color, |
| text: this._getReformedLabel(i), |
| textFont: this.getFont(dataTextStyle), |
| textAlign: dataTextStyle.align || 'center', |
| textBaseline: dataTextStyle.baseline || baseLine |
| } |
| }; |
| if (rotate) { |
| axShape.style.textAlign = rotate > 0 ? this.option.position == 'bottom' ? 'right' : 'left' : this.option.position == 'bottom' ? 'left' : 'right'; |
| axShape.rotation = [ |
| rotate * Math.PI / 180, |
| axShape.style.x, |
| axShape.style.y |
| ]; |
| } |
| this.shapeList.push(new TextShape(this._axisLabelClickable(clickable, axShape))); |
| } |
| } else { |
| var xPosition; |
| var align; |
| if (this.option.position == 'left') { |
| xPosition = this.grid.getX() - margin; |
| align = 'right'; |
| } else { |
| xPosition = this.grid.getXend() + margin; |
| align = 'left'; |
| } |
| for (var i = 0; i < dataLength; i += this._interval) { |
| if (this._getReformedLabel(i) === '') { |
| continue; |
| } |
| dataTextStyle = zrUtil.merge(data[i].textStyle || {}, textStyle); |
| axShape = { |
| zlevel: this._zlevelBase, |
| hoverable: false, |
| style: { |
| x: xPosition, |
| y: this.getCoordByIndex(i), |
| color: dataTextStyle.color, |
| text: this._getReformedLabel(i), |
| textFont: this.getFont(dataTextStyle), |
| textAlign: dataTextStyle.align || align, |
| textBaseline: dataTextStyle.baseline || i === 0 && this.option.name !== '' ? 'bottom' : i == dataLength - 1 && this.option.name !== '' ? 'top' : 'middle' |
| } |
| }; |
| if (rotate) { |
| axShape.rotation = [ |
| rotate * Math.PI / 180, |
| axShape.style.x, |
| axShape.style.y |
| ]; |
| } |
| this.shapeList.push(new TextShape(this._axisLabelClickable(clickable, axShape))); |
| } |
| } |
| }, |
| _buildSplitLine: function () { |
| var axShape; |
| var dataLength = this.option.data.length; |
| var sLineOption = this.option.splitLine; |
| var lineType = sLineOption.lineStyle.type; |
| var lineWidth = sLineOption.lineStyle.width; |
| var color = sLineOption.lineStyle.color; |
| color = color instanceof Array ? color : [color]; |
| var colorLength = color.length; |
| var onGap = sLineOption.onGap; |
| var optGap = onGap ? this.getGap() / 2 : typeof onGap == 'undefined' ? this.option.boundaryGap ? this.getGap() / 2 : 0 : 0; |
| dataLength -= onGap || typeof onGap == 'undefined' && this.option.boundaryGap ? 1 : 0; |
| if (this.isHorizontal()) { |
| var sy = this.grid.getY(); |
| var ey = this.grid.getYend(); |
| var x; |
| for (var i = 0; i < dataLength; i += this._interval) { |
| x = this.subPixelOptimize(this.getCoordByIndex(i) + optGap, lineWidth); |
| axShape = { |
| zlevel: this._zlevelBase, |
| hoverable: false, |
| style: { |
| xStart: x, |
| yStart: sy, |
| xEnd: x, |
| yEnd: ey, |
| strokeColor: color[i / this._interval % colorLength], |
| lineType: lineType, |
| lineWidth: lineWidth |
| } |
| }; |
| this.shapeList.push(new LineShape(axShape)); |
| } |
| } else { |
| var sx = this.grid.getX(); |
| var ex = this.grid.getXend(); |
| var y; |
| for (var i = 0; i < dataLength; i += this._interval) { |
| y = this.subPixelOptimize(this.getCoordByIndex(i) - optGap, lineWidth); |
| axShape = { |
| zlevel: this._zlevelBase, |
| hoverable: false, |
| style: { |
| xStart: sx, |
| yStart: y, |
| xEnd: ex, |
| yEnd: y, |
| strokeColor: color[i / this._interval % colorLength], |
| linetype: lineType, |
| lineWidth: lineWidth |
| } |
| }; |
| this.shapeList.push(new LineShape(axShape)); |
| } |
| } |
| }, |
| _buildSplitArea: function () { |
| var axShape; |
| var sAreaOption = this.option.splitArea; |
| var color = sAreaOption.areaStyle.color; |
| if (!(color instanceof Array)) { |
| axShape = { |
| zlevel: this._zlevelBase, |
| hoverable: false, |
| style: { |
| x: this.grid.getX(), |
| y: this.grid.getY(), |
| width: this.grid.getWidth(), |
| height: this.grid.getHeight(), |
| color: color |
| } |
| }; |
| this.shapeList.push(new RectangleShape(axShape)); |
| } else { |
| var colorLength = color.length; |
| var dataLength = this.option.data.length; |
| var onGap = sAreaOption.onGap; |
| var optGap = onGap ? this.getGap() / 2 : typeof onGap == 'undefined' ? this.option.boundaryGap ? this.getGap() / 2 : 0 : 0; |
| if (this.isHorizontal()) { |
| var y = this.grid.getY(); |
| var height = this.grid.getHeight(); |
| var lastX = this.grid.getX(); |
| var curX; |
| for (var i = 0; i <= dataLength; i += this._interval) { |
| curX = i < dataLength ? this.getCoordByIndex(i) + optGap : this.grid.getXend(); |
| axShape = { |
| zlevel: this._zlevelBase, |
| hoverable: false, |
| style: { |
| x: lastX, |
| y: y, |
| width: curX - lastX, |
| height: height, |
| color: color[i / this._interval % colorLength] |
| } |
| }; |
| this.shapeList.push(new RectangleShape(axShape)); |
| lastX = curX; |
| } |
| } else { |
| var x = this.grid.getX(); |
| var width = this.grid.getWidth(); |
| var lastYend = this.grid.getYend(); |
| var curY; |
| for (var i = 0; i <= dataLength; i += this._interval) { |
| curY = i < dataLength ? this.getCoordByIndex(i) - optGap : this.grid.getY(); |
| axShape = { |
| zlevel: this._zlevelBase, |
| hoverable: false, |
| style: { |
| x: x, |
| y: curY, |
| width: width, |
| height: lastYend - curY, |
| color: color[i / this._interval % colorLength] |
| } |
| }; |
| this.shapeList.push(new RectangleShape(axShape)); |
| lastYend = curY; |
| } |
| } |
| } |
| }, |
| refresh: function (newOption) { |
| if (newOption) { |
| this.option = this.reformOption(newOption); |
| this.option.axisLabel.textStyle = zrUtil.merge(this.option.axisLabel.textStyle || {}, this.ecTheme.textStyle); |
| } |
| this.clear(); |
| this._buildShape(); |
| }, |
| getGap: function () { |
| var dataLength = this.option.data.length; |
| var total = this.isHorizontal() ? this.grid.getWidth() : this.grid.getHeight(); |
| if (this.option.boundaryGap) { |
| return total / dataLength; |
| } else { |
| return total / (dataLength > 1 ? dataLength - 1 : 1); |
| } |
| }, |
| getCoord: function (value) { |
| var data = this.option.data; |
| var dataLength = data.length; |
| var gap = this.getGap(); |
| var position = this.option.boundaryGap ? gap / 2 : 0; |
| for (var i = 0; i < dataLength; i++) { |
| if (data[i] == value || typeof data[i].value != 'undefined' && data[i].value == value) { |
| if (this.isHorizontal()) { |
| position = this.grid.getX() + position; |
| } else { |
| position = this.grid.getYend() - position; |
| } |
| return position; |
| } |
| position += gap; |
| } |
| }, |
| getCoordByIndex: function (dataIndex) { |
| if (dataIndex < 0) { |
| if (this.isHorizontal()) { |
| return this.grid.getX(); |
| } else { |
| return this.grid.getYend(); |
| } |
| } else if (dataIndex > this.option.data.length - 1) { |
| if (this.isHorizontal()) { |
| return this.grid.getXend(); |
| } else { |
| return this.grid.getY(); |
| } |
| } else { |
| var gap = this.getGap(); |
| var position = this.option.boundaryGap ? gap / 2 : 0; |
| position += dataIndex * gap; |
| if (this.isHorizontal()) { |
| position = this.grid.getX() + position; |
| } else { |
| position = this.grid.getYend() - position; |
| } |
| return position; |
| } |
| }, |
| getNameByIndex: function (dataIndex) { |
| var data = this.option.data[dataIndex]; |
| if (typeof data != 'undefined' && typeof data.value != 'undefined') { |
| return data.value; |
| } else { |
| return data; |
| } |
| }, |
| getIndexByName: function (name) { |
| var data = this.option.data; |
| var dataLength = data.length; |
| for (var i = 0; i < dataLength; i++) { |
| if (data[i] == name || typeof data[i].value != 'undefined' && data[i].value == name) { |
| return i; |
| } |
| } |
| return -1; |
| }, |
| getValueFromCoord: function () { |
| return ''; |
| }, |
| isMainAxis: function (dataIndex) { |
| return dataIndex % this._interval === 0; |
| } |
| }; |
| zrUtil.inherits(CategoryAxis, Base); |
| require('../component').define('categoryAxis', CategoryAxis); |
| return CategoryAxis; |
| });define('echarts/component/valueAxis', [ |
| 'require', |
| './base', |
| 'zrender/shape/Text', |
| 'zrender/shape/Line', |
| 'zrender/shape/Rectangle', |
| '../config', |
| '../util/date', |
| 'zrender/tool/util', |
| '../util/smartSteps', |
| '../util/accMath', |
| '../component' |
| ], function (require) { |
| var Base = require('./base'); |
| var TextShape = require('zrender/shape/Text'); |
| var LineShape = require('zrender/shape/Line'); |
| var RectangleShape = require('zrender/shape/Rectangle'); |
| var ecConfig = require('../config'); |
| var ecDate = require('../util/date'); |
| var zrUtil = require('zrender/tool/util'); |
| function ValueAxis(ecTheme, messageCenter, zr, option, myChart, axisBase, series) { |
| if (!series || series.length === 0) { |
| console.err('option.series.length == 0.'); |
| return; |
| } |
| Base.call(this, ecTheme, messageCenter, zr, option, myChart); |
| this.series = series; |
| this.grid = this.component.grid; |
| for (var method in axisBase) { |
| this[method] = axisBase[method]; |
| } |
| this.refresh(option, series); |
| } |
| ValueAxis.prototype = { |
| type: ecConfig.COMPONENT_TYPE_AXIS_VALUE, |
| _buildShape: function () { |
| this._hasData = false; |
| this._calculateValue(); |
| if (!this._hasData || !this.option.show) { |
| return; |
| } |
| this.option.splitArea.show && this._buildSplitArea(); |
| this.option.splitLine.show && this._buildSplitLine(); |
| this.option.axisLine.show && this._buildAxisLine(); |
| this.option.axisTick.show && this._buildAxisTick(); |
| this.option.axisLabel.show && this._buildAxisLabel(); |
| for (var i = 0, l = this.shapeList.length; i < l; i++) { |
| this.zr.addShape(this.shapeList[i]); |
| } |
| }, |
| _buildAxisTick: function () { |
| var axShape; |
| var data = this._valueList; |
| var dataLength = this._valueList.length; |
| var tickOption = this.option.axisTick; |
| var length = tickOption.length; |
| var color = tickOption.lineStyle.color; |
| var lineWidth = tickOption.lineStyle.width; |
| if (this.isHorizontal()) { |
| var yPosition = this.option.position === 'bottom' ? tickOption.inside ? this.grid.getYend() - length - 1 : this.grid.getYend() + 1 : tickOption.inside ? this.grid.getY() + 1 : this.grid.getY() - length - 1; |
| var x; |
| for (var i = 0; i < dataLength; i++) { |
| x = this.subPixelOptimize(this.getCoord(data[i]), lineWidth); |
| axShape = { |
| _axisShape: 'axisTick', |
| zlevel: this._zlevelBase, |
| hoverable: false, |
| style: { |
| xStart: x, |
| yStart: yPosition, |
| xEnd: x, |
| yEnd: yPosition + length, |
| strokeColor: color, |
| lineWidth: lineWidth |
| } |
| }; |
| this.shapeList.push(new LineShape(axShape)); |
| } |
| } else { |
| var xPosition = this.option.position === 'left' ? tickOption.inside ? this.grid.getX() + 1 : this.grid.getX() - length - 1 : tickOption.inside ? this.grid.getXend() - length - 1 : this.grid.getXend() + 1; |
| var y; |
| for (var i = 0; i < dataLength; i++) { |
| y = this.subPixelOptimize(this.getCoord(data[i]), lineWidth); |
| axShape = { |
| _axisShape: 'axisTick', |
| zlevel: this._zlevelBase, |
| hoverable: false, |
| style: { |
| xStart: xPosition, |
| yStart: y, |
| xEnd: xPosition + length, |
| yEnd: y, |
| strokeColor: color, |
| lineWidth: lineWidth |
| } |
| }; |
| this.shapeList.push(new LineShape(axShape)); |
| } |
| } |
| }, |
| _buildAxisLabel: function () { |
| var axShape; |
| var data = this._valueList; |
| var dataLength = this._valueList.length; |
| var rotate = this.option.axisLabel.rotate; |
| var margin = this.option.axisLabel.margin; |
| var clickable = this.option.axisLabel.clickable; |
| var textStyle = this.option.axisLabel.textStyle; |
| if (this.isHorizontal()) { |
| var yPosition; |
| var baseLine; |
| if (this.option.position === 'bottom') { |
| yPosition = this.grid.getYend() + margin; |
| baseLine = 'top'; |
| } else { |
| yPosition = this.grid.getY() - margin; |
| baseLine = 'bottom'; |
| } |
| for (var i = 0; i < dataLength; i++) { |
| axShape = { |
| zlevel: this._zlevelBase, |
| hoverable: false, |
| style: { |
| x: this.getCoord(data[i]), |
| y: yPosition, |
| color: typeof textStyle.color === 'function' ? textStyle.color(data[i]) : textStyle.color, |
| text: this._valueLabel[i], |
| textFont: this.getFont(textStyle), |
| textAlign: textStyle.align || 'center', |
| textBaseline: textStyle.baseline || baseLine |
| } |
| }; |
| if (rotate) { |
| axShape.style.textAlign = rotate > 0 ? this.option.position === 'bottom' ? 'right' : 'left' : this.option.position === 'bottom' ? 'left' : 'right'; |
| axShape.rotation = [ |
| rotate * Math.PI / 180, |
| axShape.style.x, |
| axShape.style.y |
| ]; |
| } |
| this.shapeList.push(new TextShape(this._axisLabelClickable(clickable, axShape))); |
| } |
| } else { |
| var xPosition; |
| var align; |
| if (this.option.position === 'left') { |
| xPosition = this.grid.getX() - margin; |
| align = 'right'; |
| } else { |
| xPosition = this.grid.getXend() + margin; |
| align = 'left'; |
| } |
| for (var i = 0; i < dataLength; i++) { |
| axShape = { |
| zlevel: this._zlevelBase, |
| hoverable: false, |
| style: { |
| x: xPosition, |
| y: this.getCoord(data[i]), |
| color: typeof textStyle.color === 'function' ? textStyle.color(data[i]) : textStyle.color, |
| text: this._valueLabel[i], |
| textFont: this.getFont(textStyle), |
| textAlign: textStyle.align || align, |
| textBaseline: textStyle.baseline || i === 0 && this.option.name !== '' ? 'bottom' : i === dataLength - 1 && this.option.name !== '' ? 'top' : 'middle' |
| } |
| }; |
| if (rotate) { |
| axShape.rotation = [ |
| rotate * Math.PI / 180, |
| axShape.style.x, |
| axShape.style.y |
| ]; |
| } |
| this.shapeList.push(new TextShape(this._axisLabelClickable(clickable, axShape))); |
| } |
| } |
| }, |
| _buildSplitLine: function () { |
| var axShape; |
| var data = this._valueList; |
| var dataLength = this._valueList.length; |
| var sLineOption = this.option.splitLine; |
| var lineType = sLineOption.lineStyle.type; |
| var lineWidth = sLineOption.lineStyle.width; |
| var color = sLineOption.lineStyle.color; |
| color = color instanceof Array ? color : [color]; |
| var colorLength = color.length; |
| if (this.isHorizontal()) { |
| var sy = this.grid.getY(); |
| var ey = this.grid.getYend(); |
| var x; |
| for (var i = 0; i < dataLength; i++) { |
| x = this.subPixelOptimize(this.getCoord(data[i]), lineWidth); |
| axShape = { |
| zlevel: this._zlevelBase, |
| hoverable: false, |
| style: { |
| xStart: x, |
| yStart: sy, |
| xEnd: x, |
| yEnd: ey, |
| strokeColor: color[i % colorLength], |
| lineType: lineType, |
| lineWidth: lineWidth |
| } |
| }; |
| this.shapeList.push(new LineShape(axShape)); |
| } |
| } else { |
| var sx = this.grid.getX(); |
| var ex = this.grid.getXend(); |
| var y; |
| for (var i = 0; i < dataLength; i++) { |
| y = this.subPixelOptimize(this.getCoord(data[i]), lineWidth); |
| axShape = { |
| zlevel: this._zlevelBase, |
| hoverable: false, |
| style: { |
| xStart: sx, |
| yStart: y, |
| xEnd: ex, |
| yEnd: y, |
| strokeColor: color[i % colorLength], |
| lineType: lineType, |
| lineWidth: lineWidth |
| } |
| }; |
| this.shapeList.push(new LineShape(axShape)); |
| } |
| } |
| }, |
| _buildSplitArea: function () { |
| var axShape; |
| var color = this.option.splitArea.areaStyle.color; |
| if (!(color instanceof Array)) { |
| axShape = { |
| zlevel: this._zlevelBase, |
| hoverable: false, |
| style: { |
| x: this.grid.getX(), |
| y: this.grid.getY(), |
| width: this.grid.getWidth(), |
| height: this.grid.getHeight(), |
| color: color |
| } |
| }; |
| this.shapeList.push(new RectangleShape(axShape)); |
| } else { |
| var colorLength = color.length; |
| var data = this._valueList; |
| var dataLength = this._valueList.length; |
| if (this.isHorizontal()) { |
| var y = this.grid.getY(); |
| var height = this.grid.getHeight(); |
| var lastX = this.grid.getX(); |
| var curX; |
| for (var i = 0; i <= dataLength; i++) { |
| curX = i < dataLength ? this.getCoord(data[i]) : this.grid.getXend(); |
| axShape = { |
| zlevel: this._zlevelBase, |
| hoverable: false, |
| style: { |
| x: lastX, |
| y: y, |
| width: curX - lastX, |
| height: height, |
| color: color[i % colorLength] |
| } |
| }; |
| this.shapeList.push(new RectangleShape(axShape)); |
| lastX = curX; |
| } |
| } else { |
| var x = this.grid.getX(); |
| var width = this.grid.getWidth(); |
| var lastYend = this.grid.getYend(); |
| var curY; |
| for (var i = 0; i <= dataLength; i++) { |
| curY = i < dataLength ? this.getCoord(data[i]) : this.grid.getY(); |
| axShape = { |
| zlevel: this._zlevelBase, |
| hoverable: false, |
| style: { |
| x: x, |
| y: curY, |
| width: width, |
| height: lastYend - curY, |
| color: color[i % colorLength] |
| } |
| }; |
| this.shapeList.push(new RectangleShape(axShape)); |
| lastYend = curY; |
| } |
| } |
| } |
| }, |
| _calculateValue: function () { |
| if (isNaN(this.option.min - 0) || isNaN(this.option.max - 0)) { |
| var data = {}; |
| var xIdx; |
| var yIdx; |
| var legend = this.component.legend; |
| for (var i = 0, l = this.series.length; i < l; i++) { |
| if (this.series[i].type != ecConfig.CHART_TYPE_LINE && this.series[i].type != ecConfig.CHART_TYPE_BAR && this.series[i].type != ecConfig.CHART_TYPE_SCATTER && this.series[i].type != ecConfig.CHART_TYPE_K && this.series[i].type != ecConfig.CHART_TYPE_EVENTRIVER) { |
| continue; |
| } |
| if (legend && !legend.isSelected(this.series[i].name)) { |
| continue; |
| } |
| xIdx = this.series[i].xAxisIndex || 0; |
| yIdx = this.series[i].yAxisIndex || 0; |
| if (this.option.xAxisIndex != xIdx && this.option.yAxisIndex != yIdx) { |
| continue; |
| } |
| this._calculSum(data, i); |
| } |
| var oriData; |
| for (var i in data) { |
| oriData = data[i]; |
| for (var j = 0, k = oriData.length; j < k; j++) { |
| if (!isNaN(oriData[j])) { |
| this._hasData = true; |
| this._min = oriData[j]; |
| this._max = oriData[j]; |
| break; |
| } |
| } |
| if (this._hasData) { |
| break; |
| } |
| } |
| for (var i in data) { |
| oriData = data[i]; |
| for (var j = 0, k = oriData.length; j < k; j++) { |
| if (!isNaN(oriData[j])) { |
| this._min = Math.min(this._min, oriData[j]); |
| this._max = Math.max(this._max, oriData[j]); |
| } |
| } |
| } |
| var gap = Math.abs(this._max - this._min); |
| this._min = isNaN(this.option.min - 0) ? this._min - Math.abs(gap * this.option.boundaryGap[0]) : this.option.min - 0; |
| this._max = isNaN(this.option.max - 0) ? this._max + Math.abs(gap * this.option.boundaryGap[1]) : this.option.max - 0; |
| if (this._min === this._max) { |
| if (this._max === 0) { |
| this._max = 1; |
| } else if (this._max > 0) { |
| this._min = this._max / this.option.splitNumber != null ? this.option.splitNumber : 5; |
| } else { |
| this._max = this._max / this.option.splitNumber != null ? this.option.splitNumber : 5; |
| } |
| } |
| this.option.type != 'time' ? this._reformValue(this.option.scale) : this._reformTimeValue(); |
| } else { |
| this._hasData = true; |
| this._min = this.option.min - 0; |
| this._max = this.option.max - 0; |
| this.option.type != 'time' ? this._customerValue() : this._reformTimeValue(); |
| } |
| }, |
| _calculSum: function (data, i) { |
| var key = this.series[i].name || 'kener'; |
| var value; |
| var oriData; |
| if (!this.series[i].stack) { |
| data[key] = data[key] || []; |
| if (this.series[i].type != ecConfig.CHART_TYPE_EVENTRIVER) { |
| oriData = this.series[i].data; |
| for (var j = 0, k = oriData.length; j < k; j++) { |
| value = oriData[j].value != null ? oriData[j].value : oriData[j]; |
| if (this.series[i].type === ecConfig.CHART_TYPE_K) { |
| data[key].push(value[0]); |
| data[key].push(value[1]); |
| data[key].push(value[2]); |
| data[key].push(value[3]); |
| } else if (value instanceof Array) { |
| if (this.option.xAxisIndex != -1) { |
| data[key].push(this.option.type != 'time' ? value[0] : ecDate.getNewDate(value[0])); |
| } |
| if (this.option.yAxisIndex != -1) { |
| data[key].push(this.option.type != 'time' ? value[1] : ecDate.getNewDate(value[1])); |
| } |
| } else { |
| data[key].push(value); |
| } |
| } |
| } else { |
| oriData = this.series[i].eventList; |
| for (var j = 0, k = oriData.length; j < k; j++) { |
| var evolution = oriData[j].evolution; |
| for (var m = 0, n = evolution.length; m < n; m++) { |
| data[key].push(ecDate.getNewDate(evolution[m].time)); |
| } |
| } |
| } |
| } else { |
| var keyP = '__Magic_Key_Positive__' + this.series[i].stack; |
| var keyN = '__Magic_Key_Negative__' + this.series[i].stack; |
| data[keyP] = data[keyP] || []; |
| data[keyN] = data[keyN] || []; |
| data[key] = data[key] || []; |
| oriData = this.series[i].data; |
| for (var j = 0, k = oriData.length; j < k; j++) { |
| value = oriData[j].value != null ? oriData[j].value : oriData[j]; |
| if (value === '-') { |
| continue; |
| } |
| value = value - 0; |
| if (value >= 0) { |
| if (data[keyP][j] != null) { |
| data[keyP][j] += value; |
| } else { |
| data[keyP][j] = value; |
| } |
| } else { |
| if (data[keyN][j] != null) { |
| data[keyN][j] += value; |
| } else { |
| data[keyN][j] = value; |
| } |
| } |
| if (this.option.scale) { |
| data[key].push(value); |
| } |
| } |
| } |
| }, |
| _reformValue: function (scale) { |
| var smartSteps = require('../util/smartSteps'); |
| var splitNumber = this.option.splitNumber; |
| if (!scale && this._min >= 0 && this._max >= 0) { |
| this._min = 0; |
| } |
| if (!scale && this._min <= 0 && this._max <= 0) { |
| this._max = 0; |
| } |
| var stepOpt = smartSteps(this._min, this._max, splitNumber); |
| splitNumber = splitNumber != null ? splitNumber : stepOpt.secs; |
| this.option.splitNumber = splitNumber; |
| this._min = stepOpt.min; |
| this._max = stepOpt.max; |
| this._valueList = stepOpt.pnts; |
| this._reformLabelData(); |
| }, |
| _reformTimeValue: function () { |
| var splitNumber = this.option.splitNumber != null ? this.option.splitNumber : 5; |
| var curValue = ecDate.getAutoFormatter(this._min, this._max, splitNumber); |
| var formatter = curValue.formatter; |
| var gapValue = curValue.gapValue; |
| this._valueList = [ecDate.getNewDate(this._min)]; |
| var startGap; |
| switch (formatter) { |
| case 'week': |
| startGap = ecDate.nextMonday(this._min); |
| break; |
| case 'month': |
| startGap = ecDate.nextNthOnMonth(this._min, 1); |
| break; |
| case 'quarter': |
| startGap = ecDate.nextNthOnQuarterYear(this._min, 1); |
| break; |
| case 'half-year': |
| startGap = ecDate.nextNthOnHalfYear(this._min, 1); |
| break; |
| case 'year': |
| startGap = ecDate.nextNthOnYear(this._min, 1); |
| break; |
| default: |
| if (gapValue <= 3600000 * 2) { |
| startGap = (Math.floor(this._min / gapValue) + 1) * gapValue; |
| } else { |
| startGap = ecDate.getNewDate(this._min - -gapValue); |
| startGap.setHours(Math.round(startGap.getHours() / 6) * 6); |
| startGap.setMinutes(0); |
| startGap.setSeconds(0); |
| } |
| break; |
| } |
| if (startGap - this._min < gapValue / 2) { |
| startGap -= -gapValue; |
| } |
| curValue = ecDate.getNewDate(startGap); |
| splitNumber *= 1.5; |
| while (splitNumber-- >= 0) { |
| if (formatter == 'month' || formatter == 'quarter' || formatter == 'half-year' || formatter == 'year') { |
| curValue.setDate(1); |
| } |
| if (this._max - curValue < gapValue / 2) { |
| break; |
| } |
| this._valueList.push(curValue); |
| curValue = ecDate.getNewDate(curValue - -gapValue); |
| } |
| this._valueList.push(ecDate.getNewDate(this._max)); |
| this._reformLabelData(formatter); |
| }, |
| _customerValue: function () { |
| var accMath = require('../util/accMath'); |
| var splitNumber = this.option.splitNumber != null ? this.option.splitNumber : 5; |
| var splitGap = (this._max - this._min) / splitNumber; |
| this._valueList = []; |
| for (var i = 0; i <= splitNumber; i++) { |
| this._valueList.push(accMath.accAdd(this._min, accMath.accMul(splitGap, i))); |
| } |
| this._reformLabelData(); |
| }, |
| _reformLabelData: function (timeFormatter) { |
| this._valueLabel = []; |
| var formatter = this.option.axisLabel.formatter; |
| if (formatter) { |
| for (var i = 0, l = this._valueList.length; i < l; i++) { |
| if (typeof formatter === 'function') { |
| this._valueLabel.push(timeFormatter ? formatter.call(this.myChart, this._valueList[i], timeFormatter) : formatter.call(this.myChart, this._valueList[i])); |
| } else if (typeof formatter === 'string') { |
| this._valueLabel.push(timeFormatter ? ecDate.format(formatter, this._valueList[i]) : formatter.replace('{value}', this._valueList[i])); |
| } |
| } |
| } else if (timeFormatter) { |
| for (var i = 0, l = this._valueList.length; i < l; i++) { |
| this._valueLabel.push(ecDate.format(timeFormatter, this._valueList[i])); |
| } |
| } else { |
| for (var i = 0, l = this._valueList.length; i < l; i++) { |
| this._valueLabel.push(this.numAddCommas(this._valueList[i])); |
| } |
| } |
| }, |
| getExtremum: function () { |
| this._calculateValue(); |
| return { |
| min: this._min, |
| max: this._max |
| }; |
| }, |
| refresh: function (newOption, newSeries) { |
| if (newOption) { |
| this.option = this.reformOption(newOption); |
| this.option.axisLabel.textStyle = zrUtil.merge(this.option.axisLabel.textStyle || {}, this.ecTheme.textStyle); |
| this.series = newSeries; |
| } |
| if (this.zr) { |
| this.clear(); |
| this._buildShape(); |
| } |
| }, |
| getCoord: function (value) { |
| value = value < this._min ? this._min : value; |
| value = value > this._max ? this._max : value; |
| var result; |
| if (!this.isHorizontal()) { |
| result = this.grid.getYend() - (value - this._min) / (this._max - this._min) * this.grid.getHeight(); |
| } else { |
| result = this.grid.getX() + (value - this._min) / (this._max - this._min) * this.grid.getWidth(); |
| } |
| return result; |
| }, |
| getCoordSize: function (value) { |
| if (!this.isHorizontal()) { |
| return Math.abs(value / (this._max - this._min) * this.grid.getHeight()); |
| } else { |
| return Math.abs(value / (this._max - this._min) * this.grid.getWidth()); |
| } |
| }, |
| getValueFromCoord: function (coord) { |
| var result; |
| if (!this.isHorizontal()) { |
| coord = coord < this.grid.getY() ? this.grid.getY() : coord; |
| coord = coord > this.grid.getYend() ? this.grid.getYend() : coord; |
| result = this._max - (coord - this.grid.getY()) / this.grid.getHeight() * (this._max - this._min); |
| } else { |
| coord = coord < this.grid.getX() ? this.grid.getX() : coord; |
| coord = coord > this.grid.getXend() ? this.grid.getXend() : coord; |
| result = this._min + (coord - this.grid.getX()) / this.grid.getWidth() * (this._max - this._min); |
| } |
| return result.toFixed(2) - 0; |
| }, |
| isMaindAxis: function (value) { |
| for (var i = 0, l = this._valueList.length; i < l; i++) { |
| if (this._valueList[i] === value) { |
| return true; |
| } |
| } |
| return false; |
| } |
| }; |
| zrUtil.inherits(ValueAxis, Base); |
| require('../component').define('valueAxis', ValueAxis); |
| return ValueAxis; |
| });define('echarts/util/date', [], function () { |
| var _timeGap = [ |
| { |
| formatter: 'hh : mm : ss', |
| value: 1000 |
| }, |
| { |
| formatter: 'hh : mm : ss', |
| value: 1000 * 5 |
| }, |
| { |
| formatter: 'hh : mm : ss', |
| value: 1000 * 10 |
| }, |
| { |
| formatter: 'hh : mm : ss', |
| value: 1000 * 15 |
| }, |
| { |
| formatter: 'hh : mm : ss', |
| value: 1000 * 30 |
| }, |
| { |
| formatter: 'hh : mm\nMM - dd', |
| value: 60000 |
| }, |
| { |
| formatter: 'hh : mm\nMM - dd', |
| value: 60000 * 5 |
| }, |
| { |
| formatter: 'hh : mm\nMM - dd', |
| value: 60000 * 10 |
| }, |
| { |
| formatter: 'hh : mm\nMM - dd', |
| value: 60000 * 15 |
| }, |
| { |
| formatter: 'hh : mm\nMM - dd', |
| value: 60000 * 30 |
| }, |
| { |
| formatter: 'hh : mm\nMM - dd', |
| value: 3600000 |
| }, |
| { |
| formatter: 'hh : mm\nMM - dd', |
| value: 3600000 * 2 |
| }, |
| { |
| formatter: 'hh : mm\nMM - dd', |
| value: 3600000 * 6 |
| }, |
| { |
| formatter: 'hh : mm\nMM - dd', |
| value: 3600000 * 12 |
| }, |
| { |
| formatter: 'MM - dd\nyyyy', |
| value: 3600000 * 24 |
| }, |
| { |
| formatter: 'week', |
| value: 3600000 * 24 * 7 |
| }, |
| { |
| formatter: 'month', |
| value: 3600000 * 24 * 31 |
| }, |
| { |
| formatter: 'quarter', |
| value: 3600000 * 24 * 380 / 4 |
| }, |
| { |
| formatter: 'half-year', |
| value: 3600000 * 24 * 380 / 2 |
| }, |
| { |
| formatter: 'year', |
| value: 3600000 * 24 * 380 |
| } |
| ]; |
| function getAutoFormatter(min, max, splitNumber) { |
| splitNumber = splitNumber > 1 ? splitNumber : 2; |
| var curValue; |
| var totalGap; |
| var formatter; |
| var gapValue; |
| for (var i = 0, l = _timeGap.length; i < l; i++) { |
| curValue = _timeGap[i].value; |
| totalGap = Math.ceil(max / curValue) * curValue - Math.floor(min / curValue) * curValue; |
| if (Math.round(totalGap / curValue) <= splitNumber * 1.2) { |
| formatter = _timeGap[i].formatter; |
| gapValue = _timeGap[i].value; |
| break; |
| } |
| } |
| if (formatter == null) { |
| formatter = 'year'; |
| curValue = 3600000 * 24 * 367; |
| totalGap = Math.ceil(max / curValue) * curValue - Math.floor(min / curValue) * curValue; |
| gapValue = Math.round(totalGap / (splitNumber - 1) / curValue) * curValue; |
| } |
| return { |
| formatter: formatter, |
| gapValue: gapValue |
| }; |
| } |
| function s2d(v) { |
| return v < 10 ? '0' + v : v; |
| } |
| function format(formatter, value) { |
| if (formatter == 'week' || formatter == 'month' || formatter == 'quarter' || formatter == 'half-year' || formatter == 'year') { |
| formatter = 'MM - dd\nyyyy'; |
| } |
| var date = getNewDate(value); |
| var y = date.getFullYear(); |
| var M = date.getMonth() + 1; |
| var d = date.getDate(); |
| var h = date.getHours(); |
| var m = date.getMinutes(); |
| var s = date.getSeconds(); |
| formatter = formatter.replace('MM', s2d(M)); |
| formatter = formatter.toLowerCase(); |
| formatter = formatter.replace('yyyy', y); |
| formatter = formatter.replace('yy', y % 100); |
| formatter = formatter.replace('dd', s2d(d)); |
| formatter = formatter.replace('d', d); |
| formatter = formatter.replace('hh', s2d(h)); |
| formatter = formatter.replace('h', h); |
| formatter = formatter.replace('mm', s2d(m)); |
| formatter = formatter.replace('m', m); |
| formatter = formatter.replace('ss', s2d(s)); |
| formatter = formatter.replace('s', s); |
| return formatter; |
| } |
| function nextMonday(value) { |
| value = getNewDate(value); |
| value.setDate(value.getDate() + 8 - value.getDay()); |
| return value; |
| } |
| function nextNthPerNmonth(value, nth, nmon) { |
| value = getNewDate(value); |
| value.setMonth(Math.ceil((value.getMonth() + 1) / nmon) * nmon); |
| value.setDate(nth); |
| return value; |
| } |
| function nextNthOnMonth(value, nth) { |
| return nextNthPerNmonth(value, nth, 1); |
| } |
| function nextNthOnQuarterYear(value, nth) { |
| return nextNthPerNmonth(value, nth, 3); |
| } |
| function nextNthOnHalfYear(value, nth) { |
| return nextNthPerNmonth(value, nth, 6); |
| } |
| function nextNthOnYear(value, nth) { |
| return nextNthPerNmonth(value, nth, 12); |
| } |
| function getNewDate(value) { |
| return value instanceof Date ? value : new Date(typeof value == 'string' ? value.replace(/-/g, '/') : value); |
| } |
| return { |
| getAutoFormatter: getAutoFormatter, |
| getNewDate: getNewDate, |
| format: format, |
| nextMonday: nextMonday, |
| nextNthPerNmonth: nextNthPerNmonth, |
| nextNthOnMonth: nextNthOnMonth, |
| nextNthOnQuarterYear: nextNthOnQuarterYear, |
| nextNthOnHalfYear: nextNthOnHalfYear, |
| nextNthOnYear: nextNthOnYear |
| }; |
| });define('echarts/util/smartSteps', [], function () { |
| var mySteps = [ |
| 10, |
| 25, |
| 50 |
| ]; |
| var mySections = [ |
| 4, |
| 5, |
| 6 |
| ]; |
| var custOpts; |
| var custSteps; |
| var custSecs; |
| var minLocked; |
| var maxLocked; |
| var MT = Math; |
| var MATH_ROUND = MT.round; |
| var MATH_FLOOR = MT.floor; |
| var MATH_CEIL = MT.ceil; |
| var MATH_ABS = MT.abs; |
| function MATH_LOG(n) { |
| return MT.log(MATH_ABS(n)) / MT.LN10; |
| } |
| function MATH_POW(n) { |
| return MT.pow(10, n); |
| } |
| function MATH_ISINT(n) { |
| return n === MATH_FLOOR(n); |
| } |
| function smartSteps(min, max, section, opts) { |
| custOpts = opts || {}; |
| custSteps = custOpts.steps || mySteps; |
| custSecs = custOpts.secs || mySections; |
| section = MATH_ROUND(+section || 0) % 99; |
| min = +min || 0; |
| max = +max || 0; |
| minLocked = maxLocked = 0; |
| if ('min' in custOpts) { |
| min = +custOpts.min || 0; |
| minLocked = 1; |
| } |
| if ('max' in custOpts) { |
| max = +custOpts.max || 0; |
| maxLocked = 1; |
| } |
| if (min > max) { |
| max = [ |
| min, |
| min = max |
| ][0]; |
| } |
| var span = max - min; |
| if (minLocked && maxLocked) { |
| return bothLocked(min, max, section); |
| } |
| if (span < (section || 5)) { |
| if (MATH_ISINT(min) && MATH_ISINT(max)) { |
| return forInteger(min, max, section); |
| } else if (span === 0) { |
| return forSpan0(min, max, section); |
| } |
| } |
| return coreCalc(min, max, section); |
| } |
| function makeResult(newMin, newMax, section, expon) { |
| expon = expon || 0; |
| var expStep = expNum((newMax - newMin) / section, -1); |
| var expMin = expNum(newMin, -1, 1); |
| var expMax = expNum(newMax, -1); |
| var minExp = MT.min(expStep.e, expMin.e, expMax.e); |
| expFixTo(expStep, { |
| c: 0, |
| e: minExp |
| }); |
| expFixTo(expMin, expStep, 1); |
| expFixTo(expMax, expStep); |
| expon += minExp; |
| newMin = expMin.c; |
| newMax = expMax.c; |
| var step = (newMax - newMin) / section; |
| var zoom = MATH_POW(expon); |
| var fixTo = 0; |
| var points = []; |
| for (var i = section + 1; i--;) { |
| points[i] = (newMin + step * i) * zoom; |
| } |
| if (expon < 0) { |
| fixTo = decimals(zoom); |
| step = +(step * zoom).toFixed(fixTo); |
| newMin = +(newMin * zoom).toFixed(fixTo); |
| newMax = +(newMax * zoom).toFixed(fixTo); |
| for (var i = points.length; i--;) { |
| points[i] = points[i].toFixed(fixTo); |
| +points[i] === 0 && (points[i] = '0'); |
| } |
| } else { |
| newMin *= zoom; |
| newMax *= zoom; |
| step *= zoom; |
| } |
| custSecs = 0; |
| custSteps = 0; |
| custOpts = 0; |
| return { |
| min: newMin, |
| max: newMax, |
| secs: section, |
| step: step, |
| fix: fixTo, |
| exp: expon, |
| pnts: points |
| }; |
| } |
| function expNum(num, digit, byFloor) { |
| digit = MATH_ROUND(digit % 10) || 2; |
| if (digit < 0) { |
| if (MATH_ISINT(num)) { |
| digit = ('' + MATH_ABS(num)).replace(/0+$/, '').length || 1; |
| } else { |
| num = num.toFixed(15).replace(/0+$/, ''); |
| digit = num.replace('.', '').replace(/^[-0]+/, '').length; |
| num = +num; |
| } |
| } |
| var expon = MATH_FLOOR(MATH_LOG(num)) - digit + 1; |
| var cNum = +(num * MATH_POW(-expon)).toFixed(15) || 0; |
| cNum = byFloor ? MATH_FLOOR(cNum) : MATH_CEIL(cNum); |
| !cNum && (expon = 0); |
| if (('' + MATH_ABS(cNum)).length > digit) { |
| expon += 1; |
| cNum /= 10; |
| } |
| return { |
| c: cNum, |
| e: expon |
| }; |
| } |
| function expFixTo(expnum1, expnum2, byFloor) { |
| var deltaExp = expnum2.e - expnum1.e; |
| if (deltaExp) { |
| expnum1.e += deltaExp; |
| expnum1.c *= MATH_POW(-deltaExp); |
| expnum1.c = byFloor ? MATH_FLOOR(expnum1.c) : MATH_CEIL(expnum1.c); |
| } |
| } |
| function expFixMin(expnum1, expnum2, byFloor) { |
| if (expnum1.e < expnum2.e) { |
| expFixTo(expnum2, expnum1, byFloor); |
| } else { |
| expFixTo(expnum1, expnum2, byFloor); |
| } |
| } |
| function getCeil(num, rounds) { |
| rounds = rounds || mySteps; |
| num = expNum(num); |
| var cNum = num.c; |
| var i = 0; |
| while (cNum > rounds[i]) { |
| i++; |
| } |
| if (!rounds[i]) { |
| cNum /= 10; |
| num.e += 1; |
| i = 0; |
| while (cNum > rounds[i]) { |
| i++; |
| } |
| } |
| num.c = rounds[i]; |
| return num; |
| } |
| function coreCalc(min, max, section) { |
| var step; |
| var secs = section || +custSecs.slice(-1); |
| var expStep = getCeil((max - min) / secs, custSteps); |
| var expSpan = expNum(max - min); |
| var expMin = expNum(min, -1, 1); |
| var expMax = expNum(max, -1); |
| expFixTo(expSpan, expStep); |
| expFixTo(expMin, expStep, 1); |
| expFixTo(expMax, expStep); |
| if (!section) { |
| secs = look4sections(expMin, expMax); |
| } else { |
| step = look4step(expMin, expMax, secs); |
| } |
| if (MATH_ISINT(min) && MATH_ISINT(max) && min * max >= 0) { |
| if (max - min < secs) { |
| return forInteger(min, max, secs); |
| } |
| secs = tryForInt(min, max, section, expMin, expMax, secs); |
| } |
| var arrMM = cross0(min, max, expMin.c, expMax.c); |
| expMin.c = arrMM[0]; |
| expMax.c = arrMM[1]; |
| if (minLocked || maxLocked) { |
| singleLocked(min, max, expMin, expMax); |
| } |
| return makeResult(expMin.c, expMax.c, secs, expMax.e); |
| } |
| function look4sections(expMin, expMax) { |
| var section; |
| var tmpStep, tmpMin, tmpMax; |
| var reference = []; |
| for (var i = custSecs.length; i--;) { |
| section = custSecs[i]; |
| tmpStep = getCeil((expMax.c - expMin.c) / section, custSteps); |
| tmpStep = tmpStep.c * MATH_POW(tmpStep.e); |
| tmpMin = MATH_FLOOR(expMin.c / tmpStep) * tmpStep; |
| tmpMax = MATH_CEIL(expMax.c / tmpStep) * tmpStep; |
| reference[i] = { |
| min: tmpMin, |
| max: tmpMax, |
| step: tmpStep, |
| span: tmpMax - tmpMin |
| }; |
| } |
| reference.sort(function (a, b) { |
| return a.span - b.span; |
| }); |
| reference = reference[0]; |
| section = reference.span / reference.step; |
| expMin.c = reference.min; |
| expMax.c = reference.max; |
| return section < 3 ? section * 2 : section; |
| } |
| function look4step(expMin, expMax, secs) { |
| var span; |
| var tmpMax; |
| var tmpMin = expMax.c; |
| var tmpStep = (expMax.c - expMin.c) / secs - 1; |
| while (tmpMin > expMin.c) { |
| tmpStep = getCeil(tmpStep + 1, custSteps); |
| tmpStep = tmpStep.c * MATH_POW(tmpStep.e); |
| span = tmpStep * secs; |
| tmpMax = MATH_CEIL(expMax.c / tmpStep) * tmpStep; |
| tmpMin = tmpMax - span; |
| } |
| var deltaMin = expMin.c - tmpMin; |
| var deltaMax = tmpMax - expMax.c; |
| var deltaDelta = deltaMin - deltaMax; |
| if (deltaDelta >= tmpStep * 2) { |
| deltaDelta = MATH_FLOOR(deltaDelta / tmpStep) * tmpStep; |
| tmpMin += deltaDelta; |
| tmpMax += deltaDelta; |
| } |
| expMin.c = tmpMin; |
| expMax.c = tmpMax; |
| return tmpStep; |
| } |
| function tryForInt(min, max, section, expMin, expMax, secs) { |
| var span = expMax.c - expMin.c; |
| var step = span / secs * MATH_POW(expMax.e); |
| if (!MATH_ISINT(step)) { |
| step = MATH_FLOOR(step); |
| span = step * secs; |
| if (span < max - min) { |
| step += 1; |
| span = step * secs; |
| if (!section && step * (secs - 1) >= max - min) { |
| secs -= 1; |
| span = step * secs; |
| } |
| } |
| if (span >= max - min) { |
| var delta = span - (max - min); |
| expMin.c = MATH_ROUND(min - delta / 2); |
| expMax.c = MATH_ROUND(max + delta / 2); |
| expMin.e = 0; |
| expMax.e = 0; |
| } |
| } |
| return secs; |
| } |
| function forInteger(min, max, section) { |
| section = section || 5; |
| if (minLocked) { |
| max = min + section; |
| } else if (maxLocked) { |
| min = max - section; |
| } else { |
| var delta = section - (max - min); |
| var newMin = MATH_ROUND(min - delta / 2); |
| var newMax = MATH_ROUND(max + delta / 2); |
| var arrMM = cross0(min, max, newMin, newMax); |
| min = arrMM[0]; |
| max = arrMM[1]; |
| } |
| return makeResult(min, max, section); |
| } |
| function forSpan0(min, max, section) { |
| section = section || 5; |
| var delta = MT.min(MATH_ABS(max / section), section) / 2.1; |
| if (minLocked) { |
| max = min + delta; |
| } else if (maxLocked) { |
| min = max - delta; |
| } else { |
| min = min - delta; |
| max = max + delta; |
| } |
| return coreCalc(min, max, section); |
| } |
| function cross0(min, max, newMin, newMax) { |
| if (min >= 0 && newMin < 0) { |
| newMax -= newMin; |
| newMin = 0; |
| } else if (max <= 0 && newMax > 0) { |
| newMin -= newMax; |
| newMax = 0; |
| } |
| return [ |
| newMin, |
| newMax |
| ]; |
| } |
| function decimals(num) { |
| num = (+num).toFixed(15).split('.'); |
| return num.pop().replace(/0+$/, '').length; |
| } |
| function singleLocked(min, max, emin, emax) { |
| if (minLocked) { |
| var expMin = expNum(min, 4, 1); |
| if (emin.e - expMin.e > 6) { |
| expMin = { |
| c: 0, |
| e: emin.e |
| }; |
| } |
| expFixMin(emin, expMin); |
| expFixMin(emax, expMin); |
| emax.c += expMin.c - emin.c; |
| emin.c = expMin.c; |
| } else if (maxLocked) { |
| var expMax = expNum(max, 4); |
| if (emax.e - expMax.e > 6) { |
| expMax = { |
| c: 0, |
| e: emax.e |
| }; |
| } |
| expFixMin(emin, expMax); |
| expFixMin(emax, expMax); |
| emin.c += expMax.c - emax.c; |
| emax.c = expMax.c; |
| } |
| } |
| function bothLocked(min, max, section) { |
| var trySecs = section ? [section] : custSecs; |
| var span = max - min; |
| if (span === 0) { |
| max = expNum(max, 3); |
| section = trySecs[0]; |
| max.c = MATH_ROUND(max.c + section / 2); |
| return makeResult(max.c - section, max.c, section, max.e); |
| } |
| if (MATH_ABS(max / span) < 0.000001) { |
| max = 0; |
| } |
| if (MATH_ABS(min / span) < 0.000001) { |
| min = 0; |
| } |
| var step, deltaSpan, score; |
| var scoreS = [ |
| [ |
| 5, |
| 10 |
| ], |
| [ |
| 10, |
| 2 |
| ], |
| [ |
| 50, |
| 10 |
| ], |
| [ |
| 100, |
| 2 |
| ] |
| ]; |
| var reference = []; |
| var debugLog = []; |
| var expSpan = expNum(max - min, 3); |
| var expMin = expNum(min, -1, 1); |
| var expMax = expNum(max, -1); |
| expFixTo(expMin, expSpan, 1); |
| expFixTo(expMax, expSpan); |
| span = expMax.c - expMin.c; |
| expSpan.c = span; |
| for (var i = trySecs.length; i--;) { |
| section = trySecs[i]; |
| step = MATH_CEIL(span / section); |
| deltaSpan = step * section - span; |
| score = (deltaSpan + 3) * 3; |
| score += (section - trySecs[0] + 2) * 2; |
| if (section % 5 === 0) { |
| score -= 10; |
| } |
| for (var j = scoreS.length; j--;) { |
| if (step % scoreS[j][0] === 0) { |
| score /= scoreS[j][1]; |
| } |
| } |
| debugLog[i] = [ |
| section, |
| step, |
| deltaSpan, |
| score |
| ].join(); |
| reference[i] = { |
| secs: section, |
| step: step, |
| delta: deltaSpan, |
| score: score |
| }; |
| } |
| reference.sort(function (a, b) { |
| return a.score - b.score; |
| }); |
| reference = reference[0]; |
| expMin.c = MATH_ROUND(expMin.c - reference.delta / 2); |
| expMax.c = MATH_ROUND(expMax.c + reference.delta / 2); |
| return makeResult(expMin.c, expMax.c, reference.secs, expSpan.e); |
| } |
| return smartSteps; |
| });define('echarts/chart/line', [ |
| 'require', |
| '../component/base', |
| './base', |
| 'zrender/shape/BrokenLine', |
| '../util/shape/Icon', |
| '../util/shape/HalfSmoothPolygon', |
| '../component/axis', |
| '../component/grid', |
| '../component/dataZoom', |
| '../config', |
| '../util/ecData', |
| 'zrender/tool/util', |
| 'zrender/tool/color', |
| '../chart' |
| ], function (require) { |
| var ComponentBase = require('../component/base'); |
| var ChartBase = require('./base'); |
| var BrokenLineShape = require('zrender/shape/BrokenLine'); |
| var IconShape = require('../util/shape/Icon'); |
| var HalfSmoothPolygonShape = require('../util/shape/HalfSmoothPolygon'); |
| require('../component/axis'); |
| require('../component/grid'); |
| require('../component/dataZoom'); |
| var ecConfig = require('../config'); |
| var ecData = require('../util/ecData'); |
| var zrUtil = require('zrender/tool/util'); |
| var zrColor = require('zrender/tool/color'); |
| function Line(ecTheme, messageCenter, zr, option, myChart) { |
| ComponentBase.call(this, ecTheme, messageCenter, zr, option, myChart); |
| ChartBase.call(this); |
| this.refresh(option); |
| } |
| Line.prototype = { |
| type: ecConfig.CHART_TYPE_LINE, |
| _buildShape: function () { |
| this.finalPLMap = {}; |
| this._bulidPosition(); |
| }, |
| _buildHorizontal: function (seriesArray, maxDataLength, locationMap, xMarkMap) { |
| var series = this.series; |
| var seriesIndex = locationMap[0][0]; |
| var serie = series[seriesIndex]; |
| var xAxisIndex = serie.xAxisIndex; |
| var categoryAxis = this.component.xAxis.getAxis(xAxisIndex); |
| var yAxisIndex; |
| var valueAxis; |
| var x; |
| var y; |
| var lastYP; |
| var baseYP; |
| var lastYN; |
| var baseYN; |
| var curPLMap = {}; |
| var data; |
| var value; |
| for (var i = 0, l = maxDataLength; i < l; i++) { |
| if (categoryAxis.getNameByIndex(i) == null) { |
| break; |
| } |
| x = categoryAxis.getCoordByIndex(i); |
| for (var j = 0, k = locationMap.length; j < k; j++) { |
| yAxisIndex = series[locationMap[j][0]].yAxisIndex || 0; |
| valueAxis = this.component.yAxis.getAxis(yAxisIndex); |
| baseYP = lastYP = baseYN = lastYN = valueAxis.getCoord(0); |
| for (var m = 0, n = locationMap[j].length; m < n; m++) { |
| seriesIndex = locationMap[j][m]; |
| serie = series[seriesIndex]; |
| data = serie.data[i]; |
| value = data != null ? data.value != null ? data.value : data : '-'; |
| curPLMap[seriesIndex] = curPLMap[seriesIndex] || []; |
| xMarkMap[seriesIndex] = xMarkMap[seriesIndex] || { |
| min: Number.POSITIVE_INFINITY, |
| max: Number.NEGATIVE_INFINITY, |
| sum: 0, |
| counter: 0, |
| average: 0 |
| }; |
| if (value === '-') { |
| if (curPLMap[seriesIndex].length > 0) { |
| this.finalPLMap[seriesIndex] = this.finalPLMap[seriesIndex] || []; |
| this.finalPLMap[seriesIndex].push(curPLMap[seriesIndex]); |
| curPLMap[seriesIndex] = []; |
| } |
| continue; |
| } |
| if (value >= 0) { |
| lastYP -= m > 0 ? valueAxis.getCoordSize(value) : baseYP - valueAxis.getCoord(value); |
| y = lastYP; |
| } else if (value < 0) { |
| lastYN += m > 0 ? valueAxis.getCoordSize(value) : valueAxis.getCoord(value) - baseYN; |
| y = lastYN; |
| } |
| curPLMap[seriesIndex].push([ |
| x, |
| y, |
| i, |
| categoryAxis.getNameByIndex(i), |
| x, |
| baseYP |
| ]); |
| if (xMarkMap[seriesIndex].min > value) { |
| xMarkMap[seriesIndex].min = value; |
| xMarkMap[seriesIndex].minY = y; |
| xMarkMap[seriesIndex].minX = x; |
| } |
| if (xMarkMap[seriesIndex].max < value) { |
| xMarkMap[seriesIndex].max = value; |
| xMarkMap[seriesIndex].maxY = y; |
| xMarkMap[seriesIndex].maxX = x; |
| } |
| xMarkMap[seriesIndex].sum += value; |
| xMarkMap[seriesIndex].counter++; |
| } |
| } |
| lastYP = this.component.grid.getY(); |
| var symbolSize; |
| for (var j = 0, k = locationMap.length; j < k; j++) { |
| for (var m = 0, n = locationMap[j].length; m < n; m++) { |
| seriesIndex = locationMap[j][m]; |
| serie = series[seriesIndex]; |
| data = serie.data[i]; |
| value = data != null ? data.value != null ? data.value : data : '-'; |
| if (value != '-') { |
| continue; |
| } |
| if (this.deepQuery([ |
| data, |
| serie, |
| this.option |
| ], 'calculable')) { |
| symbolSize = this.deepQuery([ |
| data, |
| serie |
| ], 'symbolSize'); |
| lastYP += symbolSize * 2 + 5; |
| y = lastYP; |
| this.shapeList.push(this._getCalculableItem(seriesIndex, i, categoryAxis.getNameByIndex(i), x, y, 'horizontal')); |
| } |
| } |
| } |
| } |
| for (var sId in curPLMap) { |
| if (curPLMap[sId].length > 0) { |
| this.finalPLMap[sId] = this.finalPLMap[sId] || []; |
| this.finalPLMap[sId].push(curPLMap[sId]); |
| curPLMap[sId] = []; |
| } |
| } |
| this._calculMarkMapXY(xMarkMap, locationMap, 'y'); |
| this._buildBorkenLine(seriesArray, this.finalPLMap, categoryAxis, 'horizontal'); |
| }, |
| _buildVertical: function (seriesArray, maxDataLength, locationMap, xMarkMap) { |
| var series = this.series; |
| var seriesIndex = locationMap[0][0]; |
| var serie = series[seriesIndex]; |
| var yAxisIndex = serie.yAxisIndex; |
| var categoryAxis = this.component.yAxis.getAxis(yAxisIndex); |
| var xAxisIndex; |
| var valueAxis; |
| var x; |
| var y; |
| var lastXP; |
| var baseXP; |
| var lastXN; |
| var baseXN; |
| var curPLMap = {}; |
| var data; |
| var value; |
| for (var i = 0, l = maxDataLength; i < l; i++) { |
| if (categoryAxis.getNameByIndex(i) == null) { |
| break; |
| } |
| y = categoryAxis.getCoordByIndex(i); |
| for (var j = 0, k = locationMap.length; j < k; j++) { |
| xAxisIndex = series[locationMap[j][0]].xAxisIndex || 0; |
| valueAxis = this.component.xAxis.getAxis(xAxisIndex); |
| baseXP = lastXP = baseXN = lastXN = valueAxis.getCoord(0); |
| for (var m = 0, n = locationMap[j].length; m < n; m++) { |
| seriesIndex = locationMap[j][m]; |
| serie = series[seriesIndex]; |
| data = serie.data[i]; |
| value = data != null ? data.value != null ? data.value : data : '-'; |
| curPLMap[seriesIndex] = curPLMap[seriesIndex] || []; |
| xMarkMap[seriesIndex] = xMarkMap[seriesIndex] || { |
| min: Number.POSITIVE_INFINITY, |
| max: Number.NEGATIVE_INFINITY, |
| sum: 0, |
| counter: 0, |
| average: 0 |
| }; |
| if (value === '-') { |
| if (curPLMap[seriesIndex].length > 0) { |
| this.finalPLMap[seriesIndex] = this.finalPLMap[seriesIndex] || []; |
| this.finalPLMap[seriesIndex].push(curPLMap[seriesIndex]); |
| curPLMap[seriesIndex] = []; |
| } |
| continue; |
| } |
| if (value >= 0) { |
| lastXP += m > 0 ? valueAxis.getCoordSize(value) : valueAxis.getCoord(value) - baseXP; |
| x = lastXP; |
| } else if (value < 0) { |
| lastXN -= m > 0 ? valueAxis.getCoordSize(value) : baseXN - valueAxis.getCoord(value); |
| x = lastXN; |
| } |
| curPLMap[seriesIndex].push([ |
| x, |
| y, |
| i, |
| categoryAxis.getNameByIndex(i), |
| baseXP, |
| y |
| ]); |
| if (xMarkMap[seriesIndex].min > value) { |
| xMarkMap[seriesIndex].min = value; |
| xMarkMap[seriesIndex].minX = x; |
| xMarkMap[seriesIndex].minY = y; |
| } |
| if (xMarkMap[seriesIndex].max < value) { |
| xMarkMap[seriesIndex].max = value; |
| xMarkMap[seriesIndex].maxX = x; |
| xMarkMap[seriesIndex].maxY = y; |
| } |
| xMarkMap[seriesIndex].sum += value; |
| xMarkMap[seriesIndex].counter++; |
| } |
| } |
| lastXP = this.component.grid.getXend(); |
| var symbolSize; |
| for (var j = 0, k = locationMap.length; j < k; j++) { |
| for (var m = 0, n = locationMap[j].length; m < n; m++) { |
| seriesIndex = locationMap[j][m]; |
| serie = series[seriesIndex]; |
| data = serie.data[i]; |
| value = data != null ? data.value != null ? data.value : data : '-'; |
| if (value != '-') { |
| continue; |
| } |
| if (this.deepQuery([ |
| data, |
| serie, |
| this.option |
| ], 'calculable')) { |
| symbolSize = this.deepQuery([ |
| data, |
| serie |
| ], 'symbolSize'); |
| lastXP -= symbolSize * 2 + 5; |
| x = lastXP; |
| this.shapeList.push(this._getCalculableItem(seriesIndex, i, categoryAxis.getNameByIndex(i), x, y, 'vertical')); |
| } |
| } |
| } |
| } |
| for (var sId in curPLMap) { |
| if (curPLMap[sId].length > 0) { |
| this.finalPLMap[sId] = this.finalPLMap[sId] || []; |
| this.finalPLMap[sId].push(curPLMap[sId]); |
| curPLMap[sId] = []; |
| } |
| } |
| this._calculMarkMapXY(xMarkMap, locationMap, 'x'); |
| this._buildBorkenLine(seriesArray, this.finalPLMap, categoryAxis, 'vertical'); |
| }, |
| _buildOther: function (seriesArray, maxDataLength, locationMap, xMarkMap) { |
| var series = this.series; |
| var curPLMap = {}; |
| var xAxis; |
| var yAxis; |
| for (var j = 0, k = locationMap.length; j < k; j++) { |
| for (var m = 0, n = locationMap[j].length; m < n; m++) { |
| var seriesIndex = locationMap[j][m]; |
| var serie = series[seriesIndex]; |
| var xAxisIndex = serie.xAxisIndex || 0; |
| xAxis = this.component.xAxis.getAxis(xAxisIndex); |
| var yAxisIndex = serie.yAxisIndex || 0; |
| yAxis = this.component.yAxis.getAxis(yAxisIndex); |
| var baseY = yAxis.getCoord(0); |
| curPLMap[seriesIndex] = curPLMap[seriesIndex] || []; |
| xMarkMap[seriesIndex] = xMarkMap[seriesIndex] || { |
| min0: Number.POSITIVE_INFINITY, |
| min1: Number.POSITIVE_INFINITY, |
| max0: Number.NEGATIVE_INFINITY, |
| max1: Number.NEGATIVE_INFINITY, |
| sum0: 0, |
| sum1: 0, |
| counter0: 0, |
| counter1: 0, |
| average0: 0, |
| average1: 0 |
| }; |
| for (var i = 0, l = serie.data.length; i < l; i++) { |
| var data = serie.data[i]; |
| var value = data != null ? data.value != null ? data.value : data : '-'; |
| if (!(value instanceof Array)) { |
| continue; |
| } |
| var x = xAxis.getCoord(value[0]); |
| var y = yAxis.getCoord(value[1]); |
| curPLMap[seriesIndex].push([ |
| x, |
| y, |
| i, |
| value[0], |
| x, |
| baseY |
| ]); |
| if (xMarkMap[seriesIndex].min0 > value[0]) { |
| xMarkMap[seriesIndex].min0 = value[0]; |
| xMarkMap[seriesIndex].minY0 = y; |
| xMarkMap[seriesIndex].minX0 = x; |
| } |
| if (xMarkMap[seriesIndex].max0 < value[0]) { |
| xMarkMap[seriesIndex].max0 = value[0]; |
| xMarkMap[seriesIndex].maxY0 = y; |
| xMarkMap[seriesIndex].maxX0 = x; |
| } |
| xMarkMap[seriesIndex].sum0 += value[0]; |
| xMarkMap[seriesIndex].counter0++; |
| if (xMarkMap[seriesIndex].min1 > value[1]) { |
| xMarkMap[seriesIndex].min1 = value[1]; |
| xMarkMap[seriesIndex].minY1 = y; |
| xMarkMap[seriesIndex].minX1 = x; |
| } |
| if (xMarkMap[seriesIndex].max1 < value[1]) { |
| xMarkMap[seriesIndex].max1 = value[1]; |
| xMarkMap[seriesIndex].maxY1 = y; |
| xMarkMap[seriesIndex].maxX1 = x; |
| } |
| xMarkMap[seriesIndex].sum1 += value[1]; |
| xMarkMap[seriesIndex].counter1++; |
| } |
| } |
| } |
| for (var sId in curPLMap) { |
| if (curPLMap[sId].length > 0) { |
| this.finalPLMap[sId] = this.finalPLMap[sId] || []; |
| this.finalPLMap[sId].push(curPLMap[sId]); |
| curPLMap[sId] = []; |
| } |
| } |
| this._calculMarkMapXY(xMarkMap, locationMap, 'xy'); |
| this._buildBorkenLine(seriesArray, this.finalPLMap, xAxis, 'other'); |
| }, |
| _buildBorkenLine: function (seriesArray, pointList, categoryAxis, curOrient) { |
| var orient = curOrient == 'other' ? 'horizontal' : curOrient; |
| var series = this.series; |
| var data; |
| for (var sIdx = seriesArray.length - 1; sIdx >= 0; sIdx--) { |
| var seriesIndex = seriesArray[sIdx]; |
| var serie = series[seriesIndex]; |
| var seriesPL = pointList[seriesIndex]; |
| if (serie.type === this.type && seriesPL != null) { |
| var bbox = this._getBbox(seriesIndex, orient); |
| var defaultColor = this._sIndex2ColorMap[seriesIndex]; |
| var lineWidth = this.query(serie, 'itemStyle.normal.lineStyle.width'); |
| var lineType = this.query(serie, 'itemStyle.normal.lineStyle.type'); |
| var lineColor = this.query(serie, 'itemStyle.normal.lineStyle.color'); |
| var normalColor = this.getItemStyleColor(this.query(serie, 'itemStyle.normal.color'), seriesIndex, -1); |
| var isFill = this.query(serie, 'itemStyle.normal.areaStyle') != null; |
| var fillNormalColor = this.query(serie, 'itemStyle.normal.areaStyle.color'); |
| for (var i = 0, l = seriesPL.length; i < l; i++) { |
| var singlePL = seriesPL[i]; |
| var isLarge = curOrient != 'other' && this._isLarge(orient, singlePL); |
| if (!isLarge) { |
| for (var j = 0, k = singlePL.length; j < k; j++) { |
| data = serie.data[singlePL[j][2]]; |
| if (this.deepQuery([ |
| data, |
| serie, |
| this.option |
| ], 'calculable') || this.deepQuery([ |
| data, |
| serie |
| ], 'showAllSymbol') || categoryAxis.type === 'categoryAxis' && categoryAxis.isMainAxis(singlePL[j][2]) && this.deepQuery([ |
| data, |
| serie |
| ], 'symbol') != 'none') { |
| this.shapeList.push(this._getSymbol(seriesIndex, singlePL[j][2], singlePL[j][3], singlePL[j][0], singlePL[j][1], orient)); |
| } |
| } |
| } else { |
| singlePL = this._getLargePointList(orient, singlePL); |
| } |
| var brokenLineShape = new BrokenLineShape({ |
| zlevel: this._zlevelBase, |
| style: { |
| miterLimit: lineWidth, |
| pointList: singlePL, |
| strokeColor: lineColor || normalColor || defaultColor, |
| lineWidth: lineWidth, |
| lineType: lineType, |
| smooth: this._getSmooth(serie.smooth), |
| smoothConstraint: bbox, |
| shadowColor: this.query(serie, 'itemStyle.normal.lineStyle.shadowColor'), |
| shadowBlur: this.query(serie, 'itemStyle.normal.lineStyle.shadowBlur'), |
| shadowOffsetX: this.query(serie, 'itemStyle.normal.lineStyle.shadowOffsetX'), |
| shadowOffsetY: this.query(serie, 'itemStyle.normal.lineStyle.shadowOffsetY') |
| }, |
| hoverable: false, |
| _main: true, |
| _seriesIndex: seriesIndex, |
| _orient: orient |
| }); |
| ecData.pack(brokenLineShape, series[seriesIndex], seriesIndex, 0, i, series[seriesIndex].name); |
| this.shapeList.push(brokenLineShape); |
| if (isFill) { |
| var halfSmoothPolygonShape = new HalfSmoothPolygonShape({ |
| zlevel: this._zlevelBase, |
| style: { |
| miterLimit: lineWidth, |
| pointList: zrUtil.clone(singlePL).concat([ |
| [ |
| singlePL[singlePL.length - 1][4], |
| singlePL[singlePL.length - 1][5] |
| ], |
| [ |
| singlePL[0][4], |
| singlePL[0][5] |
| ] |
| ]), |
| brushType: 'fill', |
| smooth: this._getSmooth(serie.smooth), |
| smoothConstraint: bbox, |
| color: fillNormalColor ? fillNormalColor : zrColor.alpha(defaultColor, 0.5) |
| }, |
| highlightStyle: { brushType: 'fill' }, |
| hoverable: false, |
| _main: true, |
| _seriesIndex: seriesIndex, |
| _orient: orient |
| }); |
| ecData.pack(halfSmoothPolygonShape, series[seriesIndex], seriesIndex, 0, i, series[seriesIndex].name); |
| this.shapeList.push(halfSmoothPolygonShape); |
| } |
| } |
| } |
| } |
| }, |
| _getBbox: function (seriesIndex, orient) { |
| var bbox = this.component.grid.getBbox(); |
| var xMarkMap = this.xMarkMap[seriesIndex]; |
| if (xMarkMap.minX0 != null) { |
| return [ |
| [ |
| Math.min(xMarkMap.minX0, xMarkMap.maxX0, xMarkMap.minX1, xMarkMap.maxX1), |
| Math.min(xMarkMap.minY0, xMarkMap.maxY0, xMarkMap.minY1, xMarkMap.maxY1) |
| ], |
| [ |
| Math.max(xMarkMap.minX0, xMarkMap.maxX0, xMarkMap.minX1, xMarkMap.maxX1), |
| Math.max(xMarkMap.minY0, xMarkMap.maxY0, xMarkMap.minY1, xMarkMap.maxY1) |
| ] |
| ]; |
| } else if (orient === 'horizontal') { |
| bbox[0][1] = Math.min(xMarkMap.minY, xMarkMap.maxY); |
| bbox[1][1] = Math.max(xMarkMap.minY, xMarkMap.maxY); |
| } else { |
| bbox[0][0] = Math.min(xMarkMap.minX, xMarkMap.maxX); |
| bbox[1][0] = Math.max(xMarkMap.minX, xMarkMap.maxX); |
| } |
| return bbox; |
| }, |
| _isLarge: function (orient, singlePL) { |
| if (singlePL.length < 2) { |
| return false; |
| } else { |
| return orient === 'horizontal' ? Math.abs(singlePL[0][0] - singlePL[1][0]) < 0.5 : Math.abs(singlePL[0][1] - singlePL[1][1]) < 0.5; |
| } |
| }, |
| _getLargePointList: function (orient, singlePL) { |
| var total; |
| if (orient === 'horizontal') { |
| total = this.component.grid.getWidth(); |
| } else { |
| total = this.component.grid.getHeight(); |
| } |
| var len = singlePL.length; |
| var newList = []; |
| for (var i = 0; i < total; i++) { |
| newList[i] = singlePL[Math.floor(len / total * i)]; |
| } |
| return newList; |
| }, |
| _getSmooth: function (isSmooth) { |
| if (isSmooth) { |
| return 0.3; |
| } else { |
| return 0; |
| } |
| }, |
| _getCalculableItem: function (seriesIndex, dataIndex, name, x, y, orient) { |
| var series = this.series; |
| var color = series[seriesIndex].calculableHolderColor || this.ecTheme.calculableHolderColor; |
| var itemShape = this._getSymbol(seriesIndex, dataIndex, name, x, y, orient); |
| itemShape.style.color = color; |
| itemShape.style.strokeColor = color; |
| itemShape.rotation = [ |
| 0, |
| 0 |
| ]; |
| itemShape.hoverable = false; |
| itemShape.draggable = false; |
| itemShape.style.text = undefined; |
| return itemShape; |
| }, |
| _getSymbol: function (seriesIndex, dataIndex, name, x, y, orient) { |
| var series = this.series; |
| var serie = series[seriesIndex]; |
| var data = serie.data[dataIndex]; |
| var itemShape = this.getSymbolShape(serie, seriesIndex, data, dataIndex, name, x, y, this._sIndex2ShapeMap[seriesIndex], this._sIndex2ColorMap[seriesIndex], '#fff', orient === 'vertical' ? 'horizontal' : 'vertical'); |
| itemShape.zlevel = this._zlevelBase + 1; |
| if (this.deepQuery([ |
| data, |
| serie, |
| this.option |
| ], 'calculable')) { |
| this.setCalculable(itemShape); |
| itemShape.draggable = true; |
| } |
| return itemShape; |
| }, |
| getMarkCoord: function (seriesIndex, mpData) { |
| var serie = this.series[seriesIndex]; |
| var xMarkMap = this.xMarkMap[seriesIndex]; |
| var xAxis = this.component.xAxis.getAxis(serie.xAxisIndex); |
| var yAxis = this.component.yAxis.getAxis(serie.yAxisIndex); |
| if (mpData.type && (mpData.type === 'max' || mpData.type === 'min' || mpData.type === 'average')) { |
| var valueIndex = mpData.valueIndex != null ? mpData.valueIndex : xMarkMap.maxX0 != null ? '1' : ''; |
| return [ |
| xMarkMap[mpData.type + 'X' + valueIndex], |
| xMarkMap[mpData.type + 'Y' + valueIndex], |
| xMarkMap[mpData.type + 'Line' + valueIndex], |
| xMarkMap[mpData.type + valueIndex] |
| ]; |
| } |
| return [ |
| typeof mpData.xAxis != 'string' && xAxis.getCoordByIndex ? xAxis.getCoordByIndex(mpData.xAxis || 0) : xAxis.getCoord(mpData.xAxis || 0), |
| typeof mpData.yAxis != 'string' && yAxis.getCoordByIndex ? yAxis.getCoordByIndex(mpData.yAxis || 0) : yAxis.getCoord(mpData.yAxis || 0) |
| ]; |
| }, |
| refresh: function (newOption) { |
| if (newOption) { |
| this.option = newOption; |
| this.series = newOption.series; |
| } |
| this.backupShapeList(); |
| this._buildShape(); |
| }, |
| ontooltipHover: function (param, tipShape) { |
| var seriesIndex = param.seriesIndex; |
| var dataIndex = param.dataIndex; |
| var seriesPL; |
| var singlePL; |
| var len = seriesIndex.length; |
| while (len--) { |
| seriesPL = this.finalPLMap[seriesIndex[len]]; |
| if (seriesPL) { |
| for (var i = 0, l = seriesPL.length; i < l; i++) { |
| singlePL = seriesPL[i]; |
| for (var j = 0, k = singlePL.length; j < k; j++) { |
| if (dataIndex === singlePL[j][2]) { |
| tipShape.push(this._getSymbol(seriesIndex[len], singlePL[j][2], singlePL[j][3], singlePL[j][0], singlePL[j][1], 'horizontal')); |
| } |
| } |
| } |
| } |
| } |
| }, |
| addDataAnimation: function (params) { |
| var series = this.series; |
| var aniMap = {}; |
| for (var i = 0, l = params.length; i < l; i++) { |
| aniMap[params[i][0]] = params[i]; |
| } |
| var x; |
| var dx; |
| var y; |
| var dy; |
| var seriesIndex; |
| var pointList; |
| var isHorizontal; |
| for (var i = this.shapeList.length - 1; i >= 0; i--) { |
| seriesIndex = this.shapeList[i]._seriesIndex; |
| if (aniMap[seriesIndex] && !aniMap[seriesIndex][3]) { |
| if (this.shapeList[i]._main && this.shapeList[i].style.pointList.length > 1) { |
| pointList = this.shapeList[i].style.pointList; |
| dx = Math.abs(pointList[0][0] - pointList[1][0]); |
| dy = Math.abs(pointList[0][1] - pointList[1][1]); |
| isHorizontal = this.shapeList[i]._orient === 'horizontal'; |
| if (aniMap[seriesIndex][2]) { |
| if (this.shapeList[i].type === 'half-smooth-polygon') { |
| var len = pointList.length; |
| this.shapeList[i].style.pointList[len - 3] = pointList[len - 2]; |
| this.shapeList[i].style.pointList[len - 3][isHorizontal ? 0 : 1] = pointList[len - 4][isHorizontal ? 0 : 1]; |
| this.shapeList[i].style.pointList[len - 2] = pointList[len - 1]; |
| } |
| this.shapeList[i].style.pointList.pop(); |
| isHorizontal ? (x = dx, y = 0) : (x = 0, y = -dy); |
| } else { |
| this.shapeList[i].style.pointList.shift(); |
| if (this.shapeList[i].type === 'half-smooth-polygon') { |
| var targetPoint = this.shapeList[i].style.pointList.pop(); |
| isHorizontal ? targetPoint[0] = pointList[0][0] : targetPoint[1] = pointList[0][1]; |
| this.shapeList[i].style.pointList.push(targetPoint); |
| } |
| isHorizontal ? (x = -dx, y = 0) : (x = 0, y = dy); |
| } |
| this.zr.modShape(this.shapeList[i].id, { style: { pointList: this.shapeList[i].style.pointList } }, true); |
| } else { |
| if (aniMap[seriesIndex][2] && this.shapeList[i]._dataIndex === series[seriesIndex].data.length - 1) { |
| this.zr.delShape(this.shapeList[i].id); |
| continue; |
| } else if (!aniMap[seriesIndex][2] && this.shapeList[i]._dataIndex === 0) { |
| this.zr.delShape(this.shapeList[i].id); |
| continue; |
| } |
| } |
| this.shapeList[i].position = [ |
| 0, |
| 0 |
| ]; |
| this.zr.animate(this.shapeList[i].id, '').when(500, { |
| position: [ |
| x, |
| y |
| ] |
| }).start(); |
| } |
| } |
| } |
| }; |
| function legendLineIcon(ctx, style, refreshNextFrame) { |
| var x = style.x; |
| var y = style.y; |
| var width = style.width; |
| var height = style.height; |
| var dy = height / 2; |
| if (style.symbol.match('empty')) { |
| ctx.fillStyle = '#fff'; |
| } |
| style.brushType = 'both'; |
| var symbol = style.symbol.replace('empty', '').toLowerCase(); |
| if (symbol.match('star')) { |
| dy = symbol.replace('star', '') - 0 || 5; |
| y -= 1; |
| symbol = 'star'; |
| } else if (symbol === 'rectangle' || symbol === 'arrow') { |
| x += (width - height) / 2; |
| width = height; |
| } |
| var imageLocation = ''; |
| if (symbol.match('image')) { |
| imageLocation = symbol.replace(new RegExp('^image:\\/\\/'), ''); |
| symbol = 'image'; |
| x += Math.round((width - height) / 2) - 1; |
| width = height = height + 2; |
| } |
| symbol = IconShape.prototype.iconLibrary[symbol]; |
| if (symbol) { |
| var x2 = style.x; |
| var y2 = style.y; |
| ctx.moveTo(x2, y2 + dy); |
| ctx.lineTo(x2 + 5, y2 + dy); |
| ctx.moveTo(x2 + style.width - 5, y2 + dy); |
| ctx.lineTo(x2 + style.width, y2 + dy); |
| var self = this; |
| symbol(ctx, { |
| x: x + 4, |
| y: y + 4, |
| width: width - 8, |
| height: height - 8, |
| n: dy, |
| image: imageLocation |
| }, function () { |
| self.modSelf(); |
| refreshNextFrame(); |
| }); |
| } else { |
| ctx.moveTo(x, y + dy); |
| ctx.lineTo(x + width, y + dy); |
| } |
| } |
| IconShape.prototype.iconLibrary['legendLineIcon'] = legendLineIcon; |
| zrUtil.inherits(Line, ChartBase); |
| zrUtil.inherits(Line, ComponentBase); |
| require('../chart').define('line', Line); |
| return Line; |
| });define('echarts/util/shape/HalfSmoothPolygon', [ |
| 'require', |
| 'zrender/shape/Base', |
| 'zrender/shape/util/smoothBezier', |
| 'zrender/tool/util', |
| 'zrender/shape/Polygon' |
| ], function (require) { |
| var Base = require('zrender/shape/Base'); |
| var smoothBezier = require('zrender/shape/util/smoothBezier'); |
| var zrUtil = require('zrender/tool/util'); |
| function HalfSmoothPolygon(options) { |
| Base.call(this, options); |
| } |
| HalfSmoothPolygon.prototype = { |
| type: 'half-smooth-polygon', |
| buildPath: function (ctx, style) { |
| var pointList = style.pointList; |
| if (pointList.length < 2) { |
| return; |
| } |
| if (style.smooth) { |
| var controlPoints = smoothBezier(pointList.slice(0, -2), style.smooth, false, style.smoothConstraint); |
| ctx.moveTo(pointList[0][0], pointList[0][1]); |
| var cp1; |
| var cp2; |
| var p; |
| var l = pointList.length; |
| for (var i = 0; i < l - 3; i++) { |
| cp1 = controlPoints[i * 2]; |
| cp2 = controlPoints[i * 2 + 1]; |
| p = pointList[i + 1]; |
| ctx.bezierCurveTo(cp1[0], cp1[1], cp2[0], cp2[1], p[0], p[1]); |
| } |
| ctx.lineTo(pointList[l - 2][0], pointList[l - 2][1]); |
| ctx.lineTo(pointList[l - 1][0], pointList[l - 1][1]); |
| ctx.lineTo(pointList[0][0], pointList[0][1]); |
| } else { |
| require('zrender/shape/Polygon').prototype.buildPath(ctx, style); |
| } |
| return; |
| } |
| }; |
| zrUtil.inherits(HalfSmoothPolygon, Base); |
| return HalfSmoothPolygon; |
| });define('echarts/chart/bar', [ |
| 'require', |
| '../component/base', |
| './base', |
| 'zrender/shape/Rectangle', |
| '../component/axis', |
| '../component/grid', |
| '../component/dataZoom', |
| '../config', |
| '../util/ecData', |
| 'zrender/tool/util', |
| 'zrender/tool/color', |
| '../chart' |
| ], function (require) { |
| var ComponentBase = require('../component/base'); |
| var ChartBase = require('./base'); |
| var RectangleShape = require('zrender/shape/Rectangle'); |
| require('../component/axis'); |
| require('../component/grid'); |
| require('../component/dataZoom'); |
| var ecConfig = require('../config'); |
| var ecData = require('../util/ecData'); |
| var zrUtil = require('zrender/tool/util'); |
| var zrColor = require('zrender/tool/color'); |
| function Bar(ecTheme, messageCenter, zr, option, myChart) { |
| ComponentBase.call(this, ecTheme, messageCenter, zr, option, myChart); |
| ChartBase.call(this); |
| this.refresh(option); |
| } |
| Bar.prototype = { |
| type: ecConfig.CHART_TYPE_BAR, |
| _buildShape: function () { |
| this._bulidPosition(); |
| }, |
| _buildNormal: function (seriesArray, maxDataLength, locationMap, xMarkMap, orient) { |
| var series = this.series; |
| var seriesIndex = locationMap[0][0]; |
| var serie = series[seriesIndex]; |
| var xAxisIndex = serie.xAxisIndex; |
| var yAxisIndex = serie.yAxisIndex; |
| var categoryAxis = orient == 'horizontal' ? this.component.xAxis.getAxis(xAxisIndex) : this.component.yAxis.getAxis(yAxisIndex); |
| var valueAxis; |
| var size = this._mapSize(categoryAxis, locationMap); |
| var gap = size.gap; |
| var barGap = size.barGap; |
| var barWidthMap = size.barWidthMap; |
| var barMaxWidthMap = size.barMaxWidthMap; |
| var barWidth = size.barWidth; |
| var barMinHeightMap = size.barMinHeightMap; |
| var barHeight; |
| var curBarWidth; |
| var interval = size.interval; |
| var x; |
| var y; |
| var lastP; |
| var baseP; |
| var lastN; |
| var baseN; |
| var barShape; |
| var data; |
| var value; |
| for (var i = 0, l = maxDataLength; i < l; i++) { |
| if (categoryAxis.getNameByIndex(i) == null) { |
| break; |
| } |
| orient == 'horizontal' ? x = categoryAxis.getCoordByIndex(i) - gap / 2 : y = categoryAxis.getCoordByIndex(i) + gap / 2; |
| for (var j = 0, k = locationMap.length; j < k; j++) { |
| yAxisIndex = series[locationMap[j][0]].yAxisIndex || 0; |
| xAxisIndex = series[locationMap[j][0]].xAxisIndex || 0; |
| valueAxis = orient == 'horizontal' ? this.component.yAxis.getAxis(yAxisIndex) : this.component.xAxis.getAxis(xAxisIndex); |
| baseP = lastP = baseN = lastN = valueAxis.getCoord(0); |
| for (var m = 0, n = locationMap[j].length; m < n; m++) { |
| seriesIndex = locationMap[j][m]; |
| serie = series[seriesIndex]; |
| data = serie.data[i]; |
| value = data != null ? data.value != null ? data.value : data : '-'; |
| xMarkMap[seriesIndex] = xMarkMap[seriesIndex] || { |
| min: Number.POSITIVE_INFINITY, |
| max: Number.NEGATIVE_INFINITY, |
| sum: 0, |
| counter: 0, |
| average: 0 |
| }; |
| if (value === '-') { |
| continue; |
| } |
| if (value > 0) { |
| barHeight = m > 0 ? valueAxis.getCoordSize(value) : orient == 'horizontal' ? baseP - valueAxis.getCoord(value) : valueAxis.getCoord(value) - baseP; |
| if (n === 1 && barMinHeightMap[seriesIndex] > barHeight) { |
| barHeight = barMinHeightMap[seriesIndex]; |
| } |
| if (orient == 'horizontal') { |
| lastP -= barHeight; |
| y = lastP; |
| } else { |
| x = lastP; |
| lastP += barHeight; |
| } |
| } else if (value < 0) { |
| barHeight = m > 0 ? valueAxis.getCoordSize(value) : orient == 'horizontal' ? valueAxis.getCoord(value) - baseN : baseN - valueAxis.getCoord(value); |
| if (n === 1 && barMinHeightMap[seriesIndex] > barHeight) { |
| barHeight = barMinHeightMap[seriesIndex]; |
| } |
| if (orient == 'horizontal') { |
| y = lastN; |
| lastN += barHeight; |
| } else { |
| lastN -= barHeight; |
| x = lastN; |
| } |
| } else { |
| barHeight = 0; |
| if (orient == 'horizontal') { |
| lastP -= barHeight; |
| y = lastP; |
| } else { |
| x = lastP; |
| lastP += barHeight; |
| } |
| } |
| var curBarWidth = Math.min(barMaxWidthMap[seriesIndex] || Number.MAX_VALUE, barWidthMap[seriesIndex] || barWidth); |
| xMarkMap[seriesIndex][i] = orient == 'horizontal' ? x + curBarWidth / 2 : y - curBarWidth / 2; |
| if (xMarkMap[seriesIndex].min > value) { |
| xMarkMap[seriesIndex].min = value; |
| if (orient == 'horizontal') { |
| xMarkMap[seriesIndex].minY = y; |
| xMarkMap[seriesIndex].minX = xMarkMap[seriesIndex][i]; |
| } else { |
| xMarkMap[seriesIndex].minX = x + barHeight; |
| xMarkMap[seriesIndex].minY = xMarkMap[seriesIndex][i]; |
| } |
| } |
| if (xMarkMap[seriesIndex].max < value) { |
| xMarkMap[seriesIndex].max = value; |
| if (orient == 'horizontal') { |
| xMarkMap[seriesIndex].maxY = y; |
| xMarkMap[seriesIndex].maxX = xMarkMap[seriesIndex][i]; |
| } else { |
| xMarkMap[seriesIndex].maxX = x + barHeight; |
| xMarkMap[seriesIndex].maxY = xMarkMap[seriesIndex][i]; |
| } |
| } |
| xMarkMap[seriesIndex].sum += value; |
| xMarkMap[seriesIndex].counter++; |
| if (i % interval === 0) { |
| barShape = this._getBarItem(seriesIndex, i, categoryAxis.getNameByIndex(i), x, y - (orient == 'horizontal' ? 0 : curBarWidth), orient == 'horizontal' ? curBarWidth : barHeight, orient == 'horizontal' ? barHeight : curBarWidth, orient == 'horizontal' ? 'vertical' : 'horizontal'); |
| this.shapeList.push(new RectangleShape(barShape)); |
| } |
| } |
| for (var m = 0, n = locationMap[j].length; m < n; m++) { |
| seriesIndex = locationMap[j][m]; |
| serie = series[seriesIndex]; |
| data = serie.data[i]; |
| value = data != null ? data.value != null ? data.value : data : '-'; |
| if (value != '-') { |
| continue; |
| } |
| if (this.deepQuery([ |
| data, |
| serie, |
| this.option |
| ], 'calculable')) { |
| if (orient == 'horizontal') { |
| lastP -= this.ecTheme.island.r; |
| y = lastP; |
| } else { |
| x = lastP; |
| lastP += this.ecTheme.island.r; |
| } |
| curBarWidth = Math.min(barMaxWidthMap[seriesIndex] || Number.MAX_VALUE, barWidthMap[seriesIndex] || barWidth); |
| barShape = this._getBarItem(seriesIndex, i, categoryAxis.getNameByIndex(i), x + 0.5, y + 0.5 - (orient == 'horizontal' ? 0 : curBarWidth), (orient == 'horizontal' ? curBarWidth : this.ecTheme.island.r) - 1, (orient == 'horizontal' ? this.ecTheme.island.r : curBarWidth) - 1, orient == 'horizontal' ? 'vertical' : 'horizontal'); |
| barShape.hoverable = false; |
| barShape.draggable = false; |
| barShape.style.lineWidth = 1; |
| barShape.style.brushType = 'stroke'; |
| barShape.style.strokeColor = serie.calculableHolderColor || this.ecTheme.calculableHolderColor; |
| this.shapeList.push(new RectangleShape(barShape)); |
| } |
| } |
| orient == 'horizontal' ? x += curBarWidth + barGap : y -= curBarWidth + barGap; |
| } |
| } |
| this._calculMarkMapXY(xMarkMap, locationMap, orient == 'horizontal' ? 'y' : 'x'); |
| }, |
| _buildHorizontal: function (seriesArray, maxDataLength, locationMap, xMarkMap) { |
| return this._buildNormal(seriesArray, maxDataLength, locationMap, xMarkMap, 'horizontal'); |
| }, |
| _buildVertical: function (seriesArray, maxDataLength, locationMap, xMarkMap) { |
| return this._buildNormal(seriesArray, maxDataLength, locationMap, xMarkMap, 'vertical'); |
| }, |
| _buildOther: function (seriesArray, maxDataLength, locationMap, xMarkMap) { |
| var series = this.series; |
| for (var j = 0, k = locationMap.length; j < k; j++) { |
| for (var m = 0, n = locationMap[j].length; m < n; m++) { |
| var seriesIndex = locationMap[j][m]; |
| var serie = series[seriesIndex]; |
| var xAxisIndex = serie.xAxisIndex || 0; |
| var xAxis = this.component.xAxis.getAxis(xAxisIndex); |
| var baseX = xAxis.getCoord(0); |
| var yAxisIndex = serie.yAxisIndex || 0; |
| var yAxis = this.component.yAxis.getAxis(yAxisIndex); |
| var baseY = yAxis.getCoord(0); |
| xMarkMap[seriesIndex] = xMarkMap[seriesIndex] || { |
| min0: Number.POSITIVE_INFINITY, |
| min1: Number.POSITIVE_INFINITY, |
| max0: Number.NEGATIVE_INFINITY, |
| max1: Number.NEGATIVE_INFINITY, |
| sum0: 0, |
| sum1: 0, |
| counter0: 0, |
| counter1: 0, |
| average0: 0, |
| average1: 0 |
| }; |
| for (var i = 0, l = serie.data.length; i < l; i++) { |
| var data = serie.data[i]; |
| var value = data != null ? data.value != null ? data.value : data : '-'; |
| if (!(value instanceof Array)) { |
| continue; |
| } |
| var x = xAxis.getCoord(value[0]); |
| var y = yAxis.getCoord(value[1]); |
| var queryTarget = [ |
| data, |
| serie |
| ]; |
| var barWidth = this.deepQuery(queryTarget, 'barWidth') || 10; |
| var barHeight = this.deepQuery(queryTarget, 'barHeight'); |
| var orient; |
| var barShape; |
| if (barHeight != null) { |
| orient = 'horizontal'; |
| if (value[0] > 0) { |
| barWidth = x - baseX; |
| x -= barWidth; |
| } else if (value[0] < 0) { |
| barWidth = baseX - x; |
| } else { |
| barWidth = 0; |
| } |
| barShape = this._getBarItem(seriesIndex, i, value[0], x, y - barHeight / 2, barWidth, barHeight, orient); |
| } else { |
| orient = 'vertical'; |
| if (value[1] > 0) { |
| barHeight = baseY - y; |
| } else if (value[1] < 0) { |
| barHeight = y - baseY; |
| y -= barHeight; |
| } else { |
| barHeight = 0; |
| } |
| barShape = this._getBarItem(seriesIndex, i, value[0], x - barWidth / 2, y, barWidth, barHeight, orient); |
| } |
| this.shapeList.push(new RectangleShape(barShape)); |
| x = xAxis.getCoord(value[0]); |
| y = yAxis.getCoord(value[1]); |
| if (xMarkMap[seriesIndex].min0 > value[0]) { |
| xMarkMap[seriesIndex].min0 = value[0]; |
| xMarkMap[seriesIndex].minY0 = y; |
| xMarkMap[seriesIndex].minX0 = x; |
| } |
| if (xMarkMap[seriesIndex].max0 < value[0]) { |
| xMarkMap[seriesIndex].max0 = value[0]; |
| xMarkMap[seriesIndex].maxY0 = y; |
| xMarkMap[seriesIndex].maxX0 = x; |
| } |
| xMarkMap[seriesIndex].sum0 += value[0]; |
| xMarkMap[seriesIndex].counter0++; |
| if (xMarkMap[seriesIndex].min1 > value[1]) { |
| xMarkMap[seriesIndex].min1 = value[1]; |
| xMarkMap[seriesIndex].minY1 = y; |
| xMarkMap[seriesIndex].minX1 = x; |
| } |
| if (xMarkMap[seriesIndex].max1 < value[1]) { |
| xMarkMap[seriesIndex].max1 = value[1]; |
| xMarkMap[seriesIndex].maxY1 = y; |
| xMarkMap[seriesIndex].maxX1 = x; |
| } |
| xMarkMap[seriesIndex].sum1 += value[1]; |
| xMarkMap[seriesIndex].counter1++; |
| } |
| } |
| } |
| this._calculMarkMapXY(xMarkMap, locationMap, 'xy'); |
| }, |
| _mapSize: function (categoryAxis, locationMap, ignoreUserDefined) { |
| var res = this._findSpecialBarSzie(locationMap, ignoreUserDefined); |
| var barWidthMap = res.barWidthMap; |
| var barMaxWidthMap = res.barMaxWidthMap; |
| var barMinHeightMap = res.barMinHeightMap; |
| var sBarWidthCounter = res.sBarWidthCounter; |
| var sBarWidthTotal = res.sBarWidthTotal; |
| var barGap = res.barGap; |
| var barCategoryGap = res.barCategoryGap; |
| var gap; |
| var barWidth; |
| var interval = 1; |
| if (locationMap.length != sBarWidthCounter) { |
| if (!ignoreUserDefined) { |
| gap = typeof barCategoryGap === 'string' && barCategoryGap.match(/%$/) ? Math.floor(categoryAxis.getGap() * (100 - parseFloat(barCategoryGap)) / 100) : categoryAxis.getGap() - barCategoryGap; |
| if (typeof barGap === 'string' && barGap.match(/%$/)) { |
| barGap = parseFloat(barGap) / 100; |
| barWidth = Math.floor((gap - sBarWidthTotal) / ((locationMap.length - 1) * barGap + locationMap.length - sBarWidthCounter)); |
| barGap = Math.floor(barWidth * barGap); |
| } else { |
| barGap = parseFloat(barGap); |
| barWidth = Math.floor((gap - sBarWidthTotal - barGap * (locationMap.length - 1)) / (locationMap.length - sBarWidthCounter)); |
| } |
| if (barWidth <= 0) { |
| return this._mapSize(categoryAxis, locationMap, true); |
| } |
| } else { |
| gap = categoryAxis.getGap(); |
| barGap = 0; |
| barWidth = Math.floor(gap / locationMap.length); |
| if (barWidth <= 0) { |
| interval = Math.floor(locationMap.length / gap); |
| barWidth = 1; |
| } |
| } |
| } else { |
| gap = sBarWidthCounter > 1 ? typeof barCategoryGap === 'string' && barCategoryGap.match(/%$/) ? Math.floor(categoryAxis.getGap() * (100 - parseFloat(barCategoryGap)) / 100) : categoryAxis.getGap() - barCategoryGap : sBarWidthTotal; |
| barWidth = 0; |
| barGap = sBarWidthCounter > 1 ? Math.floor((gap - sBarWidthTotal) / (sBarWidthCounter - 1)) : 0; |
| if (barGap < 0) { |
| return this._mapSize(categoryAxis, locationMap, true); |
| } |
| } |
| return this._recheckBarMaxWidth(locationMap, barWidthMap, barMaxWidthMap, barMinHeightMap, gap, barWidth, barGap, interval); |
| }, |
| _findSpecialBarSzie: function (locationMap, ignoreUserDefined) { |
| var series = this.series; |
| var barWidthMap = {}; |
| var barMaxWidthMap = {}; |
| var barMinHeightMap = {}; |
| var sBarWidth; |
| var sBarMaxWidth; |
| var sBarWidthCounter = 0; |
| var sBarWidthTotal = 0; |
| var barGap; |
| var barCategoryGap; |
| for (var j = 0, k = locationMap.length; j < k; j++) { |
| var hasFound = { |
| barWidth: false, |
| barMaxWidth: false |
| }; |
| for (var m = 0, n = locationMap[j].length; m < n; m++) { |
| var seriesIndex = locationMap[j][m]; |
| var queryTarget = series[seriesIndex]; |
| if (!ignoreUserDefined) { |
| if (!hasFound.barWidth) { |
| sBarWidth = this.query(queryTarget, 'barWidth'); |
| if (sBarWidth != null) { |
| barWidthMap[seriesIndex] = sBarWidth; |
| sBarWidthTotal += sBarWidth; |
| sBarWidthCounter++; |
| hasFound.barWidth = true; |
| for (var ii = 0, ll = m; ii < ll; ii++) { |
| var pSeriesIndex = locationMap[j][ii]; |
| barWidthMap[pSeriesIndex] = sBarWidth; |
| } |
| } |
| } else { |
| barWidthMap[seriesIndex] = sBarWidth; |
| } |
| if (!hasFound.barMaxWidth) { |
| sBarMaxWidth = this.query(queryTarget, 'barMaxWidth'); |
| if (sBarMaxWidth != null) { |
| barMaxWidthMap[seriesIndex] = sBarMaxWidth; |
| hasFound.barMaxWidth = true; |
| for (var ii = 0, ll = m; ii < ll; ii++) { |
| var pSeriesIndex = locationMap[j][ii]; |
| barMaxWidthMap[pSeriesIndex] = sBarMaxWidth; |
| } |
| } |
| } else { |
| barMaxWidthMap[seriesIndex] = sBarMaxWidth; |
| } |
| } |
| barMinHeightMap[seriesIndex] = this.query(queryTarget, 'barMinHeight'); |
| barGap = barGap != null ? barGap : this.query(queryTarget, 'barGap'); |
| barCategoryGap = barCategoryGap != null ? barCategoryGap : this.query(queryTarget, 'barCategoryGap'); |
| } |
| } |
| return { |
| barWidthMap: barWidthMap, |
| barMaxWidthMap: barMaxWidthMap, |
| barMinHeightMap: barMinHeightMap, |
| sBarWidth: sBarWidth, |
| sBarMaxWidth: sBarMaxWidth, |
| sBarWidthCounter: sBarWidthCounter, |
| sBarWidthTotal: sBarWidthTotal, |
| barGap: barGap, |
| barCategoryGap: barCategoryGap |
| }; |
| }, |
| _recheckBarMaxWidth: function (locationMap, barWidthMap, barMaxWidthMap, barMinHeightMap, gap, barWidth, barGap, interval) { |
| for (var j = 0, k = locationMap.length; j < k; j++) { |
| var seriesIndex = locationMap[j][0]; |
| if (barMaxWidthMap[seriesIndex] && barMaxWidthMap[seriesIndex] < barWidth) { |
| gap -= barWidth - barMaxWidthMap[seriesIndex]; |
| } |
| } |
| return { |
| barWidthMap: barWidthMap, |
| barMaxWidthMap: barMaxWidthMap, |
| barMinHeightMap: barMinHeightMap, |
| gap: gap, |
| barWidth: barWidth, |
| barGap: barGap, |
| interval: interval |
| }; |
| }, |
| _getBarItem: function (seriesIndex, dataIndex, name, x, y, width, height, orient) { |
| var series = this.series; |
| var barShape; |
| var serie = series[seriesIndex]; |
| var data = serie.data[dataIndex]; |
| var defaultColor = this._sIndex2ColorMap[seriesIndex]; |
| var queryTarget = [ |
| data, |
| serie |
| ]; |
| var normalColor = this.deepQuery(queryTarget, 'itemStyle.normal.color') || defaultColor; |
| var emphasisColor = this.deepQuery(queryTarget, 'itemStyle.emphasis.color'); |
| var normal = this.deepMerge(queryTarget, 'itemStyle.normal'); |
| var normalBorderWidth = normal.barBorderWidth; |
| var emphasis = this.deepMerge(queryTarget, 'itemStyle.emphasis'); |
| barShape = { |
| zlevel: this._zlevelBase, |
| clickable: this.deepQuery(queryTarget, 'clickable'), |
| style: { |
| x: x, |
| y: y, |
| width: width, |
| height: height, |
| brushType: 'both', |
| color: this.getItemStyleColor(normalColor, seriesIndex, dataIndex, data), |
| radius: normal.barBorderRadius, |
| lineWidth: normalBorderWidth, |
| strokeColor: normal.barBorderColor |
| }, |
| highlightStyle: { |
| color: this.getItemStyleColor(emphasisColor, seriesIndex, dataIndex, data), |
| radius: emphasis.barBorderRadius, |
| lineWidth: emphasis.barBorderWidth, |
| strokeColor: emphasis.barBorderColor |
| }, |
| _orient: orient |
| }; |
| barShape.highlightStyle.color = barShape.highlightStyle.color || (typeof barShape.style.color === 'string' ? zrColor.lift(barShape.style.color, -0.3) : barShape.style.color); |
| if (normalBorderWidth > 0 && barShape.style.height > normalBorderWidth && barShape.style.width > normalBorderWidth) { |
| barShape.style.y += normalBorderWidth / 2; |
| barShape.style.height -= normalBorderWidth; |
| barShape.style.x += normalBorderWidth / 2; |
| barShape.style.width -= normalBorderWidth; |
| } else { |
| barShape.style.brushType = 'fill'; |
| } |
| barShape.highlightStyle.textColor = barShape.highlightStyle.color; |
| barShape = this.addLabel(barShape, serie, data, name, orient); |
| if (barShape.style.textPosition === 'insideLeft' || barShape.style.textPosition === 'insideRight' || barShape.style.textPosition === 'insideTop' || barShape.style.textPosition === 'insideBottom') { |
| var gap = 5; |
| switch (barShape.style.textPosition) { |
| case 'insideLeft': |
| barShape.style.textX = barShape.style.x + gap; |
| barShape.style.textY = barShape.style.y + barShape.style.height / 2; |
| barShape.style.textAlign = 'left'; |
| barShape.style.textBaseline = 'middle'; |
| break; |
| case 'insideRight': |
| barShape.style.textX = barShape.style.x + barShape.style.width - gap; |
| barShape.style.textY = barShape.style.y + barShape.style.height / 2; |
| barShape.style.textAlign = 'right'; |
| barShape.style.textBaseline = 'middle'; |
| break; |
| case 'insideTop': |
| barShape.style.textX = barShape.style.x + barShape.style.width / 2; |
| barShape.style.textY = barShape.style.y + gap / 2; |
| barShape.style.textAlign = 'center'; |
| barShape.style.textBaseline = 'top'; |
| break; |
| case 'insideBottom': |
| barShape.style.textX = barShape.style.x + barShape.style.width / 2; |
| barShape.style.textY = barShape.style.y + barShape.style.height - gap / 2; |
| barShape.style.textAlign = 'center'; |
| barShape.style.textBaseline = 'bottom'; |
| break; |
| } |
| barShape.style.textPosition = 'specific'; |
| barShape.style.textColor = barShape.style.textColor || '#fff'; |
| } |
| if (this.deepQuery([ |
| data, |
| serie, |
| this.option |
| ], 'calculable')) { |
| this.setCalculable(barShape); |
| barShape.draggable = true; |
| } |
| ecData.pack(barShape, series[seriesIndex], seriesIndex, series[seriesIndex].data[dataIndex], dataIndex, name); |
| return barShape; |
| }, |
| getMarkCoord: function (seriesIndex, mpData) { |
| var serie = this.series[seriesIndex]; |
| var xMarkMap = this.xMarkMap[seriesIndex]; |
| var xAxis = this.component.xAxis.getAxis(serie.xAxisIndex); |
| var yAxis = this.component.yAxis.getAxis(serie.yAxisIndex); |
| var dataIndex; |
| var pos; |
| if (mpData.type && (mpData.type === 'max' || mpData.type === 'min' || mpData.type === 'average')) { |
| var valueIndex = mpData.valueIndex != null ? mpData.valueIndex : xMarkMap.maxX0 != null ? '1' : ''; |
| pos = [ |
| xMarkMap[mpData.type + 'X' + valueIndex], |
| xMarkMap[mpData.type + 'Y' + valueIndex], |
| xMarkMap[mpData.type + 'Line' + valueIndex], |
| xMarkMap[mpData.type + valueIndex] |
| ]; |
| } else if (xMarkMap.isHorizontal) { |
| dataIndex = typeof mpData.xAxis === 'string' && xAxis.getIndexByName ? xAxis.getIndexByName(mpData.xAxis) : mpData.xAxis || 0; |
| var x = xMarkMap[dataIndex]; |
| x = x != null ? x : typeof mpData.xAxis != 'string' && xAxis.getCoordByIndex ? xAxis.getCoordByIndex(mpData.xAxis || 0) : xAxis.getCoord(mpData.xAxis || 0); |
| pos = [ |
| x, |
| yAxis.getCoord(mpData.yAxis || 0) |
| ]; |
| } else { |
| dataIndex = typeof mpData.yAxis === 'string' && yAxis.getIndexByName ? yAxis.getIndexByName(mpData.yAxis) : mpData.yAxis || 0; |
| var y = xMarkMap[dataIndex]; |
| y = y != null ? y : typeof mpData.yAxis != 'string' && yAxis.getCoordByIndex ? yAxis.getCoordByIndex(mpData.yAxis || 0) : yAxis.getCoord(mpData.yAxis || 0); |
| pos = [ |
| xAxis.getCoord(mpData.xAxis || 0), |
| y |
| ]; |
| } |
| return pos; |
| }, |
| refresh: function (newOption) { |
| if (newOption) { |
| this.option = newOption; |
| this.series = newOption.series; |
| } |
| this.backupShapeList(); |
| this._buildShape(); |
| }, |
| addDataAnimation: function (params) { |
| var series = this.series; |
| var aniMap = {}; |
| for (var i = 0, l = params.length; i < l; i++) { |
| aniMap[params[i][0]] = params[i]; |
| } |
| var x; |
| var dx; |
| var y; |
| var dy; |
| var serie; |
| var seriesIndex; |
| var dataIndex; |
| for (var i = this.shapeList.length - 1; i >= 0; i--) { |
| seriesIndex = ecData.get(this.shapeList[i], 'seriesIndex'); |
| if (aniMap[seriesIndex] && !aniMap[seriesIndex][3]) { |
| if (this.shapeList[i].type === 'rectangle') { |
| dataIndex = ecData.get(this.shapeList[i], 'dataIndex'); |
| serie = series[seriesIndex]; |
| if (aniMap[seriesIndex][2] && dataIndex === serie.data.length - 1) { |
| this.zr.delShape(this.shapeList[i].id); |
| continue; |
| } else if (!aniMap[seriesIndex][2] && dataIndex === 0) { |
| this.zr.delShape(this.shapeList[i].id); |
| continue; |
| } |
| if (this.shapeList[i]._orient === 'horizontal') { |
| dy = this.component.yAxis.getAxis(serie.yAxisIndex || 0).getGap(); |
| y = aniMap[seriesIndex][2] ? -dy : dy; |
| x = 0; |
| } else { |
| dx = this.component.xAxis.getAxis(serie.xAxisIndex || 0).getGap(); |
| x = aniMap[seriesIndex][2] ? dx : -dx; |
| y = 0; |
| } |
| this.shapeList[i].position = [ |
| 0, |
| 0 |
| ]; |
| this.zr.animate(this.shapeList[i].id, '').when(500, { |
| position: [ |
| x, |
| y |
| ] |
| }).start(); |
| } |
| } |
| } |
| } |
| }; |
| zrUtil.inherits(Bar, ChartBase); |
| zrUtil.inherits(Bar, ComponentBase); |
| require('../chart').define('bar', Bar); |
| return Bar; |
| });define('echarts/chart/scatter', [ |
| 'require', |
| '../component/base', |
| './base', |
| '../util/shape/Symbol', |
| '../component/axis', |
| '../component/grid', |
| '../component/dataZoom', |
| '../component/dataRange', |
| '../config', |
| 'zrender/tool/util', |
| 'zrender/tool/color', |
| '../chart' |
| ], function (require) { |
| var ComponentBase = require('../component/base'); |
| var ChartBase = require('./base'); |
| var SymbolShape = require('../util/shape/Symbol'); |
| require('../component/axis'); |
| require('../component/grid'); |
| require('../component/dataZoom'); |
| require('../component/dataRange'); |
| var ecConfig = require('../config'); |
| var zrUtil = require('zrender/tool/util'); |
| var zrColor = require('zrender/tool/color'); |
| function Scatter(ecTheme, messageCenter, zr, option, myChart) { |
| ComponentBase.call(this, ecTheme, messageCenter, zr, option, myChart); |
| ChartBase.call(this); |
| this.refresh(option); |
| } |
| Scatter.prototype = { |
| type: ecConfig.CHART_TYPE_SCATTER, |
| _buildShape: function () { |
| var series = this.series; |
| this._sIndex2ColorMap = {}; |
| this._symbol = this.option.symbolList; |
| this._sIndex2ShapeMap = {}; |
| this.selectedMap = {}; |
| this.xMarkMap = {}; |
| var legend = this.component.legend; |
| var seriesArray = []; |
| var serie; |
| var serieName; |
| var iconShape; |
| var iconType; |
| for (var i = 0, l = series.length; i < l; i++) { |
| serie = series[i]; |
| serieName = serie.name; |
| if (serie.type === ecConfig.CHART_TYPE_SCATTER) { |
| series[i] = this.reformOption(series[i]); |
| this.legendHoverLink = series[i].legendHoverLink || this.legendHoverLink; |
| this._sIndex2ShapeMap[i] = this.query(serie, 'symbol') || this._symbol[i % this._symbol.length]; |
| if (legend) { |
| this.selectedMap[serieName] = legend.isSelected(serieName); |
| this._sIndex2ColorMap[i] = zrColor.alpha(legend.getColor(serieName), 0.5); |
| iconShape = legend.getItemShape(serieName); |
| if (iconShape) { |
| var iconType = this._sIndex2ShapeMap[i]; |
| iconShape.style.brushType = iconType.match('empty') ? 'stroke' : 'both'; |
| iconType = iconType.replace('empty', '').toLowerCase(); |
| if (iconType.match('rectangle')) { |
| iconShape.style.x += Math.round((iconShape.style.width - iconShape.style.height) / 2); |
| iconShape.style.width = iconShape.style.height; |
| } |
| if (iconType.match('star')) { |
| iconShape.style.n = iconType.replace('star', '') - 0 || 5; |
| iconType = 'star'; |
| } |
| if (iconType.match('image')) { |
| iconShape.style.image = iconType.replace(new RegExp('^image:\\/\\/'), ''); |
| iconShape.style.x += Math.round((iconShape.style.width - iconShape.style.height) / 2); |
| iconShape.style.width = iconShape.style.height; |
| iconType = 'image'; |
| } |
| iconShape.style.iconType = iconType; |
| legend.setItemShape(serieName, iconShape); |
| } |
| } else { |
| this.selectedMap[serieName] = true; |
| this._sIndex2ColorMap[i] = zrColor.alpha(this.zr.getColor(i), 0.5); |
| } |
| if (this.selectedMap[serieName]) { |
| seriesArray.push(i); |
| } |
| } |
| } |
| this._buildSeries(seriesArray); |
| this.addShapeList(); |
| }, |
| _buildSeries: function (seriesArray) { |
| if (seriesArray.length === 0) { |
| return; |
| } |
| var series = this.series; |
| var seriesIndex; |
| var serie; |
| var data; |
| var value; |
| var xAxis; |
| var yAxis; |
| var pointList = {}; |
| var x; |
| var y; |
| for (var j = 0, k = seriesArray.length; j < k; j++) { |
| seriesIndex = seriesArray[j]; |
| serie = series[seriesIndex]; |
| if (serie.data.length === 0) { |
| continue; |
| } |
| xAxis = this.component.xAxis.getAxis(serie.xAxisIndex || 0); |
| yAxis = this.component.yAxis.getAxis(serie.yAxisIndex || 0); |
| pointList[seriesIndex] = []; |
| for (var i = 0, l = serie.data.length; i < l; i++) { |
| data = serie.data[i]; |
| value = data != null ? data.value != null ? data.value : data : '-'; |
| if (value === '-' || value.length < 2) { |
| continue; |
| } |
| x = xAxis.getCoord(value[0]); |
| y = yAxis.getCoord(value[1]); |
| pointList[seriesIndex].push([ |
| x, |
| y, |
| i, |
| data.name || '' |
| ]); |
| } |
| this.xMarkMap[seriesIndex] = this._markMap(xAxis, yAxis, serie.data, pointList[seriesIndex]); |
| this.buildMark(seriesIndex); |
| } |
| this._buildPointList(pointList); |
| }, |
| _markMap: function (xAxis, yAxis, data, pointList) { |
| var xMarkMap = { |
| min0: Number.POSITIVE_INFINITY, |
| max0: Number.NEGATIVE_INFINITY, |
| sum0: 0, |
| counter0: 0, |
| average0: 0, |
| min1: Number.POSITIVE_INFINITY, |
| max1: Number.NEGATIVE_INFINITY, |
| sum1: 0, |
| counter1: 0, |
| average1: 0 |
| }; |
| var value; |
| for (var i = 0, l = pointList.length; i < l; i++) { |
| value = data[pointList[i][2]].value || data[pointList[i][2]]; |
| if (xMarkMap.min0 > value[0]) { |
| xMarkMap.min0 = value[0]; |
| xMarkMap.minY0 = pointList[i][1]; |
| xMarkMap.minX0 = pointList[i][0]; |
| } |
| if (xMarkMap.max0 < value[0]) { |
| xMarkMap.max0 = value[0]; |
| xMarkMap.maxY0 = pointList[i][1]; |
| xMarkMap.maxX0 = pointList[i][0]; |
| } |
| xMarkMap.sum0 += value[0]; |
| xMarkMap.counter0++; |
| if (xMarkMap.min1 > value[1]) { |
| xMarkMap.min1 = value[1]; |
| xMarkMap.minY1 = pointList[i][1]; |
| xMarkMap.minX1 = pointList[i][0]; |
| } |
| if (xMarkMap.max1 < value[1]) { |
| xMarkMap.max1 = value[1]; |
| xMarkMap.maxY1 = pointList[i][1]; |
| xMarkMap.maxX1 = pointList[i][0]; |
| } |
| xMarkMap.sum1 += value[1]; |
| xMarkMap.counter1++; |
| } |
| var gridX = this.component.grid.getX(); |
| var gridXend = this.component.grid.getXend(); |
| var gridY = this.component.grid.getY(); |
| var gridYend = this.component.grid.getYend(); |
| xMarkMap.average0 = (xMarkMap.sum0 / xMarkMap.counter0).toFixed(2) - 0; |
| var x = xAxis.getCoord(xMarkMap.average0); |
| xMarkMap.averageLine0 = [ |
| [ |
| x, |
| gridYend |
| ], |
| [ |
| x, |
| gridY |
| ] |
| ]; |
| xMarkMap.minLine0 = [ |
| [ |
| xMarkMap.minX0, |
| gridYend |
| ], |
| [ |
| xMarkMap.minX0, |
| gridY |
| ] |
| ]; |
| xMarkMap.maxLine0 = [ |
| [ |
| xMarkMap.maxX0, |
| gridYend |
| ], |
| [ |
| xMarkMap.maxX0, |
| gridY |
| ] |
| ]; |
| xMarkMap.average1 = (xMarkMap.sum1 / xMarkMap.counter1).toFixed(2) - 0; |
| var y = yAxis.getCoord(xMarkMap.average1); |
| xMarkMap.averageLine1 = [ |
| [ |
| gridX, |
| y |
| ], |
| [ |
| gridXend, |
| y |
| ] |
| ]; |
| xMarkMap.minLine1 = [ |
| [ |
| gridX, |
| xMarkMap.minY1 |
| ], |
| [ |
| gridXend, |
| xMarkMap.minY1 |
| ] |
| ]; |
| xMarkMap.maxLine1 = [ |
| [ |
| gridX, |
| xMarkMap.maxY1 |
| ], |
| [ |
| gridXend, |
| xMarkMap.maxY1 |
| ] |
| ]; |
| return xMarkMap; |
| }, |
| _buildPointList: function (pointList) { |
| var series = this.series; |
| var serie; |
| var seriesPL; |
| var singlePoint; |
| var shape; |
| for (var seriesIndex in pointList) { |
| serie = series[seriesIndex]; |
| seriesPL = pointList[seriesIndex]; |
| if (serie.large && serie.data.length > serie.largeThreshold) { |
| this.shapeList.push(this._getLargeSymbol(seriesPL, this.getItemStyleColor(this.query(serie, 'itemStyle.normal.color'), seriesIndex, -1) || this._sIndex2ColorMap[seriesIndex])); |
| continue; |
| } |
| for (var i = 0, l = seriesPL.length; i < l; i++) { |
| singlePoint = seriesPL[i]; |
| shape = this._getSymbol(seriesIndex, singlePoint[2], singlePoint[3], singlePoint[0], singlePoint[1]); |
| shape && this.shapeList.push(shape); |
| } |
| } |
| }, |
| _getSymbol: function (seriesIndex, dataIndex, name, x, y) { |
| var series = this.series; |
| var serie = series[seriesIndex]; |
| var data = serie.data[dataIndex]; |
| var dataRange = this.component.dataRange; |
| var rangColor; |
| if (dataRange) { |
| rangColor = isNaN(data[2]) ? this._sIndex2ColorMap[seriesIndex] : dataRange.getColor(data[2]); |
| if (!rangColor) { |
| return null; |
| } |
| } else { |
| rangColor = this._sIndex2ColorMap[seriesIndex]; |
| } |
| var itemShape = this.getSymbolShape(serie, seriesIndex, data, dataIndex, name, x, y, this._sIndex2ShapeMap[seriesIndex], rangColor, 'rgba(0,0,0,0)', 'vertical'); |
| itemShape.zlevel = this._zlevelBase; |
| itemShape._main = true; |
| return itemShape; |
| }, |
| _getLargeSymbol: function (pointList, nColor) { |
| return new SymbolShape({ |
| zlevel: this._zlevelBase, |
| _main: true, |
| hoverable: false, |
| style: { |
| pointList: pointList, |
| color: nColor, |
| strokeColor: nColor |
| }, |
| highlightStyle: { pointList: [] } |
| }); |
| }, |
| getMarkCoord: function (seriesIndex, mpData) { |
| var serie = this.series[seriesIndex]; |
| var xMarkMap = this.xMarkMap[seriesIndex]; |
| var xAxis = this.component.xAxis.getAxis(serie.xAxisIndex); |
| var yAxis = this.component.yAxis.getAxis(serie.yAxisIndex); |
| var pos; |
| if (mpData.type && (mpData.type === 'max' || mpData.type === 'min' || mpData.type === 'average')) { |
| var valueIndex = mpData.valueIndex != null ? mpData.valueIndex : 1; |
| pos = [ |
| xMarkMap[mpData.type + 'X' + valueIndex], |
| xMarkMap[mpData.type + 'Y' + valueIndex], |
| xMarkMap[mpData.type + 'Line' + valueIndex], |
| xMarkMap[mpData.type + valueIndex] |
| ]; |
| } else { |
| pos = [ |
| typeof mpData.xAxis != 'string' && xAxis.getCoordByIndex ? xAxis.getCoordByIndex(mpData.xAxis || 0) : xAxis.getCoord(mpData.xAxis || 0), |
| typeof mpData.yAxis != 'string' && yAxis.getCoordByIndex ? yAxis.getCoordByIndex(mpData.yAxis || 0) : yAxis.getCoord(mpData.yAxis || 0) |
| ]; |
| } |
| return pos; |
| }, |
| refresh: function (newOption) { |
| if (newOption) { |
| this.option = newOption; |
| this.series = newOption.series; |
| } |
| this.backupShapeList(); |
| this._buildShape(); |
| }, |
| ondataRange: function (param, status) { |
| if (this.component.dataRange) { |
| this.refresh(); |
| status.needRefresh = true; |
| } |
| return; |
| } |
| }; |
| zrUtil.inherits(Scatter, ChartBase); |
| zrUtil.inherits(Scatter, ComponentBase); |
| require('../chart').define('scatter', Scatter); |
| return Scatter; |
| });define('echarts/component/dataRange', [ |
| 'require', |
| './base', |
| 'zrender/shape/Text', |
| 'zrender/shape/Rectangle', |
| '../util/shape/HandlePolygon', |
| '../config', |
| 'zrender/tool/util', |
| 'zrender/tool/event', |
| 'zrender/tool/area', |
| 'zrender/tool/color', |
| '../component' |
| ], function (require) { |
| var Base = require('./base'); |
| var TextShape = require('zrender/shape/Text'); |
| var RectangleShape = require('zrender/shape/Rectangle'); |
| var HandlePolygonShape = require('../util/shape/HandlePolygon'); |
| var ecConfig = require('../config'); |
| var zrUtil = require('zrender/tool/util'); |
| var zrEvent = require('zrender/tool/event'); |
| var zrArea = require('zrender/tool/area'); |
| var zrColor = require('zrender/tool/color'); |
| function DataRange(ecTheme, messageCenter, zr, option, myChart) { |
| if (typeof this.query(option, 'dataRange.min') == 'undefined' || typeof this.query(option, 'dataRange.max') == 'undefined') { |
| console.error('option.dataRange.min or option.dataRange.max has not been defined.'); |
| return; |
| } |
| Base.call(this, ecTheme, messageCenter, zr, option, myChart); |
| var self = this; |
| self._ondrift = function (dx, dy) { |
| return self.__ondrift(this, dx, dy); |
| }; |
| self._ondragend = function () { |
| return self.__ondragend(); |
| }; |
| self._dataRangeSelected = function (param) { |
| return self.__dataRangeSelected(param); |
| }; |
| self._dispatchHoverLink = function (param) { |
| return self.__dispatchHoverLink(param); |
| }; |
| self._onhoverlink = function (params) { |
| return self.__onhoverlink(params); |
| }; |
| this._selectedMap = {}; |
| this._range = {}; |
| this.refresh(option); |
| messageCenter.bind(ecConfig.EVENT.HOVER, this._onhoverlink); |
| } |
| DataRange.prototype = { |
| type: ecConfig.COMPONENT_TYPE_DATARANGE, |
| _textGap: 10, |
| _buildShape: function () { |
| this._itemGroupLocation = this._getItemGroupLocation(); |
| this._buildBackground(); |
| if (this.dataRangeOption.splitNumber <= 0 || this.dataRangeOption.calculable) { |
| this._buildGradient(); |
| } else { |
| this._buildItem(); |
| } |
| if (this.dataRangeOption.show) { |
| for (var i = 0, l = this.shapeList.length; i < l; i++) { |
| this.zr.addShape(this.shapeList[i]); |
| } |
| } |
| this._syncShapeFromRange(); |
| }, |
| _buildItem: function () { |
| var data = this._valueTextList; |
| var dataLength = data.length; |
| var itemName; |
| var itemShape; |
| var textShape; |
| var font = this.getFont(this.dataRangeOption.textStyle); |
| var lastX = this._itemGroupLocation.x; |
| var lastY = this._itemGroupLocation.y; |
| var itemWidth = this.dataRangeOption.itemWidth; |
| var itemHeight = this.dataRangeOption.itemHeight; |
| var itemGap = this.dataRangeOption.itemGap; |
| var textHeight = zrArea.getTextHeight('国', font); |
| var color; |
| if (this.dataRangeOption.orient == 'vertical' && this.dataRangeOption.x == 'right') { |
| lastX = this._itemGroupLocation.x + this._itemGroupLocation.width - itemWidth; |
| } |
| var needValueText = true; |
| if (this.dataRangeOption.text) { |
| needValueText = false; |
| if (this.dataRangeOption.text[0]) { |
| textShape = this._getTextShape(lastX, lastY, this.dataRangeOption.text[0]); |
| if (this.dataRangeOption.orient == 'horizontal') { |
| lastX += zrArea.getTextWidth(this.dataRangeOption.text[0], font) + this._textGap; |
| } else { |
| lastY += textHeight + this._textGap; |
| textShape.style.y += textHeight / 2 + this._textGap; |
| textShape.style.textBaseline = 'bottom'; |
| } |
| this.shapeList.push(new TextShape(textShape)); |
| } |
| } |
| for (var i = 0; i < dataLength; i++) { |
| itemName = data[i]; |
| color = this.getColorByIndex(i); |
| itemShape = this._getItemShape(lastX, lastY, itemWidth, itemHeight, this._selectedMap[i] ? color : '#ccc'); |
| itemShape._idx = i; |
| itemShape.onmousemove = this._dispatchHoverLink; |
| itemShape.onclick = this._dataRangeSelected; |
| this.shapeList.push(new RectangleShape(itemShape)); |
| if (needValueText) { |
| textShape = { |
| zlevel: this._zlevelBase, |
| style: { |
| x: lastX + itemWidth + 5, |
| y: lastY, |
| color: this._selectedMap[i] ? this.dataRangeOption.textStyle.color : '#ccc', |
| text: data[i], |
| textFont: font, |
| textBaseline: 'top' |
| }, |
| highlightStyle: { brushType: 'fill' }, |
| clickable: true |
| }; |
| if (this.dataRangeOption.orient == 'vertical' && this.dataRangeOption.x == 'right') { |
| textShape.style.x -= itemWidth + 10; |
| textShape.style.textAlign = 'right'; |
| } |
| textShape._idx = i; |
| textShape.onclick = this._dataRangeSelected; |
| this.shapeList.push(new TextShape(textShape)); |
| } |
| if (this.dataRangeOption.orient == 'horizontal') { |
| lastX += itemWidth + (needValueText ? 5 : 0) + (needValueText ? zrArea.getTextWidth(itemName, font) : 0) + itemGap; |
| } else { |
| lastY += itemHeight + itemGap; |
| } |
| } |
| if (!needValueText && this.dataRangeOption.text[1]) { |
| if (this.dataRangeOption.orient == 'horizontal') { |
| lastX = lastX - itemGap + this._textGap; |
| } else { |
| lastY = lastY - itemGap + this._textGap; |
| } |
| textShape = this._getTextShape(lastX, lastY, this.dataRangeOption.text[1]); |
| if (this.dataRangeOption.orient != 'horizontal') { |
| textShape.style.y -= 5; |
| textShape.style.textBaseline = 'top'; |
| } |
| this.shapeList.push(new TextShape(textShape)); |
| } |
| }, |
| _buildGradient: function () { |
| var itemShape; |
| var textShape; |
| var font = this.getFont(this.dataRangeOption.textStyle); |
| var lastX = this._itemGroupLocation.x; |
| var lastY = this._itemGroupLocation.y; |
| var itemWidth = this.dataRangeOption.itemWidth; |
| var itemHeight = this.dataRangeOption.itemHeight; |
| var textHeight = zrArea.getTextHeight('国', font); |
| var needValueText = true; |
| if (this.dataRangeOption.text) { |
| needValueText = false; |
| if (this.dataRangeOption.text[0]) { |
| textShape = this._getTextShape(lastX, lastY, this.dataRangeOption.text[0]); |
| if (this.dataRangeOption.orient == 'horizontal') { |
| lastX += zrArea.getTextWidth(this.dataRangeOption.text[0], font) + this._textGap; |
| } else { |
| lastY += textHeight + this._textGap; |
| textShape.style.y += textHeight / 2 + this._textGap; |
| textShape.style.textBaseline = 'bottom'; |
| } |
| this.shapeList.push(new TextShape(textShape)); |
| } |
| } |
| var zrColor = require('zrender/tool/color'); |
| var per = 1 / (this.dataRangeOption.color.length - 1); |
| var colorList = []; |
| for (var i = 0, l = this.dataRangeOption.color.length; i < l; i++) { |
| colorList.push([ |
| i * per, |
| this.dataRangeOption.color[i] |
| ]); |
| } |
| if (this.dataRangeOption.orient == 'horizontal') { |
| itemShape = { |
| zlevel: this._zlevelBase, |
| style: { |
| x: lastX, |
| y: lastY, |
| width: itemWidth * 10, |
| height: itemHeight, |
| color: zrColor.getLinearGradient(lastX, lastY, lastX + itemWidth * 10, lastY, colorList) |
| }, |
| hoverable: false |
| }; |
| lastX += itemWidth * 10 + this._textGap; |
| } else { |
| itemShape = { |
| zlevel: this._zlevelBase, |
| style: { |
| x: lastX, |
| y: lastY, |
| width: itemWidth, |
| height: itemHeight * 10, |
| color: zrColor.getLinearGradient(lastX, lastY, lastX, lastY + itemHeight * 10, colorList) |
| }, |
| hoverable: false |
| }; |
| lastY += itemHeight * 10 + this._textGap; |
| } |
| this.shapeList.push(new RectangleShape(itemShape)); |
| this._calculableLocation = itemShape.style; |
| if (this.dataRangeOption.calculable) { |
| this._buildFiller(); |
| this._bulidMask(); |
| this._bulidHandle(); |
| } |
| this._buildIndicator(); |
| if (!needValueText && this.dataRangeOption.text[1]) { |
| textShape = this._getTextShape(lastX, lastY, this.dataRangeOption.text[1]); |
| this.shapeList.push(new TextShape(textShape)); |
| } |
| }, |
| _buildIndicator: function () { |
| var x = this._calculableLocation.x; |
| var y = this._calculableLocation.y; |
| var width = this._calculableLocation.width; |
| var height = this._calculableLocation.height; |
| var size = 5; |
| var pointList; |
| var textPosition; |
| if (this.dataRangeOption.orient == 'horizontal') { |
| if (this.dataRangeOption.y != 'bottom') { |
| pointList = [ |
| [ |
| x, |
| y + height |
| ], |
| [ |
| x - size, |
| y + height + size |
| ], |
| [ |
| x + size, |
| y + height + size |
| ] |
| ]; |
| textPosition = 'bottom'; |
| } else { |
| pointList = [ |
| [ |
| x, |
| y |
| ], |
| [ |
| x - size, |
| y - size |
| ], |
| [ |
| x + size, |
| y - size |
| ] |
| ]; |
| textPosition = 'top'; |
| } |
| } else { |
| if (this.dataRangeOption.x != 'right') { |
| pointList = [ |
| [ |
| x + width, |
| y |
| ], |
| [ |
| x + width + size, |
| y - size |
| ], |
| [ |
| x + width + size, |
| y + size |
| ] |
| ]; |
| textPosition = 'right'; |
| } else { |
| pointList = [ |
| [ |
| x, |
| y |
| ], |
| [ |
| x - size, |
| y - size |
| ], |
| [ |
| x - size, |
| y + size |
| ] |
| ]; |
| textPosition = 'left'; |
| } |
| } |
| this._indicatorShape = { |
| style: { |
| pointList: pointList, |
| color: '#fff', |
| __rect: { |
| x: Math.min(pointList[0][0], pointList[1][0]), |
| y: Math.min(pointList[0][1], pointList[1][1]), |
| width: size * (this.dataRangeOption.orient == 'horizontal' ? 2 : 1), |
| height: size * (this.dataRangeOption.orient == 'horizontal' ? 1 : 2) |
| } |
| }, |
| highlightStyle: { |
| brushType: 'fill', |
| textPosition: textPosition, |
| textColor: this.dataRangeOption.textStyle.color |
| }, |
| hoverable: false |
| }; |
| this._indicatorShape = new HandlePolygonShape(this._indicatorShape); |
| }, |
| _buildFiller: function () { |
| this._fillerShape = { |
| zlevel: this._zlevelBase + 1, |
| style: { |
| x: this._calculableLocation.x, |
| y: this._calculableLocation.y, |
| width: this._calculableLocation.width, |
| height: this._calculableLocation.height, |
| color: 'rgba(255,255,255,0)' |
| }, |
| highlightStyle: { |
| strokeColor: 'rgba(255,255,255,0.5)', |
| lineWidth: 1 |
| }, |
| draggable: true, |
| ondrift: this._ondrift, |
| ondragend: this._ondragend, |
| onmousemove: this._dispatchHoverLink, |
| _type: 'filler' |
| }; |
| this._fillerShape = new RectangleShape(this._fillerShape); |
| this.shapeList.push(this._fillerShape); |
| }, |
| _bulidHandle: function () { |
| var x = this._calculableLocation.x; |
| var y = this._calculableLocation.y; |
| var width = this._calculableLocation.width; |
| var height = this._calculableLocation.height; |
| var font = this.getFont(this.dataRangeOption.textStyle); |
| var textHeight = zrArea.getTextHeight('国', font); |
| var textWidth = Math.max(zrArea.getTextWidth(this._textFormat(this.dataRangeOption.max), font), zrArea.getTextWidth(this._textFormat(this.dataRangeOption.min), font)) + 2; |
| var pointListStart; |
| var textXStart; |
| var textYStart; |
| var coverRectStart; |
| var pointListEnd; |
| var textXEnd; |
| var textYEnd; |
| var coverRectEnd; |
| if (this.dataRangeOption.orient == 'horizontal') { |
| if (this.dataRangeOption.y != 'bottom') { |
| pointListStart = [ |
| [ |
| x, |
| y |
| ], |
| [ |
| x, |
| y + height + textHeight |
| ], |
| [ |
| x - textHeight, |
| y + height + textHeight |
| ], |
| [ |
| x - 1, |
| y + height |
| ], |
| [ |
| x - 1, |
| y |
| ] |
| ]; |
| textXStart = x - textWidth / 2 - textHeight; |
| textYStart = y + height + textHeight / 2 + 2; |
| coverRectStart = { |
| x: x - textWidth - textHeight, |
| y: y + height, |
| width: textWidth + textHeight, |
| height: textHeight |
| }; |
| pointListEnd = [ |
| [ |
| x + width, |
| y |
| ], |
| [ |
| x + width, |
| y + height + textHeight |
| ], |
| [ |
| x + width + textHeight, |
| y + height + textHeight |
| ], |
| [ |
| x + width + 1, |
| y + height |
| ], |
| [ |
| x + width + 1, |
| y |
| ] |
| ]; |
| textXEnd = x + width + textWidth / 2 + textHeight; |
| textYEnd = textYStart; |
| coverRectEnd = { |
| x: x + width, |
| y: y + height, |
| width: textWidth + textHeight, |
| height: textHeight |
| }; |
| } else { |
| pointListStart = [ |
| [ |
| x, |
| y + height |
| ], |
| [ |
| x, |
| y - textHeight |
| ], |
| [ |
| x - textHeight, |
| y - textHeight |
| ], |
| [ |
| x - 1, |
| y |
| ], |
| [ |
| x - 1, |
| y + height |
| ] |
| ]; |
| textXStart = x - textWidth / 2 - textHeight; |
| textYStart = y - textHeight / 2 - 2; |
| coverRectStart = { |
| x: x - textWidth - textHeight, |
| y: y - textHeight, |
| width: textWidth + textHeight, |
| height: textHeight |
| }; |
| pointListEnd = [ |
| [ |
| x + width, |
| y + height |
| ], |
| [ |
| x + width, |
| y - textHeight |
| ], |
| [ |
| x + width + textHeight, |
| y - textHeight |
| ], |
| [ |
| x + width + 1, |
| y |
| ], |
| [ |
| x + width + 1, |
| y + height |
| ] |
| ]; |
| textXEnd = x + width + textWidth / 2 + textHeight; |
| textYEnd = textYStart; |
| coverRectEnd = { |
| x: x + width, |
| y: y - textHeight, |
| width: textWidth + textHeight, |
| height: textHeight |
| }; |
| } |
| } else { |
| textWidth += textHeight; |
| if (this.dataRangeOption.x != 'right') { |
| pointListStart = [ |
| [ |
| x, |
| y |
| ], |
| [ |
| x + width + textHeight, |
| y |
| ], |
| [ |
| x + width + textHeight, |
| y - textHeight |
| ], |
| [ |
| x + width, |
| y - 1 |
| ], |
| [ |
| x, |
| y - 1 |
| ] |
| ]; |
| textXStart = x + width + textWidth / 2 + textHeight / 2; |
| textYStart = y - textHeight / 2; |
| coverRectStart = { |
| x: x + width, |
| y: y - textHeight, |
| width: textWidth + textHeight, |
| height: textHeight |
| }; |
| pointListEnd = [ |
| [ |
| x, |
| y + height |
| ], |
| [ |
| x + width + textHeight, |
| y + height |
| ], |
| [ |
| x + width + textHeight, |
| y + textHeight + height |
| ], |
| [ |
| x + width, |
| y + 1 + height |
| ], |
| [ |
| x, |
| y + height + 1 |
| ] |
| ]; |
| textXEnd = textXStart; |
| textYEnd = y + height + textHeight / 2; |
| coverRectEnd = { |
| x: x + width, |
| y: y + height, |
| width: textWidth + textHeight, |
| height: textHeight |
| }; |
| } else { |
| pointListStart = [ |
| [ |
| x + width, |
| y |
| ], |
| [ |
| x - textHeight, |
| y |
| ], |
| [ |
| x - textHeight, |
| y - textHeight |
| ], |
| [ |
| x, |
| y - 1 |
| ], |
| [ |
| x + width, |
| y - 1 |
| ] |
| ]; |
| textXStart = x - textWidth / 2 - textHeight / 2; |
| textYStart = y - textHeight / 2; |
| coverRectStart = { |
| x: x - textWidth - textHeight, |
| y: y - textHeight, |
| width: textWidth + textHeight, |
| height: textHeight |
| }; |
| pointListEnd = [ |
| [ |
| x + width, |
| y + height |
| ], |
| [ |
| x - textHeight, |
| y + height |
| ], |
| [ |
| x - textHeight, |
| y + textHeight + height |
| ], |
| [ |
| x, |
| y + 1 + height |
| ], |
| [ |
| x + width, |
| y + height + 1 |
| ] |
| ]; |
| textXEnd = textXStart; |
| textYEnd = y + height + textHeight / 2; |
| coverRectEnd = { |
| x: x - textWidth - textHeight, |
| y: y + height, |
| width: textWidth + textHeight, |
| height: textHeight |
| }; |
| } |
| } |
| this._startShape = { |
| style: { |
| pointList: pointListStart, |
| text: this._textFormat(this.dataRangeOption.max), |
| textX: textXStart, |
| textY: textYStart, |
| color: this.getColor(this.dataRangeOption.max), |
| rect: coverRectStart, |
| x: pointListStart[0][0], |
| y: pointListStart[0][1], |
| _x: pointListStart[0][0], |
| _y: pointListStart[0][1] |
| } |
| }; |
| this._startShape.highlightStyle = { |
| strokeColor: this._startShape.style.color, |
| lineWidth: 1 |
| }; |
| this._endShape = { |
| style: { |
| pointList: pointListEnd, |
| text: this._textFormat(this.dataRangeOption.min), |
| textX: textXEnd, |
| textY: textYEnd, |
| color: this.getColor(this.dataRangeOption.min), |
| rect: coverRectEnd, |
| x: pointListEnd[0][0], |
| y: pointListEnd[0][1], |
| _x: pointListEnd[0][0], |
| _y: pointListEnd[0][1] |
| } |
| }; |
| this._endShape.highlightStyle = { |
| strokeColor: this._endShape.style.color, |
| lineWidth: 1 |
| }; |
| this._startShape.zlevel = this._endShape.zlevel = this._zlevelBase + 1; |
| this._startShape.draggable = this._endShape.draggable = true; |
| this._startShape.ondrift = this._endShape.ondrift = this._ondrift; |
| this._startShape.ondragend = this._endShape.ondragend = this._ondragend; |
| this._startShape.style.textColor = this._endShape.style.textColor = this.dataRangeOption.textStyle.color; |
| this._startShape.style.textAlign = this._endShape.style.textAlign = 'center'; |
| this._startShape.style.textPosition = this._endShape.style.textPosition = 'specific'; |
| this._startShape.style.textBaseline = this._endShape.style.textBaseline = 'middle'; |
| this._startShape.style.width = this._endShape.style.width = 0; |
| this._startShape.style.height = this._endShape.style.height = 0; |
| this._startShape.style.textPosition = this._endShape.style.textPosition = 'specific'; |
| this._startShape = new HandlePolygonShape(this._startShape); |
| this._endShape = new HandlePolygonShape(this._endShape); |
| this.shapeList.push(this._startShape); |
| this.shapeList.push(this._endShape); |
| }, |
| _bulidMask: function () { |
| var x = this._calculableLocation.x; |
| var y = this._calculableLocation.y; |
| var width = this._calculableLocation.width; |
| var height = this._calculableLocation.height; |
| this._startMask = { |
| zlevel: this._zlevelBase + 1, |
| style: { |
| x: x, |
| y: y, |
| width: this.dataRangeOption.orient == 'horizontal' ? 0 : width, |
| height: this.dataRangeOption.orient == 'horizontal' ? height : 0, |
| color: '#ccc' |
| }, |
| hoverable: false |
| }; |
| this._endMask = { |
| zlevel: this._zlevelBase + 1, |
| style: { |
| x: this.dataRangeOption.orient == 'horizontal' ? x + width : x, |
| y: this.dataRangeOption.orient == 'horizontal' ? y : y + height, |
| width: this.dataRangeOption.orient == 'horizontal' ? 0 : width, |
| height: this.dataRangeOption.orient == 'horizontal' ? height : 0, |
| color: '#ccc' |
| }, |
| hoverable: false |
| }; |
| this._startMask = new RectangleShape(this._startMask); |
| this._endMask = new RectangleShape(this._endMask); |
| this.shapeList.push(this._startMask); |
| this.shapeList.push(this._endMask); |
| }, |
| _buildBackground: function () { |
| var padding = this.reformCssArray(this.dataRangeOption.padding); |
| this.shapeList.push(new RectangleShape({ |
| zlevel: this._zlevelBase, |
| hoverable: false, |
| style: { |
| x: this._itemGroupLocation.x - padding[3], |
| y: this._itemGroupLocation.y - padding[0], |
| width: this._itemGroupLocation.width + padding[3] + padding[1], |
| height: this._itemGroupLocation.height + padding[0] + padding[2], |
| brushType: this.dataRangeOption.borderWidth === 0 ? 'fill' : 'both', |
| color: this.dataRangeOption.backgroundColor, |
| strokeColor: this.dataRangeOption.borderColor, |
| lineWidth: this.dataRangeOption.borderWidth |
| } |
| })); |
| }, |
| _getItemGroupLocation: function () { |
| var data = this._valueTextList; |
| var dataLength = data.length; |
| var itemGap = this.dataRangeOption.itemGap; |
| var itemWidth = this.dataRangeOption.itemWidth; |
| var itemHeight = this.dataRangeOption.itemHeight; |
| var totalWidth = 0; |
| var totalHeight = 0; |
| var font = this.getFont(this.dataRangeOption.textStyle); |
| var textHeight = zrArea.getTextHeight('国', font); |
| if (this.dataRangeOption.orient == 'horizontal') { |
| if (this.dataRangeOption.text || this.dataRangeOption.splitNumber <= 0 || this.dataRangeOption.calculable) { |
| totalWidth = (this.dataRangeOption.splitNumber <= 0 || this.dataRangeOption.calculable ? itemWidth * 10 + itemGap : dataLength * (itemWidth + itemGap)) + (this.dataRangeOption.text && typeof this.dataRangeOption.text[0] != 'undefined' ? zrArea.getTextWidth(this.dataRangeOption.text[0], font) + this._textGap : 0) + (this.dataRangeOption.text && typeof this.dataRangeOption.text[1] != 'undefined' ? zrArea.getTextWidth(this.dataRangeOption.text[1], font) + this._textGap : 0); |
| } else { |
| itemWidth += 5; |
| for (var i = 0; i < dataLength; i++) { |
| totalWidth += itemWidth + zrArea.getTextWidth(data[i], font) + itemGap; |
| } |
| } |
| totalWidth -= itemGap; |
| totalHeight = Math.max(textHeight, itemHeight); |
| } else { |
| var maxWidth; |
| if (this.dataRangeOption.text || this.dataRangeOption.splitNumber <= 0 || this.dataRangeOption.calculable) { |
| totalHeight = (this.dataRangeOption.splitNumber <= 0 || this.dataRangeOption.calculable ? itemHeight * 10 + itemGap : dataLength * (itemHeight + itemGap)) + (this.dataRangeOption.text && typeof this.dataRangeOption.text[0] != 'undefined' ? this._textGap + textHeight : 0) + (this.dataRangeOption.text && typeof this.dataRangeOption.text[1] != 'undefined' ? this._textGap + textHeight : 0); |
| maxWidth = Math.max(zrArea.getTextWidth(this.dataRangeOption.text && this.dataRangeOption.text[0] || '', font), zrArea.getTextWidth(this.dataRangeOption.text && this.dataRangeOption.text[1] || '', font)); |
| totalWidth = Math.max(itemWidth, maxWidth); |
| } else { |
| totalHeight = (itemHeight + itemGap) * dataLength; |
| itemWidth += 5; |
| maxWidth = 0; |
| for (var i = 0; i < dataLength; i++) { |
| maxWidth = Math.max(maxWidth, zrArea.getTextWidth(data[i], font)); |
| } |
| totalWidth = itemWidth + maxWidth; |
| } |
| totalHeight -= itemGap; |
| } |
| var padding = this.reformCssArray(this.dataRangeOption.padding); |
| var x; |
| var zrWidth = this.zr.getWidth(); |
| switch (this.dataRangeOption.x) { |
| case 'center': |
| x = Math.floor((zrWidth - totalWidth) / 2); |
| break; |
| case 'left': |
| x = padding[3] + this.dataRangeOption.borderWidth; |
| break; |
| case 'right': |
| x = zrWidth - totalWidth - padding[1] - this.dataRangeOption.borderWidth; |
| break; |
| default: |
| x = this.parsePercent(this.dataRangeOption.x, zrWidth); |
| x = isNaN(x) ? 0 : x; |
| break; |
| } |
| var y; |
| var zrHeight = this.zr.getHeight(); |
| switch (this.dataRangeOption.y) { |
| case 'top': |
| y = padding[0] + this.dataRangeOption.borderWidth; |
| break; |
| case 'bottom': |
| y = zrHeight - totalHeight - padding[2] - this.dataRangeOption.borderWidth; |
| break; |
| case 'center': |
| y = Math.floor((zrHeight - totalHeight) / 2); |
| break; |
| default: |
| y = this.parsePercent(this.dataRangeOption.y, zrHeight); |
| y = isNaN(y) ? 0 : y; |
| break; |
| } |
| if (this.dataRangeOption.calculable) { |
| var handlerWidth = Math.max(zrArea.getTextWidth(this.dataRangeOption.max, font), zrArea.getTextWidth(this.dataRangeOption.min, font)) + textHeight; |
| if (this.dataRangeOption.orient == 'horizontal') { |
| if (x < handlerWidth) { |
| x = handlerWidth; |
| } |
| if (x + totalWidth + handlerWidth > zrWidth) { |
| x -= handlerWidth; |
| } |
| } else { |
| if (y < textHeight) { |
| y = textHeight; |
| } |
| if (y + totalHeight + textHeight > zrHeight) { |
| y -= textHeight; |
| } |
| } |
| } |
| return { |
| x: x, |
| y: y, |
| width: totalWidth, |
| height: totalHeight |
| }; |
| }, |
| _getTextShape: function (x, y, text) { |
| return { |
| zlevel: this._zlevelBase, |
| style: { |
| x: this.dataRangeOption.orient == 'horizontal' ? x : this._itemGroupLocation.x + this._itemGroupLocation.width / 2, |
| y: this.dataRangeOption.orient == 'horizontal' ? this._itemGroupLocation.y + this._itemGroupLocation.height / 2 : y, |
| color: this.dataRangeOption.textStyle.color, |
| text: text, |
| textFont: this.getFont(this.dataRangeOption.textStyle), |
| textBaseline: this.dataRangeOption.orient == 'horizontal' ? 'middle' : 'top', |
| textAlign: this.dataRangeOption.orient == 'horizontal' ? 'left' : 'center' |
| }, |
| hoverable: false |
| }; |
| }, |
| _getItemShape: function (x, y, width, height, color) { |
| return { |
| zlevel: this._zlevelBase, |
| style: { |
| x: x, |
| y: y + 1, |
| width: width, |
| height: height - 2, |
| color: color |
| }, |
| highlightStyle: { |
| strokeColor: color, |
| lineWidth: 1 |
| }, |
| clickable: true |
| }; |
| }, |
| __ondrift: function (shape, dx, dy) { |
| var x = this._calculableLocation.x; |
| var y = this._calculableLocation.y; |
| var width = this._calculableLocation.width; |
| var height = this._calculableLocation.height; |
| if (this.dataRangeOption.orient == 'horizontal') { |
| if (shape.style.x + dx <= x) { |
| shape.style.x = x; |
| } else if (shape.style.x + dx + shape.style.width >= x + width) { |
| shape.style.x = x + width - shape.style.width; |
| } else { |
| shape.style.x += dx; |
| } |
| } else { |
| if (shape.style.y + dy <= y) { |
| shape.style.y = y; |
| } else if (shape.style.y + dy + shape.style.height >= y + height) { |
| shape.style.y = y + height - shape.style.height; |
| } else { |
| shape.style.y += dy; |
| } |
| } |
| if (shape._type == 'filler') { |
| this._syncHandleShape(); |
| } else { |
| this._syncFillerShape(shape); |
| } |
| if (this.dataRangeOption.realtime) { |
| this._syncData(); |
| } |
| return true; |
| }, |
| __ondragend: function () { |
| this.isDragend = true; |
| }, |
| ondragend: function (param, status) { |
| if (!this.isDragend || !param.target) { |
| return; |
| } |
| !this.dataRangeOption.realtime && this._syncData(); |
| status.dragOut = true; |
| status.dragIn = true; |
| if (!this.dataRangeOption.realtime) { |
| this.messageCenter.dispatch(ecConfig.EVENT.DATA_RANGE, null, { |
| range: { |
| start: this._range.end, |
| end: this._range.start |
| } |
| }, this.myChart); |
| } |
| status.needRefresh = false; |
| this.isDragend = false; |
| return; |
| }, |
| _syncShapeFromRange: function () { |
| var range = this.dataRangeOption.range || {}; |
| this._range.end = typeof this._range.end != 'undefined' ? this._range.end : typeof range.start != 'undefined' ? range.start : 0; |
| this._range.start = typeof this._range.start != 'undefined' ? this._range.start : typeof range.end != 'undefined' ? range.end : 100; |
| if (this._range.start != 100 || this._range.end !== 0) { |
| if (this.dataRangeOption.orient == 'horizontal') { |
| var width = this._fillerShape.style.width; |
| this._fillerShape.style.x += width * (100 - this._range.start) / 100; |
| this._fillerShape.style.width = width * (this._range.start - this._range.end) / 100; |
| } else { |
| var height = this._fillerShape.style.height; |
| this._fillerShape.style.y += height * (100 - this._range.start) / 100; |
| this._fillerShape.style.height = height * (this._range.start - this._range.end) / 100; |
| } |
| this.zr.modShape(this._fillerShape.id); |
| this._syncHandleShape(); |
| } |
| }, |
| _syncHandleShape: function () { |
| var x = this._calculableLocation.x; |
| var y = this._calculableLocation.y; |
| var width = this._calculableLocation.width; |
| var height = this._calculableLocation.height; |
| if (this.dataRangeOption.orient == 'horizontal') { |
| this._startShape.style.x = this._fillerShape.style.x; |
| this._startMask.style.width = this._startShape.style.x - x; |
| this._endShape.style.x = this._fillerShape.style.x + this._fillerShape.style.width; |
| this._endMask.style.x = this._endShape.style.x; |
| this._endMask.style.width = x + width - this._endShape.style.x; |
| this._range.start = Math.ceil(100 - (this._startShape.style.x - x) / width * 100); |
| this._range.end = Math.floor(100 - (this._endShape.style.x - x) / width * 100); |
| } else { |
| this._startShape.style.y = this._fillerShape.style.y; |
| this._startMask.style.height = this._startShape.style.y - y; |
| this._endShape.style.y = this._fillerShape.style.y + this._fillerShape.style.height; |
| this._endMask.style.y = this._endShape.style.y; |
| this._endMask.style.height = y + height - this._endShape.style.y; |
| this._range.start = Math.ceil(100 - (this._startShape.style.y - y) / height * 100); |
| this._range.end = Math.floor(100 - (this._endShape.style.y - y) / height * 100); |
| } |
| this._syncShape(); |
| }, |
| _syncFillerShape: function (e) { |
| var x = this._calculableLocation.x; |
| var y = this._calculableLocation.y; |
| var width = this._calculableLocation.width; |
| var height = this._calculableLocation.height; |
| var a; |
| var b; |
| if (this.dataRangeOption.orient == 'horizontal') { |
| a = this._startShape.style.x; |
| b = this._endShape.style.x; |
| if (e.id == this._startShape.id && a >= b) { |
| b = a; |
| this._endShape.style.x = a; |
| } else if (e.id == this._endShape.id && a >= b) { |
| a = b; |
| this._startShape.style.x = a; |
| } |
| this._fillerShape.style.x = a; |
| this._fillerShape.style.width = b - a; |
| this._startMask.style.width = a - x; |
| this._endMask.style.x = b; |
| this._endMask.style.width = x + width - b; |
| this._range.start = Math.ceil(100 - (a - x) / width * 100); |
| this._range.end = Math.floor(100 - (b - x) / width * 100); |
| } else { |
| a = this._startShape.style.y; |
| b = this._endShape.style.y; |
| if (e.id == this._startShape.id && a >= b) { |
| b = a; |
| this._endShape.style.y = a; |
| } else if (e.id == this._endShape.id && a >= b) { |
| a = b; |
| this._startShape.style.y = a; |
| } |
| this._fillerShape.style.y = a; |
| this._fillerShape.style.height = b - a; |
| this._startMask.style.height = a - y; |
| this._endMask.style.y = b; |
| this._endMask.style.height = y + height - b; |
| this._range.start = Math.ceil(100 - (a - y) / height * 100); |
| this._range.end = Math.floor(100 - (b - y) / height * 100); |
| } |
| this._syncShape(); |
| }, |
| _syncShape: function () { |
| this._startShape.position = [ |
| this._startShape.style.x - this._startShape.style._x, |
| this._startShape.style.y - this._startShape.style._y |
| ]; |
| this._startShape.style.text = this._textFormat(this._gap * this._range.start + this.dataRangeOption.min); |
| this._startShape.style.color = this._startShape.highlightStyle.strokeColor = this.getColor(this._gap * this._range.start + this.dataRangeOption.min); |
| this._endShape.position = [ |
| this._endShape.style.x - this._endShape.style._x, |
| this._endShape.style.y - this._endShape.style._y |
| ]; |
| this._endShape.style.text = this._textFormat(this._gap * this._range.end + this.dataRangeOption.min); |
| this._endShape.style.color = this._endShape.highlightStyle.strokeColor = this.getColor(this._gap * this._range.end + this.dataRangeOption.min); |
| this.zr.modShape(this._startShape.id); |
| this.zr.modShape(this._endShape.id); |
| this.zr.modShape(this._startMask.id); |
| this.zr.modShape(this._endMask.id); |
| this.zr.modShape(this._fillerShape.id); |
| this.zr.refresh(); |
| }, |
| _syncData: function () { |
| if (this.dataRangeOption.realtime) { |
| this.messageCenter.dispatch(ecConfig.EVENT.DATA_RANGE, null, { |
| range: { |
| start: this._range.end, |
| end: this._range.start |
| } |
| }, this.myChart); |
| } |
| }, |
| __dataRangeSelected: function (param) { |
| var idx = param.target._idx; |
| this._selectedMap[idx] = !this._selectedMap[idx]; |
| this.messageCenter.dispatch(ecConfig.EVENT.REFRESH, null, null, this.myChart); |
| }, |
| __dispatchHoverLink: function (param) { |
| var valueMin; |
| var valueMax; |
| if (this.dataRangeOption.calculable) { |
| var totalValue = this.dataRangeOption.max - this.dataRangeOption.min; |
| var curValue; |
| if (this.dataRangeOption.orient == 'horizontal') { |
| curValue = (1 - (zrEvent.getX(param.event) - this._calculableLocation.x) / this._calculableLocation.width) * totalValue; |
| } else { |
| curValue = (1 - (zrEvent.getY(param.event) - this._calculableLocation.y) / this._calculableLocation.height) * totalValue; |
| } |
| valueMin = curValue - totalValue * 0.05; |
| valueMax = curValue + totalValue * 0.05; |
| } else { |
| var idx = param.target._idx; |
| valueMax = (this._colorList.length - idx) * this._gap + this.dataRangeOption.min; |
| valueMin = valueMax - this._gap; |
| } |
| this.messageCenter.dispatch(ecConfig.EVENT.DATA_RANGE_HOVERLINK, param.event, { |
| valueMin: valueMin, |
| valueMax: valueMax |
| }, this.myChart); |
| return; |
| }, |
| __onhoverlink: function (param) { |
| if (this.dataRangeOption.show && this.dataRangeOption.hoverLink && this._indicatorShape && param && param.seriesIndex != null && param.dataIndex != null) { |
| var curValue = param.value; |
| if (isNaN(curValue)) { |
| return; |
| } |
| if (curValue < this.dataRangeOption.min) { |
| curValue = this.dataRangeOption.min; |
| } else if (curValue > this.dataRangeOption.max) { |
| curValue = this.dataRangeOption.max; |
| } |
| if (this.dataRangeOption.orient == 'horizontal') { |
| this._indicatorShape.position = [ |
| (this.dataRangeOption.max - curValue) / (this.dataRangeOption.max - this.dataRangeOption.min) * this._calculableLocation.width, |
| 0 |
| ]; |
| } else { |
| this._indicatorShape.position = [ |
| 0, |
| (this.dataRangeOption.max - curValue) / (this.dataRangeOption.max - this.dataRangeOption.min) * this._calculableLocation.height |
| ]; |
| } |
| this._indicatorShape.style.text = param.value; |
| this._indicatorShape.style.color = this.getColor(curValue); |
| this.zr.addHoverShape(this._indicatorShape); |
| } |
| }, |
| _textFormat: function (valueStart, valueEnd) { |
| valueStart = valueStart.toFixed(this.dataRangeOption.precision); |
| valueEnd = typeof valueEnd != 'undefined' ? valueEnd.toFixed(this.dataRangeOption.precision) : ''; |
| if (this.dataRangeOption.formatter) { |
| if (typeof this.dataRangeOption.formatter == 'string') { |
| return this.dataRangeOption.formatter.replace('{value}', valueStart).replace('{value2}', valueEnd); |
| } else if (typeof this.dataRangeOption.formatter == 'function') { |
| return this.dataRangeOption.formatter.call(this.myChart, valueStart, valueEnd); |
| } |
| } |
| if (valueEnd !== '') { |
| return valueStart + ' - ' + valueEnd; |
| } |
| return valueStart; |
| }, |
| refresh: function (newOption) { |
| if (newOption) { |
| this.option = newOption; |
| this.option.dataRange = this.reformOption(this.option.dataRange); |
| this.dataRangeOption = this.option.dataRange; |
| if (!this.myChart.canvasSupported) { |
| this.dataRangeOption.realtime = false; |
| } |
| var splitNumber = this.dataRangeOption.splitNumber <= 0 || this.dataRangeOption.calculable ? 100 : this.dataRangeOption.splitNumber; |
| this._colorList = zrColor.getGradientColors(this.dataRangeOption.color, Math.max((splitNumber - this.dataRangeOption.color.length) / (this.dataRangeOption.color.length - 1), 0) + 1); |
| if (this._colorList.length > splitNumber) { |
| var len = this._colorList.length; |
| var newColorList = [this._colorList[0]]; |
| var step = len / (splitNumber - 1); |
| for (var i = 1; i < splitNumber - 1; i++) { |
| newColorList.push(this._colorList[Math.floor(i * step)]); |
| } |
| newColorList.push(this._colorList[len - 1]); |
| this._colorList = newColorList; |
| } |
| var precision = this.dataRangeOption.precision; |
| this._gap = (this.dataRangeOption.max - this.dataRangeOption.min) / splitNumber; |
| while (this._gap.toFixed(precision) - 0 != this._gap && precision < 5) { |
| precision++; |
| } |
| this.dataRangeOption.precision = precision; |
| this._gap = ((this.dataRangeOption.max - this.dataRangeOption.min) / splitNumber).toFixed(precision) - 0; |
| this._valueTextList = []; |
| for (var i = 0; i < splitNumber; i++) { |
| this._selectedMap[i] = true; |
| this._valueTextList.unshift(this._textFormat(i * this._gap + this.dataRangeOption.min, (i + 1) * this._gap + this.dataRangeOption.min)); |
| } |
| } |
| this.clear(); |
| this._buildShape(); |
| }, |
| getColor: function (value) { |
| if (isNaN(value)) { |
| return null; |
| } |
| if (this.dataRangeOption.min == this.dataRangeOption.max) { |
| return this._colorList[0]; |
| } |
| if (value < this.dataRangeOption.min) { |
| value = this.dataRangeOption.min; |
| } else if (value > this.dataRangeOption.max) { |
| value = this.dataRangeOption.max; |
| } |
| if (this.dataRangeOption.calculable) { |
| if (value - (this._gap * this._range.start + this.dataRangeOption.min) > 0.00005 || value - (this._gap * this._range.end + this.dataRangeOption.min) < -0.00005) { |
| return null; |
| } |
| } |
| var idx = this._colorList.length - Math.ceil((value - this.dataRangeOption.min) / (this.dataRangeOption.max - this.dataRangeOption.min) * this._colorList.length); |
| if (idx == this._colorList.length) { |
| idx--; |
| } |
| if (this._selectedMap[idx]) { |
| return this._colorList[idx]; |
| } else { |
| return null; |
| } |
| }, |
| getColorByIndex: function (idx) { |
| if (idx >= this._colorList.length) { |
| idx = this._colorList.length - 1; |
| } else if (idx < 0) { |
| idx = 0; |
| } |
| return this._colorList[idx]; |
| }, |
| onbeforDispose: function () { |
| this.messageCenter.unbind(ecConfig.EVENT.HOVER, this._onhoverlink); |
| } |
| }; |
| zrUtil.inherits(DataRange, Base); |
| require('../component').define('dataRange', DataRange); |
| return DataRange; |
| });define('echarts/util/shape/HandlePolygon', [ |
| 'require', |
| 'zrender/shape/Base', |
| 'zrender/shape/Polygon', |
| 'zrender/tool/util' |
| ], function (require) { |
| var Base = require('zrender/shape/Base'); |
| var PolygonShape = require('zrender/shape/Polygon'); |
| var zrUtil = require('zrender/tool/util'); |
| function HandlePolygon(options) { |
| Base.call(this, options); |
| } |
| HandlePolygon.prototype = { |
| type: 'handle-polygon', |
| buildPath: function (ctx, style) { |
| PolygonShape.prototype.buildPath(ctx, style); |
| }, |
| isCover: function (x, y) { |
| var originPos = this.getTansform(x, y); |
| x = originPos[0]; |
| y = originPos[1]; |
| var rect = this.style.rect; |
| if (x >= rect.x && x <= rect.x + rect.width && y >= rect.y && y <= rect.y + rect.height) { |
| return true; |
| } else { |
| return false; |
| } |
| } |
| }; |
| zrUtil.inherits(HandlePolygon, Base); |
| return HandlePolygon; |
| });define('echarts/chart/k', [ |
| 'require', |
| '../component/base', |
| './base', |
| '../util/shape/Candle', |
| '../component/axis', |
| '../component/grid', |
| '../component/dataZoom', |
| '../config', |
| '../util/ecData', |
| 'zrender/tool/util', |
| '../chart' |
| ], function (require) { |
| var ComponentBase = require('../component/base'); |
| var ChartBase = require('./base'); |
| var CandleShape = require('../util/shape/Candle'); |
| require('../component/axis'); |
| require('../component/grid'); |
| require('../component/dataZoom'); |
| var ecConfig = require('../config'); |
| var ecData = require('../util/ecData'); |
| var zrUtil = require('zrender/tool/util'); |
| function K(ecTheme, messageCenter, zr, option, myChart) { |
| ComponentBase.call(this, ecTheme, messageCenter, zr, option, myChart); |
| ChartBase.call(this); |
| this.refresh(option); |
| } |
| K.prototype = { |
| type: ecConfig.CHART_TYPE_K, |
| _buildShape: function () { |
| var series = this.series; |
| this.selectedMap = {}; |
| var _position2sIndexMap = { |
| top: [], |
| bottom: [] |
| }; |
| var xAxis; |
| for (var i = 0, l = series.length; i < l; i++) { |
| if (series[i].type === ecConfig.CHART_TYPE_K) { |
| series[i] = this.reformOption(series[i]); |
| this.legendHoverLink = series[i].legendHoverLink || this.legendHoverLink; |
| xAxis = this.component.xAxis.getAxis(series[i].xAxisIndex); |
| if (xAxis.type === ecConfig.COMPONENT_TYPE_AXIS_CATEGORY) { |
| _position2sIndexMap[xAxis.getPosition()].push(i); |
| } |
| } |
| } |
| for (var position in _position2sIndexMap) { |
| if (_position2sIndexMap[position].length > 0) { |
| this._buildSinglePosition(position, _position2sIndexMap[position]); |
| } |
| } |
| this.addShapeList(); |
| }, |
| _buildSinglePosition: function (position, seriesArray) { |
| var mapData = this._mapData(seriesArray); |
| var locationMap = mapData.locationMap; |
| var maxDataLength = mapData.maxDataLength; |
| if (maxDataLength === 0 || locationMap.length === 0) { |
| return; |
| } |
| this._buildHorizontal(seriesArray, maxDataLength, locationMap); |
| for (var i = 0, l = seriesArray.length; i < l; i++) { |
| this.buildMark(seriesArray[i]); |
| } |
| }, |
| _mapData: function (seriesArray) { |
| var series = this.series; |
| var serie; |
| var serieName; |
| var legend = this.component.legend; |
| var locationMap = []; |
| var maxDataLength = 0; |
| for (var i = 0, l = seriesArray.length; i < l; i++) { |
| serie = series[seriesArray[i]]; |
| serieName = serie.name; |
| if (legend) { |
| this.selectedMap[serieName] = legend.isSelected(serieName); |
| } else { |
| this.selectedMap[serieName] = true; |
| } |
| if (this.selectedMap[serieName]) { |
| locationMap.push(seriesArray[i]); |
| } |
| maxDataLength = Math.max(maxDataLength, serie.data.length); |
| } |
| return { |
| locationMap: locationMap, |
| maxDataLength: maxDataLength |
| }; |
| }, |
| _buildHorizontal: function (seriesArray, maxDataLength, locationMap) { |
| var series = this.series; |
| var seriesIndex; |
| var serie; |
| var xAxisIndex; |
| var categoryAxis; |
| var yAxisIndex; |
| var valueAxis; |
| var pointList = {}; |
| var candleWidth; |
| var data; |
| var value; |
| var barMaxWidth; |
| for (var j = 0, k = locationMap.length; j < k; j++) { |
| seriesIndex = locationMap[j]; |
| serie = series[seriesIndex]; |
| xAxisIndex = serie.xAxisIndex || 0; |
| categoryAxis = this.component.xAxis.getAxis(xAxisIndex); |
| candleWidth = serie.barWidth || Math.floor(categoryAxis.getGap() / 2); |
| barMaxWidth = serie.barMaxWidth; |
| if (barMaxWidth && barMaxWidth < candleWidth) { |
| candleWidth = barMaxWidth; |
| } |
| yAxisIndex = serie.yAxisIndex || 0; |
| valueAxis = this.component.yAxis.getAxis(yAxisIndex); |
| pointList[seriesIndex] = []; |
| for (var i = 0, l = maxDataLength; i < l; i++) { |
| if (categoryAxis.getNameByIndex(i) == null) { |
| break; |
| } |
| data = serie.data[i]; |
| value = data != null ? data.value != null ? data.value : data : '-'; |
| if (value === '-' || value.length != 4) { |
| continue; |
| } |
| pointList[seriesIndex].push([ |
| categoryAxis.getCoordByIndex(i), |
| candleWidth, |
| valueAxis.getCoord(value[0]), |
| valueAxis.getCoord(value[1]), |
| valueAxis.getCoord(value[2]), |
| valueAxis.getCoord(value[3]), |
| i, |
| categoryAxis.getNameByIndex(i) |
| ]); |
| } |
| } |
| this._buildKLine(seriesArray, pointList); |
| }, |
| _buildKLine: function (seriesArray, pointList) { |
| var series = this.series; |
| var nLineWidth; |
| var nLineColor; |
| var nLineColor0; |
| var nColor; |
| var nColor0; |
| var eLineWidth; |
| var eLineColor; |
| var eLineColor0; |
| var eColor; |
| var eColor0; |
| var serie; |
| var queryTarget; |
| var data; |
| var seriesPL; |
| var singlePoint; |
| var candleType; |
| var seriesIndex; |
| for (var sIdx = 0, len = seriesArray.length; sIdx < len; sIdx++) { |
| seriesIndex = seriesArray[sIdx]; |
| serie = series[seriesIndex]; |
| seriesPL = pointList[seriesIndex]; |
| if (this._isLarge(seriesPL)) { |
| seriesPL = this._getLargePointList(seriesPL); |
| } |
| if (serie.type === ecConfig.CHART_TYPE_K && seriesPL != null) { |
| queryTarget = serie; |
| nLineWidth = this.query(queryTarget, 'itemStyle.normal.lineStyle.width'); |
| nLineColor = this.query(queryTarget, 'itemStyle.normal.lineStyle.color'); |
| nLineColor0 = this.query(queryTarget, 'itemStyle.normal.lineStyle.color0'); |
| nColor = this.query(queryTarget, 'itemStyle.normal.color'); |
| nColor0 = this.query(queryTarget, 'itemStyle.normal.color0'); |
| eLineWidth = this.query(queryTarget, 'itemStyle.emphasis.lineStyle.width'); |
| eLineColor = this.query(queryTarget, 'itemStyle.emphasis.lineStyle.color'); |
| eLineColor0 = this.query(queryTarget, 'itemStyle.emphasis.lineStyle.color0'); |
| eColor = this.query(queryTarget, 'itemStyle.emphasis.color'); |
| eColor0 = this.query(queryTarget, 'itemStyle.emphasis.color0'); |
| for (var i = 0, l = seriesPL.length; i < l; i++) { |
| singlePoint = seriesPL[i]; |
| data = serie.data[singlePoint[6]]; |
| queryTarget = data; |
| candleType = singlePoint[3] < singlePoint[2]; |
| this.shapeList.push(this._getCandle(seriesIndex, singlePoint[6], singlePoint[7], singlePoint[0], singlePoint[1], singlePoint[2], singlePoint[3], singlePoint[4], singlePoint[5], candleType ? this.query(queryTarget, 'itemStyle.normal.color') || nColor : this.query(queryTarget, 'itemStyle.normal.color0') || nColor0, this.query(queryTarget, 'itemStyle.normal.lineStyle.width') || nLineWidth, candleType ? this.query(queryTarget, 'itemStyle.normal.lineStyle.color') || nLineColor : this.query(queryTarget, 'itemStyle.normal.lineStyle.color0') || nLineColor0, candleType ? this.query(queryTarget, 'itemStyle.emphasis.color') || eColor || nColor : this.query(queryTarget, 'itemStyle.emphasis.color0') || eColor0 || nColor0, this.query(queryTarget, 'itemStyle.emphasis.lineStyle.width') || eLineWidth || nLineWidth, candleType ? this.query(queryTarget, 'itemStyle.emphasis.lineStyle.color') || eLineColor || nLineColor : this.query(queryTarget, 'itemStyle.emphasis.lineStyle.color0') || eLineColor0 || nLineColor0)); |
| } |
| } |
| } |
| }, |
| _isLarge: function (singlePL) { |
| return singlePL[0][1] < 0.5; |
| }, |
| _getLargePointList: function (singlePL) { |
| var total = this.component.grid.getWidth(); |
| var len = singlePL.length; |
| var newList = []; |
| for (var i = 0; i < total; i++) { |
| newList[i] = singlePL[Math.floor(len / total * i)]; |
| } |
| return newList; |
| }, |
| _getCandle: function (seriesIndex, dataIndex, name, x, width, y0, y1, y2, y3, nColor, nLinewidth, nLineColor, eColor, eLinewidth, eLineColor) { |
| var series = this.series; |
| var itemShape = { |
| zlevel: this._zlevelBase, |
| clickable: this.deepQuery([ |
| series[seriesIndex].data[dataIndex], |
| series[seriesIndex] |
| ], 'clickable'), |
| style: { |
| x: x, |
| y: [ |
| y0, |
| y1, |
| y2, |
| y3 |
| ], |
| width: width, |
| color: nColor, |
| strokeColor: nLineColor, |
| lineWidth: nLinewidth, |
| brushType: 'both' |
| }, |
| highlightStyle: { |
| color: eColor, |
| strokeColor: eLineColor, |
| lineWidth: eLinewidth |
| }, |
| _seriesIndex: seriesIndex |
| }; |
| ecData.pack(itemShape, series[seriesIndex], seriesIndex, series[seriesIndex].data[dataIndex], dataIndex, name); |
| itemShape = new CandleShape(itemShape); |
| return itemShape; |
| }, |
| getMarkCoord: function (seriesIndex, mpData) { |
| var serie = this.series[seriesIndex]; |
| var xAxis = this.component.xAxis.getAxis(serie.xAxisIndex); |
| var yAxis = this.component.yAxis.getAxis(serie.yAxisIndex); |
| return [ |
| typeof mpData.xAxis != 'string' && xAxis.getCoordByIndex ? xAxis.getCoordByIndex(mpData.xAxis || 0) : xAxis.getCoord(mpData.xAxis || 0), |
| typeof mpData.yAxis != 'string' && yAxis.getCoordByIndex ? yAxis.getCoordByIndex(mpData.yAxis || 0) : yAxis.getCoord(mpData.yAxis || 0) |
| ]; |
| }, |
| refresh: function (newOption) { |
| if (newOption) { |
| this.option = newOption; |
| this.series = newOption.series; |
| } |
| this.backupShapeList(); |
| this._buildShape(); |
| }, |
| addDataAnimation: function (params) { |
| var series = this.series; |
| var aniMap = {}; |
| for (var i = 0, l = params.length; i < l; i++) { |
| aniMap[params[i][0]] = params[i]; |
| } |
| var x; |
| var dx; |
| var y; |
| var serie; |
| var seriesIndex; |
| var dataIndex; |
| for (var i = 0, l = this.shapeList.length; i < l; i++) { |
| seriesIndex = this.shapeList[i]._seriesIndex; |
| if (aniMap[seriesIndex] && !aniMap[seriesIndex][3]) { |
| if (this.shapeList[i].type === 'candle') { |
| dataIndex = ecData.get(this.shapeList[i], 'dataIndex'); |
| serie = series[seriesIndex]; |
| if (aniMap[seriesIndex][2] && dataIndex === serie.data.length - 1) { |
| this.zr.delShape(this.shapeList[i].id); |
| continue; |
| } else if (!aniMap[seriesIndex][2] && dataIndex === 0) { |
| this.zr.delShape(this.shapeList[i].id); |
| continue; |
| } |
| dx = this.component.xAxis.getAxis(serie.xAxisIndex || 0).getGap(); |
| x = aniMap[seriesIndex][2] ? dx : -dx; |
| y = 0; |
| this.zr.animate(this.shapeList[i].id, '').when(500, { |
| position: [ |
| x, |
| y |
| ] |
| }).start(); |
| } |
| } |
| } |
| } |
| }; |
| zrUtil.inherits(K, ChartBase); |
| zrUtil.inherits(K, ComponentBase); |
| require('../chart').define('k', K); |
| return K; |
| });define('echarts/chart/pie', [ |
| 'require', |
| '../component/base', |
| './base', |
| 'zrender/shape/Text', |
| 'zrender/shape/Ring', |
| 'zrender/shape/Circle', |
| 'zrender/shape/Sector', |
| 'zrender/shape/BrokenLine', |
| '../config', |
| '../util/ecData', |
| 'zrender/tool/util', |
| 'zrender/tool/math', |
| 'zrender/tool/color', |
| '../chart' |
| ], function (require) { |
| var ComponentBase = require('../component/base'); |
| var ChartBase = require('./base'); |
| var TextShape = require('zrender/shape/Text'); |
| var RingShape = require('zrender/shape/Ring'); |
| var CircleShape = require('zrender/shape/Circle'); |
| var SectorShape = require('zrender/shape/Sector'); |
| var BrokenLineShape = require('zrender/shape/BrokenLine'); |
| var ecConfig = require('../config'); |
| var ecData = require('../util/ecData'); |
| var zrUtil = require('zrender/tool/util'); |
| var zrMath = require('zrender/tool/math'); |
| var zrColor = require('zrender/tool/color'); |
| function Pie(ecTheme, messageCenter, zr, option, myChart) { |
| ComponentBase.call(this, ecTheme, messageCenter, zr, option, myChart); |
| ChartBase.call(this); |
| var self = this; |
| self.shapeHandler.onmouseover = function (param) { |
| var shape = param.target; |
| var seriesIndex = ecData.get(shape, 'seriesIndex'); |
| var dataIndex = ecData.get(shape, 'dataIndex'); |
| var percent = ecData.get(shape, 'special'); |
| var center = [ |
| shape.style.x, |
| shape.style.y |
| ]; |
| var startAngle = shape.style.startAngle; |
| var endAngle = shape.style.endAngle; |
| var midAngle = ((endAngle + startAngle) / 2 + 360) % 360; |
| var defaultColor = shape.highlightStyle.color; |
| var label = self.getLabel(seriesIndex, dataIndex, percent, center, midAngle, defaultColor, true); |
| if (label) { |
| self.zr.addHoverShape(label); |
| } |
| var labelLine = self.getLabelLine(seriesIndex, dataIndex, center, shape.style.r0, shape.style.r, midAngle, defaultColor, true); |
| if (labelLine) { |
| self.zr.addHoverShape(labelLine); |
| } |
| }; |
| this.refresh(option); |
| } |
| Pie.prototype = { |
| type: ecConfig.CHART_TYPE_PIE, |
| _buildShape: function () { |
| var series = this.series; |
| var legend = this.component.legend; |
| this.selectedMap = {}; |
| this._selected = {}; |
| var center; |
| var radius; |
| var pieCase; |
| this._selectedMode = false; |
| var serieName; |
| for (var i = 0, l = series.length; i < l; i++) { |
| if (series[i].type === ecConfig.CHART_TYPE_PIE) { |
| series[i] = this.reformOption(series[i]); |
| this.legendHoverLink = series[i].legendHoverLink || this.legendHoverLink; |
| serieName = series[i].name || ''; |
| this.selectedMap[serieName] = legend ? legend.isSelected(serieName) : true; |
| if (!this.selectedMap[serieName]) { |
| continue; |
| } |
| center = this.parseCenter(this.zr, series[i].center); |
| radius = this.parseRadius(this.zr, series[i].radius); |
| this._selectedMode = this._selectedMode || series[i].selectedMode; |
| this._selected[i] = []; |
| if (this.deepQuery([ |
| series[i], |
| this.option |
| ], 'calculable')) { |
| pieCase = { |
| zlevel: this._zlevelBase, |
| hoverable: false, |
| style: { |
| x: center[0], |
| y: center[1], |
| r0: radius[0] <= 10 ? 0 : radius[0] - 10, |
| r: radius[1] + 10, |
| brushType: 'stroke', |
| lineWidth: 1, |
| strokeColor: series[i].calculableHolderColor || this.ecTheme.calculableHolderColor |
| } |
| }; |
| ecData.pack(pieCase, series[i], i, undefined, -1); |
| this.setCalculable(pieCase); |
| pieCase = radius[0] <= 10 ? new CircleShape(pieCase) : new RingShape(pieCase); |
| this.shapeList.push(pieCase); |
| } |
| this._buildSinglePie(i); |
| this.buildMark(i); |
| } |
| } |
| this.addShapeList(); |
| }, |
| _buildSinglePie: function (seriesIndex) { |
| var series = this.series; |
| var serie = series[seriesIndex]; |
| var data = serie.data; |
| var legend = this.component.legend; |
| var itemName; |
| var totalSelected = 0; |
| var totalSelectedValue0 = 0; |
| var totalValue = 0; |
| var maxValue = Number.NEGATIVE_INFINITY; |
| var singleShapeList = []; |
| for (var i = 0, l = data.length; i < l; i++) { |
| itemName = data[i].name; |
| this.selectedMap[itemName] = legend ? legend.isSelected(itemName) : true; |
| if (this.selectedMap[itemName] && !isNaN(data[i].value)) { |
| if (+data[i].value !== 0) { |
| totalSelected++; |
| } else { |
| totalSelectedValue0++; |
| } |
| totalValue += +data[i].value; |
| maxValue = Math.max(maxValue, +data[i].value); |
| } |
| } |
| if (totalValue === 0) { |
| return; |
| } |
| var percent = 100; |
| var clockWise = serie.clockWise; |
| var startAngle = (serie.startAngle.toFixed(2) - 0 + 360) % 360; |
| var endAngle; |
| var minAngle = serie.minAngle || 0.01; |
| var totalAngle = 360 - minAngle * totalSelected - 0.01 * totalSelectedValue0; |
| var defaultColor; |
| var roseType = serie.roseType; |
| var center; |
| var radius; |
| var r0; |
| var r1; |
| for (var i = 0, l = data.length; i < l; i++) { |
| itemName = data[i].name; |
| if (!this.selectedMap[itemName] || isNaN(data[i].value)) { |
| continue; |
| } |
| defaultColor = legend ? legend.getColor(itemName) : this.zr.getColor(i); |
| percent = data[i].value / totalValue; |
| if (roseType != 'area') { |
| endAngle = clockWise ? startAngle - percent * totalAngle - (percent !== 0 ? minAngle : 0.01) : percent * totalAngle + startAngle + (percent !== 0 ? minAngle : 0.01); |
| } else { |
| endAngle = clockWise ? startAngle - 360 / l : 360 / l + startAngle; |
| } |
| endAngle = endAngle.toFixed(2) - 0; |
| percent = (percent * 100).toFixed(2); |
| center = this.parseCenter(this.zr, serie.center); |
| radius = this.parseRadius(this.zr, serie.radius); |
| r0 = +radius[0]; |
| r1 = +radius[1]; |
| if (roseType === 'radius') { |
| r1 = data[i].value / maxValue * (r1 - r0) * 0.8 + (r1 - r0) * 0.2 + r0; |
| } else if (roseType === 'area') { |
| r1 = Math.sqrt(data[i].value / maxValue) * (r1 - r0) + r0; |
| } |
| if (clockWise) { |
| var temp; |
| temp = startAngle; |
| startAngle = endAngle; |
| endAngle = temp; |
| } |
| this._buildItem(singleShapeList, seriesIndex, i, percent, data[i].selected, center, r0, r1, startAngle, endAngle, defaultColor); |
| if (!clockWise) { |
| startAngle = endAngle; |
| } |
| } |
| this._autoLabelLayout(singleShapeList, center, r1); |
| for (var i = 0, l = singleShapeList.length; i < l; i++) { |
| this.shapeList.push(singleShapeList[i]); |
| } |
| singleShapeList = null; |
| }, |
| _buildItem: function (singleShapeList, seriesIndex, dataIndex, percent, isSelected, center, r0, r1, startAngle, endAngle, defaultColor) { |
| var series = this.series; |
| var midAngle = ((endAngle + startAngle) / 2 + 360) % 360; |
| var sector = this.getSector(seriesIndex, dataIndex, percent, isSelected, center, r0, r1, startAngle, endAngle, defaultColor); |
| ecData.pack(sector, series[seriesIndex], seriesIndex, series[seriesIndex].data[dataIndex], dataIndex, series[seriesIndex].data[dataIndex].name, percent); |
| singleShapeList.push(sector); |
| var label = this.getLabel(seriesIndex, dataIndex, percent, center, midAngle, defaultColor, false); |
| var labelLine = this.getLabelLine(seriesIndex, dataIndex, center, r0, r1, midAngle, defaultColor, false); |
| if (labelLine) { |
| ecData.pack(labelLine, series[seriesIndex], seriesIndex, series[seriesIndex].data[dataIndex], dataIndex, series[seriesIndex].data[dataIndex].name, percent); |
| singleShapeList.push(labelLine); |
| } |
| if (label) { |
| ecData.pack(label, series[seriesIndex], seriesIndex, series[seriesIndex].data[dataIndex], dataIndex, series[seriesIndex].data[dataIndex].name, percent); |
| label._labelLine = labelLine; |
| singleShapeList.push(label); |
| } |
| }, |
| getSector: function (seriesIndex, dataIndex, percent, isSelected, center, r0, r1, startAngle, endAngle, defaultColor) { |
| var series = this.series; |
| var serie = series[seriesIndex]; |
| var data = serie.data[dataIndex]; |
| var queryTarget = [ |
| data, |
| serie |
| ]; |
| var normal = this.deepMerge(queryTarget, 'itemStyle.normal') || {}; |
| var emphasis = this.deepMerge(queryTarget, 'itemStyle.emphasis') || {}; |
| var normalColor = this.getItemStyleColor(normal.color, seriesIndex, dataIndex, data) || defaultColor; |
| var emphasisColor = this.getItemStyleColor(emphasis.color, seriesIndex, dataIndex, data) || (typeof normalColor === 'string' ? zrColor.lift(normalColor, -0.2) : normalColor); |
| var sector = { |
| zlevel: this._zlevelBase, |
| clickable: this.deepQuery(queryTarget, 'clickable'), |
| style: { |
| x: center[0], |
| y: center[1], |
| r0: r0, |
| r: r1, |
| startAngle: startAngle, |
| endAngle: endAngle, |
| brushType: 'both', |
| color: normalColor, |
| lineWidth: normal.borderWidth, |
| strokeColor: normal.borderColor, |
| lineJoin: 'round' |
| }, |
| highlightStyle: { |
| color: emphasisColor, |
| lineWidth: emphasis.borderWidth, |
| strokeColor: emphasis.borderColor, |
| lineJoin: 'round' |
| }, |
| _seriesIndex: seriesIndex, |
| _dataIndex: dataIndex |
| }; |
| if (isSelected) { |
| var midAngle = ((sector.style.startAngle + sector.style.endAngle) / 2).toFixed(2) - 0; |
| sector.style._hasSelected = true; |
| sector.style._x = sector.style.x; |
| sector.style._y = sector.style.y; |
| var offset = this.query(serie, 'selectedOffset'); |
| sector.style.x += zrMath.cos(midAngle, true) * offset; |
| sector.style.y -= zrMath.sin(midAngle, true) * offset; |
| this._selected[seriesIndex][dataIndex] = true; |
| } else { |
| this._selected[seriesIndex][dataIndex] = false; |
| } |
| if (this._selectedMode) { |
| sector.onclick = this.shapeHandler.onclick; |
| } |
| if (this.deepQuery([ |
| data, |
| serie, |
| this.option |
| ], 'calculable')) { |
| this.setCalculable(sector); |
| sector.draggable = true; |
| } |
| if (this._needLabel(serie, data, true) || this._needLabelLine(serie, data, true)) { |
| sector.onmouseover = this.shapeHandler.onmouseover; |
| } |
| sector = new SectorShape(sector); |
| return sector; |
| }, |
| getLabel: function (seriesIndex, dataIndex, percent, center, midAngle, defaultColor, isEmphasis) { |
| var series = this.series; |
| var serie = series[seriesIndex]; |
| var data = serie.data[dataIndex]; |
| if (!this._needLabel(serie, data, isEmphasis)) { |
| return; |
| } |
| var status = isEmphasis ? 'emphasis' : 'normal'; |
| var itemStyle = zrUtil.merge(zrUtil.clone(data.itemStyle) || {}, serie.itemStyle); |
| var labelControl = itemStyle[status].label; |
| var textStyle = labelControl.textStyle || {}; |
| var centerX = center[0]; |
| var centerY = center[1]; |
| var x; |
| var y; |
| var radius = this.parseRadius(this.zr, serie.radius); |
| var textAlign; |
| var textBaseline = 'middle'; |
| labelControl.position = labelControl.position || itemStyle.normal.label.position; |
| if (labelControl.position === 'center') { |
| x = centerX; |
| y = centerY; |
| textAlign = 'center'; |
| } else if (labelControl.position === 'inner' || labelControl.position === 'inside') { |
| radius = (radius[0] + radius[1]) / 2; |
| x = Math.round(centerX + radius * zrMath.cos(midAngle, true)); |
| y = Math.round(centerY - radius * zrMath.sin(midAngle, true)); |
| defaultColor = '#fff'; |
| textAlign = 'center'; |
| } else { |
| radius = radius[1] - -itemStyle[status].labelLine.length; |
| x = Math.round(centerX + radius * zrMath.cos(midAngle, true)); |
| y = Math.round(centerY - radius * zrMath.sin(midAngle, true)); |
| textAlign = midAngle >= 90 && midAngle <= 270 ? 'right' : 'left'; |
| } |
| if (labelControl.position != 'center' && labelControl.position != 'inner' && labelControl.position != 'inside') { |
| x += textAlign === 'left' ? 20 : -20; |
| } |
| data.__labelX = x - (textAlign === 'left' ? 5 : -5); |
| data.__labelY = y; |
| var ts = new TextShape({ |
| zlevel: this._zlevelBase + 1, |
| hoverable: false, |
| style: { |
| x: x, |
| y: y, |
| color: textStyle.color || defaultColor, |
| text: this.getLabelText(seriesIndex, dataIndex, percent, status), |
| textAlign: textStyle.align || textAlign, |
| textBaseline: textStyle.baseline || textBaseline, |
| textFont: this.getFont(textStyle) |
| }, |
| highlightStyle: { brushType: 'fill' } |
| }); |
| ts._radius = radius; |
| ts._labelPosition = labelControl.position || 'outer'; |
| ts._rect = ts.getRect(ts.style); |
| ts._seriesIndex = seriesIndex; |
| ts._dataIndex = dataIndex; |
| return ts; |
| }, |
| getLabelText: function (seriesIndex, dataIndex, percent, status) { |
| var series = this.series; |
| var serie = series[seriesIndex]; |
| var data = serie.data[dataIndex]; |
| var formatter = this.deepQuery([ |
| data, |
| serie |
| ], 'itemStyle.' + status + '.label.formatter'); |
| if (formatter) { |
| if (typeof formatter === 'function') { |
| return formatter.call(this.myChart, serie.name, data.name, data.value, percent); |
| } else if (typeof formatter === 'string') { |
| formatter = formatter.replace('{a}', '{a0}').replace('{b}', '{b0}').replace('{c}', '{c0}').replace('{d}', '{d0}'); |
| formatter = formatter.replace('{a0}', serie.name).replace('{b0}', data.name).replace('{c0}', data.value).replace('{d0}', percent); |
| return formatter; |
| } |
| } else { |
| return data.name; |
| } |
| }, |
| getLabelLine: function (seriesIndex, dataIndex, center, r0, r1, midAngle, defaultColor, isEmphasis) { |
| var series = this.series; |
| var serie = series[seriesIndex]; |
| var data = serie.data[dataIndex]; |
| if (this._needLabelLine(serie, data, isEmphasis)) { |
| var status = isEmphasis ? 'emphasis' : 'normal'; |
| var itemStyle = zrUtil.merge(zrUtil.clone(data.itemStyle) || {}, serie.itemStyle); |
| var labelLineControl = itemStyle[status].labelLine; |
| var lineStyle = labelLineControl.lineStyle || {}; |
| var centerX = center[0]; |
| var centerY = center[1]; |
| var minRadius = r1; |
| var maxRadius = this.parseRadius(this.zr, serie.radius)[1] - -labelLineControl.length; |
| var cosValue = zrMath.cos(midAngle, true); |
| var sinValue = zrMath.sin(midAngle, true); |
| return new BrokenLineShape({ |
| zlevel: this._zlevelBase + 1, |
| hoverable: false, |
| style: { |
| pointList: [ |
| [ |
| centerX + minRadius * cosValue, |
| centerY - minRadius * sinValue |
| ], |
| [ |
| centerX + maxRadius * cosValue, |
| centerY - maxRadius * sinValue |
| ], |
| [ |
| data.__labelX, |
| data.__labelY |
| ] |
| ], |
| strokeColor: lineStyle.color || defaultColor, |
| lineType: lineStyle.type, |
| lineWidth: lineStyle.width |
| }, |
| _seriesIndex: seriesIndex, |
| _dataIndex: dataIndex |
| }); |
| } else { |
| return; |
| } |
| }, |
| _needLabel: function (serie, data, isEmphasis) { |
| return this.deepQuery([ |
| data, |
| serie |
| ], 'itemStyle.' + (isEmphasis ? 'emphasis' : 'normal') + '.label.show'); |
| }, |
| _needLabelLine: function (serie, data, isEmphasis) { |
| return this.deepQuery([ |
| data, |
| serie |
| ], 'itemStyle.' + (isEmphasis ? 'emphasis' : 'normal') + '.labelLine.show'); |
| }, |
| _autoLabelLayout: function (sList, center, r) { |
| var leftList = []; |
| var rightList = []; |
| for (var i = 0, l = sList.length; i < l; i++) { |
| if (sList[i]._labelPosition === 'outer' || sList[i]._labelPosition === 'outside') { |
| sList[i]._rect._y = sList[i]._rect.y; |
| if (sList[i]._rect.x < center[0]) { |
| leftList.push(sList[i]); |
| } else { |
| rightList.push(sList[i]); |
| } |
| } |
| } |
| this._layoutCalculate(leftList, center, r, -1); |
| this._layoutCalculate(rightList, center, r, 1); |
| }, |
| _layoutCalculate: function (tList, center, r, direction) { |
| tList.sort(function (a, b) { |
| return a._rect.y - b._rect.y; |
| }); |
| function _changeDown(start, end, delta, direction) { |
| for (var j = start; j < end; j++) { |
| tList[j]._rect.y += delta; |
| tList[j].style.y += delta; |
| if (tList[j]._labelLine) { |
| tList[j]._labelLine.style.pointList[1][1] += delta; |
| tList[j]._labelLine.style.pointList[2][1] += delta; |
| } |
| if (j > start && j + 1 < end && tList[j + 1]._rect.y > tList[j]._rect.y + tList[j]._rect.height) { |
| _changeUp(j, delta / 2); |
| return; |
| } |
| } |
| _changeUp(end - 1, delta / 2); |
| } |
| function _changeUp(end, delta) { |
| for (var j = end; j >= 0; j--) { |
| tList[j]._rect.y -= delta; |
| tList[j].style.y -= delta; |
| if (tList[j]._labelLine) { |
| tList[j]._labelLine.style.pointList[1][1] -= delta; |
| tList[j]._labelLine.style.pointList[2][1] -= delta; |
| } |
| if (j > 0 && tList[j]._rect.y > tList[j - 1]._rect.y + tList[j - 1]._rect.height) { |
| break; |
| } |
| } |
| } |
| function _changeX(sList, isDownList, center, r, direction) { |
| var x = center[0]; |
| var y = center[1]; |
| var deltaX; |
| var deltaY; |
| var length; |
| var lastDeltaX = direction > 0 ? isDownList ? Number.MAX_VALUE : 0 : isDownList ? Number.MAX_VALUE : 0; |
| for (var i = 0, l = sList.length; i < l; i++) { |
| deltaY = Math.abs(sList[i]._rect.y - y); |
| length = sList[i]._radius - r; |
| deltaX = deltaY < r + length ? Math.sqrt((r + length + 20) * (r + length + 20) - Math.pow(sList[i]._rect.y - y, 2)) : Math.abs(sList[i]._rect.x + (direction > 0 ? 0 : sList[i]._rect.width) - x); |
| if (isDownList && deltaX >= lastDeltaX) { |
| deltaX = lastDeltaX - 10; |
| } |
| if (!isDownList && deltaX <= lastDeltaX) { |
| deltaX = lastDeltaX + 10; |
| } |
| sList[i]._rect.x = sList[i].style.x = x + deltaX * direction; |
| sList[i]._labelLine.style.pointList[2][0] = x + (deltaX - 5) * direction; |
| sList[i]._labelLine.style.pointList[1][0] = x + (deltaX - 20) * direction; |
| lastDeltaX = deltaX; |
| } |
| } |
| var lastY = 0; |
| var delta; |
| var len = tList.length; |
| var upList = []; |
| var downList = []; |
| for (var i = 0; i < len; i++) { |
| delta = tList[i]._rect.y - lastY; |
| if (delta < 0) { |
| _changeDown(i, len, -delta, direction); |
| } |
| lastY = tList[i]._rect.y + tList[i]._rect.height; |
| } |
| if (this.zr.getHeight() - lastY < 0) { |
| _changeUp(len - 1, lastY - this.zr.getHeight()); |
| } |
| for (var i = 0; i < len; i++) { |
| if (tList[i]._rect.y >= center[1]) { |
| downList.push(tList[i]); |
| } else { |
| upList.push(tList[i]); |
| } |
| } |
| _changeX(downList, true, center, r, direction); |
| _changeX(upList, false, center, r, direction); |
| }, |
| reformOption: function (opt) { |
| var _merge = zrUtil.merge; |
| opt = _merge(opt || {}, this.ecTheme.pie); |
| opt.itemStyle.normal.label.textStyle = _merge(opt.itemStyle.normal.label.textStyle || {}, this.ecTheme.textStyle); |
| opt.itemStyle.emphasis.label.textStyle = _merge(opt.itemStyle.emphasis.label.textStyle || {}, this.ecTheme.textStyle); |
| return opt; |
| }, |
| refresh: function (newOption) { |
| if (newOption) { |
| this.option = newOption; |
| this.series = newOption.series; |
| } |
| this.backupShapeList(); |
| this._buildShape(); |
| }, |
| addDataAnimation: function (params) { |
| var series = this.series; |
| var aniMap = {}; |
| for (var i = 0, l = params.length; i < l; i++) { |
| aniMap[params[i][0]] = params[i]; |
| } |
| var sectorMap = {}; |
| var textMap = {}; |
| var lineMap = {}; |
| var backupShapeList = this.shapeList; |
| this.shapeList = []; |
| var seriesIndex; |
| var isHead; |
| var dataGrow; |
| var deltaIdxMap = {}; |
| for (var i = 0, l = params.length; i < l; i++) { |
| seriesIndex = params[i][0]; |
| isHead = params[i][2]; |
| dataGrow = params[i][3]; |
| if (series[seriesIndex] && series[seriesIndex].type === ecConfig.CHART_TYPE_PIE) { |
| if (isHead) { |
| if (!dataGrow) { |
| sectorMap[seriesIndex + '_' + series[seriesIndex].data.length] = 'delete'; |
| } |
| deltaIdxMap[seriesIndex] = 1; |
| } else { |
| if (!dataGrow) { |
| sectorMap[seriesIndex + '_-1'] = 'delete'; |
| deltaIdxMap[seriesIndex] = -1; |
| } else { |
| deltaIdxMap[seriesIndex] = 0; |
| } |
| } |
| this._buildSinglePie(seriesIndex); |
| } |
| } |
| var dataIndex; |
| var key; |
| for (var i = 0, l = this.shapeList.length; i < l; i++) { |
| seriesIndex = this.shapeList[i]._seriesIndex; |
| dataIndex = this.shapeList[i]._dataIndex; |
| key = seriesIndex + '_' + dataIndex; |
| switch (this.shapeList[i].type) { |
| case 'sector': |
| sectorMap[key] = this.shapeList[i]; |
| break; |
| case 'text': |
| textMap[key] = this.shapeList[i]; |
| break; |
| case 'broken-line': |
| lineMap[key] = this.shapeList[i]; |
| break; |
| } |
| } |
| this.shapeList = []; |
| var targeSector; |
| for (var i = 0, l = backupShapeList.length; i < l; i++) { |
| seriesIndex = backupShapeList[i]._seriesIndex; |
| if (aniMap[seriesIndex]) { |
| dataIndex = backupShapeList[i]._dataIndex + deltaIdxMap[seriesIndex]; |
| key = seriesIndex + '_' + dataIndex; |
| targeSector = sectorMap[key]; |
| if (!targeSector) { |
| continue; |
| } |
| if (backupShapeList[i].type === 'sector') { |
| if (targeSector != 'delete') { |
| this.zr.animate(backupShapeList[i].id, 'style').when(400, { |
| startAngle: targeSector.style.startAngle, |
| endAngle: targeSector.style.endAngle |
| }).start(); |
| } else { |
| this.zr.animate(backupShapeList[i].id, 'style').when(400, deltaIdxMap[seriesIndex] < 0 ? { startAngle: backupShapeList[i].style.startAngle } : { endAngle: backupShapeList[i].style.endAngle }).start(); |
| } |
| } else if (backupShapeList[i].type === 'text' || backupShapeList[i].type === 'broken-line') { |
| if (targeSector === 'delete') { |
| this.zr.delShape(backupShapeList[i].id); |
| } else { |
| switch (backupShapeList[i].type) { |
| case 'text': |
| targeSector = textMap[key]; |
| this.zr.animate(backupShapeList[i].id, 'style').when(400, { |
| x: targeSector.style.x, |
| y: targeSector.style.y |
| }).start(); |
| break; |
| case 'broken-line': |
| targeSector = lineMap[key]; |
| this.zr.animate(backupShapeList[i].id, 'style').when(400, { pointList: targeSector.style.pointList }).start(); |
| break; |
| } |
| } |
| } |
| } |
| } |
| this.shapeList = backupShapeList; |
| }, |
| onclick: function (param) { |
| var series = this.series; |
| if (!this.isClick || !param.target) { |
| return; |
| } |
| this.isClick = false; |
| var offset; |
| var target = param.target; |
| var style = target.style; |
| var seriesIndex = ecData.get(target, 'seriesIndex'); |
| var dataIndex = ecData.get(target, 'dataIndex'); |
| for (var i = 0, len = this.shapeList.length; i < len; i++) { |
| if (this.shapeList[i].id === target.id) { |
| seriesIndex = ecData.get(target, 'seriesIndex'); |
| dataIndex = ecData.get(target, 'dataIndex'); |
| if (!style._hasSelected) { |
| var midAngle = ((style.startAngle + style.endAngle) / 2).toFixed(2) - 0; |
| target.style._hasSelected = true; |
| this._selected[seriesIndex][dataIndex] = true; |
| target.style._x = target.style.x; |
| target.style._y = target.style.y; |
| offset = this.query(series[seriesIndex], 'selectedOffset'); |
| target.style.x += zrMath.cos(midAngle, true) * offset; |
| target.style.y -= zrMath.sin(midAngle, true) * offset; |
| } else { |
| target.style.x = target.style._x; |
| target.style.y = target.style._y; |
| target.style._hasSelected = false; |
| this._selected[seriesIndex][dataIndex] = false; |
| } |
| this.zr.modShape(target.id, target); |
| } else if (this.shapeList[i].style._hasSelected && this._selectedMode === 'single') { |
| seriesIndex = ecData.get(this.shapeList[i], 'seriesIndex'); |
| dataIndex = ecData.get(this.shapeList[i], 'dataIndex'); |
| this.shapeList[i].style.x = this.shapeList[i].style._x; |
| this.shapeList[i].style.y = this.shapeList[i].style._y; |
| this.shapeList[i].style._hasSelected = false; |
| this._selected[seriesIndex][dataIndex] = false; |
| this.zr.modShape(this.shapeList[i].id, this.shapeList[i]); |
| } |
| } |
| this.messageCenter.dispatch(ecConfig.EVENT.PIE_SELECTED, param.event, { |
| selected: this._selected, |
| target: ecData.get(target, 'name') |
| }, this.myChart); |
| this.zr.refresh(); |
| } |
| }; |
| zrUtil.inherits(Pie, ChartBase); |
| zrUtil.inherits(Pie, ComponentBase); |
| require('../chart').define('pie', Pie); |
| return Pie; |
| });define('echarts/chart/radar', [ |
| 'require', |
| '../component/base', |
| './base', |
| 'zrender/shape/Polygon', |
| '../component/polar', |
| '../config', |
| '../util/ecData', |
| 'zrender/tool/util', |
| 'zrender/tool/color', |
| '../util/accMath', |
| '../chart' |
| ], function (require) { |
| var ComponentBase = require('../component/base'); |
| var ChartBase = require('./base'); |
| var PolygonShape = require('zrender/shape/Polygon'); |
| require('../component/polar'); |
| var ecConfig = require('../config'); |
| var ecData = require('../util/ecData'); |
| var zrUtil = require('zrender/tool/util'); |
| var zrColor = require('zrender/tool/color'); |
| function Radar(ecTheme, messageCenter, zr, option, myChart) { |
| ComponentBase.call(this, ecTheme, messageCenter, zr, option, myChart); |
| ChartBase.call(this); |
| this.refresh(option); |
| } |
| Radar.prototype = { |
| type: ecConfig.CHART_TYPE_RADAR, |
| _buildShape: function () { |
| this.selectedMap = {}; |
| this._symbol = this.option.symbolList; |
| this._queryTarget; |
| this._dropBoxList = []; |
| this._radarDataCounter = 0; |
| var series = this.series; |
| var legend = this.component.legend; |
| var serieName; |
| for (var i = 0, l = series.length; i < l; i++) { |
| if (series[i].type === ecConfig.CHART_TYPE_RADAR) { |
| this.serie = this.reformOption(series[i]); |
| this.legendHoverLink = series[i].legendHoverLink || this.legendHoverLink; |
| serieName = this.serie.name || ''; |
| this.selectedMap[serieName] = legend ? legend.isSelected(serieName) : true; |
| if (this.selectedMap[serieName]) { |
| this._queryTarget = [ |
| this.serie, |
| this.option |
| ]; |
| if (this.deepQuery(this._queryTarget, 'calculable')) { |
| this._addDropBox(i); |
| } |
| this._buildSingleRadar(i); |
| this.buildMark(i); |
| } |
| } |
| } |
| this.addShapeList(); |
| }, |
| _buildSingleRadar: function (index) { |
| var legend = this.component.legend; |
| var iconShape; |
| var data = this.serie.data; |
| var defaultColor; |
| var name; |
| var pointList; |
| var calculable = this.deepQuery(this._queryTarget, 'calculable'); |
| for (var i = 0; i < data.length; i++) { |
| name = data[i].name || ''; |
| this.selectedMap[name] = legend ? legend.isSelected(name) : true; |
| if (!this.selectedMap[name]) { |
| continue; |
| } |
| if (legend) { |
| defaultColor = legend.getColor(name); |
| iconShape = legend.getItemShape(name); |
| if (iconShape) { |
| iconShape.style.brushType = this.deepQuery([ |
| data[i], |
| this.serie |
| ], 'itemStyle.normal.areaStyle') ? 'both' : 'stroke'; |
| legend.setItemShape(name, iconShape); |
| } |
| } else { |
| defaultColor = this.zr.getColor(i); |
| } |
| pointList = this._getPointList(this.serie.polarIndex, data[i]); |
| this._addSymbol(pointList, defaultColor, i, index, this.serie.polarIndex); |
| this._addDataShape(pointList, defaultColor, data[i], index, i, calculable); |
| this._radarDataCounter++; |
| } |
| }, |
| _getPointList: function (polarIndex, dataArr) { |
| var pointList = []; |
| var vector; |
| var polar = this.component.polar; |
| var value; |
| for (var i = 0, l = dataArr.value.length; i < l; i++) { |
| value = dataArr.value[i].value != null ? dataArr.value[i].value : dataArr.value[i]; |
| vector = value != '-' ? polar.getVector(polarIndex, i, value) : false; |
| if (vector) { |
| pointList.push(vector); |
| } |
| } |
| return pointList; |
| }, |
| _addSymbol: function (pointList, defaultColor, dataIndex, seriesIndex, polarIndex) { |
| var series = this.series; |
| var itemShape; |
| var polar = this.component.polar; |
| for (var i = 0, l = pointList.length; i < l; i++) { |
| itemShape = this.getSymbolShape(this.deepMerge([ |
| series[seriesIndex].data[dataIndex], |
| series[seriesIndex] |
| ]), seriesIndex, series[seriesIndex].data[dataIndex].value[i], i, polar.getIndicatorText(polarIndex, i), pointList[i][0], pointList[i][1], this._symbol[this._radarDataCounter % this._symbol.length], defaultColor, '#fff', 'vertical'); |
| itemShape.zlevel = this._zlevelBase + 1; |
| ecData.set(itemShape, 'data', series[seriesIndex].data[dataIndex]); |
| ecData.set(itemShape, 'value', series[seriesIndex].data[dataIndex].value); |
| ecData.set(itemShape, 'dataIndex', dataIndex); |
| ecData.set(itemShape, 'special', i); |
| this.shapeList.push(itemShape); |
| } |
| }, |
| _addDataShape: function (pointList, defaultColor, data, seriesIndex, dataIndex, calculable) { |
| var series = this.series; |
| var queryTarget = [ |
| data, |
| this.serie |
| ]; |
| var nColor = this.getItemStyleColor(this.deepQuery(queryTarget, 'itemStyle.normal.color'), seriesIndex, dataIndex, data); |
| var nLineWidth = this.deepQuery(queryTarget, 'itemStyle.normal.lineStyle.width'); |
| var nLineType = this.deepQuery(queryTarget, 'itemStyle.normal.lineStyle.type'); |
| var nAreaColor = this.deepQuery(queryTarget, 'itemStyle.normal.areaStyle.color'); |
| var nIsAreaFill = this.deepQuery(queryTarget, 'itemStyle.normal.areaStyle'); |
| var shape = { |
| zlevel: this._zlevelBase, |
| style: { |
| pointList: pointList, |
| brushType: nIsAreaFill ? 'both' : 'stroke', |
| color: nAreaColor || nColor || (typeof defaultColor === 'string' ? zrColor.alpha(defaultColor, 0.5) : defaultColor), |
| strokeColor: nColor || defaultColor, |
| lineWidth: nLineWidth, |
| lineType: nLineType |
| }, |
| highlightStyle: { |
| brushType: this.deepQuery(queryTarget, 'itemStyle.emphasis.areaStyle') || nIsAreaFill ? 'both' : 'stroke', |
| color: this.deepQuery(queryTarget, 'itemStyle.emphasis.areaStyle.color') || nAreaColor || nColor || (typeof defaultColor === 'string' ? zrColor.alpha(defaultColor, 0.5) : defaultColor), |
| strokeColor: this.getItemStyleColor(this.deepQuery(queryTarget, 'itemStyle.emphasis.color'), seriesIndex, dataIndex, data) || nColor || defaultColor, |
| lineWidth: this.deepQuery(queryTarget, 'itemStyle.emphasis.lineStyle.width') || nLineWidth, |
| lineType: this.deepQuery(queryTarget, 'itemStyle.emphasis.lineStyle.type') || nLineType |
| } |
| }; |
| ecData.pack(shape, series[seriesIndex], seriesIndex, data, dataIndex, data.name, this.component.polar.getIndicator(series[seriesIndex].polarIndex)); |
| if (calculable) { |
| shape.draggable = true; |
| this.setCalculable(shape); |
| } |
| shape = new PolygonShape(shape); |
| this.shapeList.push(shape); |
| }, |
| _addDropBox: function (index) { |
| var series = this.series; |
| var polarIndex = this.deepQuery(this._queryTarget, 'polarIndex'); |
| if (!this._dropBoxList[polarIndex]) { |
| var shape = this.component.polar.getDropBox(polarIndex); |
| shape.zlevel = this._zlevelBase; |
| this.setCalculable(shape); |
| ecData.pack(shape, series, index, undefined, -1); |
| this.shapeList.push(shape); |
| this._dropBoxList[polarIndex] = true; |
| } |
| }, |
| ondragend: function (param, status) { |
| var series = this.series; |
| if (!this.isDragend || !param.target) { |
| return; |
| } |
| var target = param.target; |
| var seriesIndex = ecData.get(target, 'seriesIndex'); |
| var dataIndex = ecData.get(target, 'dataIndex'); |
| this.component.legend && this.component.legend.del(series[seriesIndex].data[dataIndex].name); |
| series[seriesIndex].data.splice(dataIndex, 1); |
| status.dragOut = true; |
| status.needRefresh = true; |
| this.isDragend = false; |
| return; |
| }, |
| ondrop: function (param, status) { |
| var series = this.series; |
| if (!this.isDrop || !param.target) { |
| return; |
| } |
| var target = param.target; |
| var dragged = param.dragged; |
| var seriesIndex = ecData.get(target, 'seriesIndex'); |
| var dataIndex = ecData.get(target, 'dataIndex'); |
| var data; |
| var legend = this.component.legend; |
| var value; |
| if (dataIndex === -1) { |
| data = { |
| value: ecData.get(dragged, 'value'), |
| name: ecData.get(dragged, 'name') |
| }; |
| series[seriesIndex].data.push(data); |
| legend && legend.add(data.name, dragged.style.color || dragged.style.strokeColor); |
| } else { |
| var accMath = require('../util/accMath'); |
| data = series[seriesIndex].data[dataIndex]; |
| legend && legend.del(data.name); |
| data.name += this.option.nameConnector + ecData.get(dragged, 'name'); |
| value = ecData.get(dragged, 'value'); |
| for (var i = 0; i < value.length; i++) { |
| data.value[i] = accMath.accAdd(data.value[i], value[i]); |
| } |
| legend && legend.add(data.name, dragged.style.color || dragged.style.strokeColor); |
| } |
| status.dragIn = status.dragIn || true; |
| this.isDrop = false; |
| return; |
| }, |
| refresh: function (newOption) { |
| if (newOption) { |
| this.option = newOption; |
| this.series = newOption.series; |
| } |
| this.backupShapeList(); |
| this._buildShape(); |
| } |
| }; |
| zrUtil.inherits(Radar, ChartBase); |
| zrUtil.inherits(Radar, ComponentBase); |
| require('../chart').define('radar', Radar); |
| return Radar; |
| });define('echarts/component/polar', [ |
| 'require', |
| './base', |
| 'zrender/shape/Text', |
| 'zrender/shape/Line', |
| 'zrender/shape/Polygon', |
| 'zrender/shape/Circle', |
| 'zrender/shape/Ring', |
| '../config', |
| 'zrender/tool/util', |
| '../util/coordinates', |
| '../util/accMath', |
| '../util/smartSteps', |
| '../component' |
| ], function (require) { |
| var Base = require('./base'); |
| var TextShape = require('zrender/shape/Text'); |
| var LineShape = require('zrender/shape/Line'); |
| var PolygonShape = require('zrender/shape/Polygon'); |
| var Circle = require('zrender/shape/Circle'); |
| var Ring = require('zrender/shape/Ring'); |
| var ecConfig = require('../config'); |
| var zrUtil = require('zrender/tool/util'); |
| var ecCoordinates = require('../util/coordinates'); |
| function Polar(ecTheme, messageCenter, zr, option, myChart) { |
| Base.call(this, ecTheme, messageCenter, zr, option, myChart); |
| this.refresh(option); |
| } |
| Polar.prototype = { |
| type: ecConfig.COMPONENT_TYPE_POLAR, |
| _buildShape: function () { |
| for (var i = 0; i < this.polar.length; i++) { |
| this._index = i; |
| this.reformOption(this.polar[i]); |
| this._queryTarget = [ |
| this.polar[i], |
| this.option |
| ]; |
| this._createVector(i); |
| this._buildSpiderWeb(i); |
| this._buildText(i); |
| this._adjustIndicatorValue(i); |
| this._addAxisLabel(i); |
| } |
| for (var i = 0; i < this.shapeList.length; i++) { |
| this.zr.addShape(this.shapeList[i]); |
| } |
| }, |
| _createVector: function (index) { |
| var item = this.polar[index]; |
| var indicator = this.deepQuery(this._queryTarget, 'indicator'); |
| var length = indicator.length; |
| var startAngle = item.startAngle; |
| var dStep = 2 * Math.PI / length; |
| var radius = this._getRadius(); |
| var __ecIndicator = item.__ecIndicator = []; |
| var vector; |
| for (var i = 0; i < length; i++) { |
| vector = ecCoordinates.polar2cartesian(radius, startAngle * Math.PI / 180 + dStep * i); |
| __ecIndicator.push({ |
| vector: [ |
| vector[1], |
| -vector[0] |
| ] |
| }); |
| } |
| }, |
| _getRadius: function () { |
| var item = this.polar[this._index]; |
| return this.parsePercent(item.radius, Math.min(this.zr.getWidth(), this.zr.getHeight()) / 2); |
| }, |
| _buildSpiderWeb: function (index) { |
| var item = this.polar[index]; |
| var __ecIndicator = item.__ecIndicator; |
| var splitArea = item.splitArea; |
| var splitLine = item.splitLine; |
| var center = this.getCenter(index); |
| var splitNumber = item.splitNumber; |
| var strokeColor = splitLine.lineStyle.color; |
| var lineWidth = splitLine.lineStyle.width; |
| var show = splitLine.show; |
| var axisLine = this.deepQuery(this._queryTarget, 'axisLine'); |
| this._addArea(__ecIndicator, splitNumber, center, splitArea, strokeColor, lineWidth, show); |
| axisLine.show && this._addLine(__ecIndicator, center, axisLine); |
| }, |
| _addAxisLabel: function (index) { |
| var accMath = require('../util/accMath'); |
| var item = this.polar[index]; |
| var indicator = this.deepQuery(this._queryTarget, 'indicator'); |
| var __ecIndicator = item.__ecIndicator; |
| var axisLabel; |
| var vector; |
| var style; |
| var newStyle; |
| var splitNumber = this.deepQuery(this._queryTarget, 'splitNumber'); |
| var center = this.getCenter(index); |
| var vector; |
| var value; |
| var text; |
| var theta; |
| var offset; |
| var interval; |
| for (var i = 0; i < indicator.length; i++) { |
| axisLabel = this.deepQuery([ |
| indicator[i], |
| item, |
| this.option |
| ], 'axisLabel'); |
| if (axisLabel.show) { |
| style = {}; |
| style.textFont = this.getFont(); |
| style = zrUtil.merge(style, axisLabel); |
| style.lineWidth = style.width; |
| vector = __ecIndicator[i].vector; |
| value = __ecIndicator[i].value; |
| theta = i / indicator.length * 2 * Math.PI; |
| offset = axisLabel.offset || 10; |
| interval = axisLabel.interval || 0; |
| if (!value) { |
| return; |
| } |
| for (var j = 1; j <= splitNumber; j += interval + 1) { |
| newStyle = zrUtil.merge({}, style); |
| text = accMath.accAdd(value.min, accMath.accMul(value.step, j)); |
| newStyle.text = this.numAddCommas(text); |
| newStyle.x = j * vector[0] / splitNumber + Math.cos(theta) * offset + center[0]; |
| newStyle.y = j * vector[1] / splitNumber + Math.sin(theta) * offset + center[1]; |
| this.shapeList.push(new TextShape({ |
| zlevel: this._zlevelBase, |
| style: newStyle, |
| draggable: false, |
| hoverable: false |
| })); |
| } |
| } |
| } |
| }, |
| _buildText: function (index) { |
| var item = this.polar[index]; |
| var __ecIndicator = item.__ecIndicator; |
| var vector; |
| var indicator = this.deepQuery(this._queryTarget, 'indicator'); |
| var center = this.getCenter(index); |
| var style; |
| var textAlign; |
| var name; |
| var rotation; |
| var x = 0; |
| var y = 0; |
| var margin; |
| var textStyle; |
| for (var i = 0; i < indicator.length; i++) { |
| name = this.deepQuery([ |
| indicator[i], |
| item, |
| this.option |
| ], 'name'); |
| if (!name.show) { |
| continue; |
| } |
| textStyle = this.deepQuery([ |
| name, |
| item, |
| this.option |
| ], 'textStyle'); |
| style = {}; |
| style.textFont = this.getFont(textStyle); |
| style.color = textStyle.color; |
| if (typeof name.formatter == 'function') { |
| style.text = name.formatter.call(this.myChart, indicator[i].text, i); |
| } else if (typeof name.formatter == 'string') { |
| style.text = name.formatter.replace('{value}', indicator[i].text); |
| } else { |
| style.text = indicator[i].text; |
| } |
| __ecIndicator[i].text = style.text; |
| vector = __ecIndicator[i].vector; |
| if (Math.round(vector[0]) > 0) { |
| textAlign = 'left'; |
| } else if (Math.round(vector[0]) < 0) { |
| textAlign = 'right'; |
| } else { |
| textAlign = 'center'; |
| } |
| if (!name.margin) { |
| vector = this._mapVector(vector, center, 1.2); |
| } else { |
| margin = name.margin; |
| x = vector[0] > 0 ? margin : -margin; |
| y = vector[1] > 0 ? margin : -margin; |
| x = vector[0] === 0 ? 0 : x; |
| y = vector[1] === 0 ? 0 : y; |
| vector = this._mapVector(vector, center, 1); |
| } |
| style.textAlign = textAlign; |
| style.x = vector[0] + x; |
| style.y = vector[1] + y; |
| if (name.rotate) { |
| rotation = [ |
| name.rotate / 180 * Math.PI, |
| vector[0], |
| vector[1] |
| ]; |
| } else { |
| rotation = [ |
| 0, |
| 0, |
| 0 |
| ]; |
| } |
| this.shapeList.push(new TextShape({ |
| zlevel: this._zlevelBase, |
| style: style, |
| draggable: false, |
| hoverable: false, |
| rotation: rotation |
| })); |
| } |
| }, |
| getIndicatorText: function (polarIndex, indicatorIndex) { |
| return this.polar[polarIndex] && this.polar[polarIndex].__ecIndicator[indicatorIndex] && this.polar[polarIndex].__ecIndicator[indicatorIndex].text; |
| }, |
| getDropBox: function (index) { |
| var index = index || 0; |
| var item = this.polar[index]; |
| var center = this.getCenter(index); |
| var __ecIndicator = item.__ecIndicator; |
| var len = __ecIndicator.length; |
| var pointList = []; |
| var vector; |
| var shape; |
| var type = item.type; |
| if (type == 'polygon') { |
| for (var i = 0; i < len; i++) { |
| vector = __ecIndicator[i].vector; |
| pointList.push(this._mapVector(vector, center, 1.2)); |
| } |
| shape = this._getShape(pointList, 'fill', 'rgba(0,0,0,0)', '', 1); |
| } else if (type == 'circle') { |
| shape = this._getCircle('', 1, 1.2, center, 'fill', 'rgba(0,0,0,0)'); |
| } |
| return shape; |
| }, |
| _addArea: function (__ecIndicator, splitNumber, center, splitArea, strokeColor, lineWidth, show) { |
| var shape; |
| var scale; |
| var scale1; |
| var pointList; |
| var type = this.deepQuery(this._queryTarget, 'type'); |
| for (var i = 0; i < splitNumber; i++) { |
| scale = (splitNumber - i) / splitNumber; |
| if (show) { |
| if (type == 'polygon') { |
| pointList = this._getPointList(__ecIndicator, scale, center); |
| shape = this._getShape(pointList, 'stroke', '', strokeColor, lineWidth); |
| } else if (type == 'circle') { |
| shape = this._getCircle(strokeColor, lineWidth, scale, center, 'stroke'); |
| } |
| this.shapeList.push(shape); |
| } |
| if (splitArea.show) { |
| scale1 = (splitNumber - i - 1) / splitNumber; |
| this._addSplitArea(__ecIndicator, splitArea, scale, scale1, center, i); |
| } |
| } |
| }, |
| _getCircle: function (strokeColor, lineWidth, scale, center, brushType, color) { |
| var radius = this._getRadius(); |
| return new Circle({ |
| zlevel: this._zlevelBase, |
| style: { |
| x: center[0], |
| y: center[1], |
| r: radius * scale, |
| brushType: brushType, |
| strokeColor: strokeColor, |
| lineWidth: lineWidth, |
| color: color |
| }, |
| hoverable: false, |
| draggable: false |
| }); |
| }, |
| _getRing: function (color, scale0, scale1, center) { |
| var radius = this._getRadius(); |
| return new Ring({ |
| zlevel: this._zlevelBase, |
| style: { |
| x: center[0], |
| y: center[1], |
| r: scale0 * radius, |
| r0: scale1 * radius, |
| color: color, |
| brushType: 'fill' |
| }, |
| hoverable: false, |
| draggable: false |
| }); |
| }, |
| _getPointList: function (__ecIndicator, scale, center) { |
| var pointList = []; |
| var len = __ecIndicator.length; |
| var vector; |
| for (var i = 0; i < len; i++) { |
| vector = __ecIndicator[i].vector; |
| pointList.push(this._mapVector(vector, center, scale)); |
| } |
| return pointList; |
| }, |
| _getShape: function (pointList, brushType, color, strokeColor, lineWidth) { |
| return new PolygonShape({ |
| zlevel: this._zlevelBase, |
| style: { |
| pointList: pointList, |
| brushType: brushType, |
| color: color, |
| strokeColor: strokeColor, |
| lineWidth: lineWidth |
| }, |
| hoverable: false, |
| draggable: false |
| }); |
| }, |
| _addSplitArea: function (__ecIndicator, splitArea, scale, scale1, center, colorInd) { |
| var indLen = __ecIndicator.length; |
| var color; |
| var colorArr = splitArea.areaStyle.color; |
| var colorLen; |
| var vector; |
| var vector1; |
| var pointList = []; |
| var indLen = __ecIndicator.length; |
| var shape; |
| var type = this.deepQuery(this._queryTarget, 'type'); |
| if (typeof colorArr == 'string') { |
| colorArr = [colorArr]; |
| } |
| colorLen = colorArr.length; |
| color = colorArr[colorInd % colorLen]; |
| if (type == 'polygon') { |
| for (var i = 0; i < indLen; i++) { |
| pointList = []; |
| vector = __ecIndicator[i].vector; |
| vector1 = __ecIndicator[(i + 1) % indLen].vector; |
| pointList.push(this._mapVector(vector, center, scale)); |
| pointList.push(this._mapVector(vector, center, scale1)); |
| pointList.push(this._mapVector(vector1, center, scale1)); |
| pointList.push(this._mapVector(vector1, center, scale)); |
| shape = this._getShape(pointList, 'fill', color, '', 1); |
| this.shapeList.push(shape); |
| } |
| } else if (type == 'circle') { |
| shape = this._getRing(color, scale, scale1, center); |
| this.shapeList.push(shape); |
| } |
| }, |
| _mapVector: function (vector, center, scale) { |
| return [ |
| vector[0] * scale + center[0], |
| vector[1] * scale + center[1] |
| ]; |
| }, |
| getCenter: function (index) { |
| var index = index || 0; |
| return this.parseCenter(this.zr, this.polar[index].center); |
| }, |
| _addLine: function (__ecIndicator, center, axisLine) { |
| var indLen = __ecIndicator.length; |
| var line; |
| var vector; |
| var lineStyle = axisLine.lineStyle; |
| var strokeColor = lineStyle.color; |
| var lineWidth = lineStyle.width; |
| var lineType = lineStyle.type; |
| for (var i = 0; i < indLen; i++) { |
| vector = __ecIndicator[i].vector; |
| line = this._getLine(center[0], center[1], vector[0] + center[0], vector[1] + center[1], strokeColor, lineWidth, lineType); |
| this.shapeList.push(line); |
| } |
| }, |
| _getLine: function (xStart, yStart, xEnd, yEnd, strokeColor, lineWidth, lineType) { |
| return new LineShape({ |
| zlevel: this._zlevelBase, |
| style: { |
| xStart: xStart, |
| yStart: yStart, |
| xEnd: xEnd, |
| yEnd: yEnd, |
| strokeColor: strokeColor, |
| lineWidth: lineWidth, |
| lineType: lineType |
| }, |
| hoverable: false |
| }); |
| }, |
| _adjustIndicatorValue: function (index) { |
| var item = this.polar[index]; |
| var indicator = this.deepQuery(this._queryTarget, 'indicator'); |
| var len = indicator.length; |
| var __ecIndicator = item.__ecIndicator; |
| var max; |
| var min; |
| var data = this._getSeriesData(index); |
| var boundaryGap = item.boundaryGap; |
| var splitNumber = item.splitNumber; |
| var scale = item.scale; |
| var smartSteps = require('../util/smartSteps'); |
| for (var i = 0; i < len; i++) { |
| if (typeof indicator[i].max == 'number') { |
| max = indicator[i].max; |
| min = indicator[i].min || 0; |
| } else { |
| var value = this._findValue(data, i, splitNumber, boundaryGap); |
| min = value.min; |
| max = value.max; |
| } |
| if (!scale && min >= 0 && max >= 0) { |
| min = 0; |
| } |
| if (!scale && min <= 0 && max <= 0) { |
| max = 0; |
| } |
| var stepOpt = smartSteps(min, max, splitNumber); |
| __ecIndicator[i].value = { |
| min: stepOpt.min, |
| max: stepOpt.max, |
| step: stepOpt.step |
| }; |
| } |
| }, |
| _getSeriesData: function (index) { |
| var data = []; |
| var serie; |
| var serieData; |
| var legend = this.component.legend; |
| var polarIndex; |
| for (var i = 0; i < this.series.length; i++) { |
| serie = this.series[i]; |
| if (serie.type != ecConfig.CHART_TYPE_RADAR) { |
| continue; |
| } |
| serieData = serie.data || []; |
| for (var j = 0; j < serieData.length; j++) { |
| polarIndex = this.deepQuery([ |
| serieData[j], |
| serie, |
| this.option |
| ], 'polarIndex') || 0; |
| if (polarIndex == index && (!legend || legend.isSelected(serieData[j].name))) { |
| data.push(serieData[j]); |
| } |
| } |
| } |
| return data; |
| }, |
| _findValue: function (data, index, splitNumber, boundaryGap) { |
| var max; |
| var min; |
| var value; |
| var one; |
| if (!data || data.length === 0) { |
| return; |
| } |
| function _compare(item) { |
| (item > max || max === undefined) && (max = item); |
| (item < min || min === undefined) && (min = item); |
| } |
| if (data.length == 1) { |
| min = 0; |
| } |
| if (data.length != 1) { |
| for (var i = 0; i < data.length; i++) { |
| value = typeof data[i].value[index].value != 'undefined' ? data[i].value[index].value : data[i].value[index]; |
| _compare(value); |
| } |
| } else { |
| one = data[0]; |
| for (var i = 0; i < one.value.length; i++) { |
| _compare(typeof one.value[i].value != 'undefined' ? one.value[i].value : one.value[i]); |
| } |
| } |
| var gap = Math.abs(max - min); |
| min = min - Math.abs(gap * boundaryGap[0]); |
| max = max + Math.abs(gap * boundaryGap[1]); |
| if (min === max) { |
| if (max === 0) { |
| max = 1; |
| } else if (max > 0) { |
| min = max / splitNumber; |
| } else { |
| max = max / splitNumber; |
| } |
| } |
| return { |
| max: max, |
| min: min |
| }; |
| }, |
| getVector: function (polarIndex, indicatorIndex, value) { |
| polarIndex = polarIndex || 0; |
| indicatorIndex = indicatorIndex || 0; |
| var __ecIndicator = this.polar[polarIndex].__ecIndicator; |
| if (indicatorIndex >= __ecIndicator.length) { |
| return; |
| } |
| var indicator = this.polar[polarIndex].__ecIndicator[indicatorIndex]; |
| var center = this.getCenter(polarIndex); |
| var vector = indicator.vector; |
| var max = indicator.value.max; |
| var min = indicator.value.min; |
| var alpha; |
| if (typeof value == 'undefined') { |
| return center; |
| } |
| switch (value) { |
| case 'min': |
| value = min; |
| break; |
| case 'max': |
| value = max; |
| break; |
| case 'center': |
| value = (max + min) / 2; |
| break; |
| } |
| if (max != min) { |
| alpha = (value - min) / (max - min); |
| } else { |
| alpha = 0.5; |
| } |
| return this._mapVector(vector, center, alpha); |
| }, |
| isInside: function (vector) { |
| var polar = this.getNearestIndex(vector); |
| if (polar) { |
| return polar.polarIndex; |
| } |
| return -1; |
| }, |
| getNearestIndex: function (vector) { |
| var item; |
| var center; |
| var radius; |
| var polarVector; |
| var startAngle; |
| var indicator; |
| var len; |
| var angle; |
| var finalAngle; |
| for (var i = 0; i < this.polar.length; i++) { |
| item = this.polar[i]; |
| center = this.getCenter(i); |
| if (vector[0] == center[0] && vector[1] == center[1]) { |
| return { |
| polarIndex: i, |
| valueIndex: 0 |
| }; |
| } |
| radius = this._getRadius(); |
| startAngle = item.startAngle; |
| indicator = item.indicator; |
| len = indicator.length; |
| angle = 2 * Math.PI / len; |
| polarVector = ecCoordinates.cartesian2polar(vector[0] - center[0], center[1] - vector[1]); |
| if (vector[0] - center[0] < 0) { |
| polarVector[1] += Math.PI; |
| } |
| if (polarVector[1] < 0) { |
| polarVector[1] += 2 * Math.PI; |
| } |
| finalAngle = polarVector[1] - startAngle / 180 * Math.PI + Math.PI * 2; |
| if (Math.abs(Math.cos(finalAngle % (angle / 2))) * radius > polarVector[0]) { |
| return { |
| polarIndex: i, |
| valueIndex: Math.floor((finalAngle + angle / 2) / angle) % len |
| }; |
| } |
| } |
| }, |
| getIndicator: function (index) { |
| var index = index || 0; |
| return this.polar[index].indicator; |
| }, |
| refresh: function (newOption) { |
| if (newOption) { |
| this.option = newOption; |
| this.polar = this.option.polar; |
| this.series = this.option.series; |
| } |
| this.clear(); |
| this._buildShape(); |
| } |
| }; |
| zrUtil.inherits(Polar, Base); |
| require('../component').define('polar', Polar); |
| return Polar; |
| });define('echarts/util/coordinates', [ |
| 'require', |
| 'zrender/tool/math' |
| ], function (require) { |
| var zrMath = require('zrender/tool/math'); |
| function polar2cartesian(r, theta) { |
| return [ |
| r * zrMath.sin(theta), |
| r * zrMath.cos(theta) |
| ]; |
| } |
| function cartesian2polar(x, y) { |
| return [ |
| Math.sqrt(x * x + y * y), |
| Math.atan(y / x) |
| ]; |
| } |
| return { |
| polar2cartesian: polar2cartesian, |
| cartesian2polar: cartesian2polar |
| }; |
| });define('echarts/chart/chord', [ |
| 'require', |
| '../component/base', |
| './base', |
| 'zrender/shape/Text', |
| 'zrender/shape/Line', |
| 'zrender/shape/Sector', |
| '../util/shape/Ribbon', |
| '../util/shape/Icon', |
| 'zrender/shape/BezierCurve', |
| '../config', |
| '../util/ecData', |
| 'zrender/tool/util', |
| 'zrender/tool/vector', |
| '../data/Graph', |
| '../layout/Chord', |
| '../chart' |
| ], function (require) { |
| 'use strict'; |
| var ComponentBase = require('../component/base'); |
| var ChartBase = require('./base'); |
| var TextShape = require('zrender/shape/Text'); |
| var LineShape = require('zrender/shape/Line'); |
| var SectorShape = require('zrender/shape/Sector'); |
| var RibbonShape = require('../util/shape/Ribbon'); |
| var IconShape = require('../util/shape/Icon'); |
| var BezierCurveShape = require('zrender/shape/BezierCurve'); |
| var ecConfig = require('../config'); |
| var ecData = require('../util/ecData'); |
| var zrUtil = require('zrender/tool/util'); |
| var vec2 = require('zrender/tool/vector'); |
| var Graph = require('../data/Graph'); |
| var ChordLayout = require('../layout/Chord'); |
| function Chord(ecTheme, messageCenter, zr, option, myChart) { |
| ComponentBase.call(this, ecTheme, messageCenter, zr, option, myChart); |
| ChartBase.call(this); |
| this.scaleLineLength = 4; |
| this.scaleUnitAngle = 4; |
| this.refresh(option); |
| } |
| Chord.prototype = { |
| type: ecConfig.CHART_TYPE_CHORD, |
| _init: function () { |
| var series = this.series; |
| this.selectedMap = {}; |
| var chordSeriesMap = {}; |
| var chordSeriesGroups = {}; |
| for (var i = 0, l = series.length; i < l; i++) { |
| if (series[i].type === this.type) { |
| var _isSelected = this.isSelected(series[i].name); |
| this.selectedMap[series[i].name] = _isSelected; |
| if (_isSelected) { |
| this.buildMark(i); |
| } |
| this.reformOption(series[i]); |
| chordSeriesMap[series[i].name] = series[i]; |
| } |
| } |
| for (var i = 0, l = series.length; i < l; i++) { |
| if (series[i].type === this.type) { |
| if (series[i].insertToSerie) { |
| var referenceSerie = chordSeriesMap[series[i].insertToSerie]; |
| series[i]._referenceSerie = referenceSerie; |
| } else { |
| chordSeriesGroups[series[i].name] = [series[i]]; |
| } |
| } |
| } |
| for (var i = 0, l = series.length; i < l; i++) { |
| if (series[i].type === this.type) { |
| if (series[i].insertToSerie) { |
| var mainSerie = series[i]._referenceSerie; |
| while (mainSerie && mainSerie._referenceSerie) { |
| mainSerie = mainSerie._referenceSerie; |
| } |
| if (chordSeriesGroups[mainSerie.name] && this.selectedMap[series[i].name]) { |
| chordSeriesGroups[mainSerie.name].push(series[i]); |
| } |
| } |
| } |
| } |
| for (var name in chordSeriesGroups) { |
| this._buildChords(chordSeriesGroups[name]); |
| } |
| this.addShapeList(); |
| }, |
| _getNodeCategory: function (serie, group) { |
| return serie.categories && serie.categories[group.category || 0]; |
| }, |
| _getNodeQueryTarget: function (serie, group) { |
| var category = this._getNodeCategory(serie, group); |
| return [ |
| group, |
| category, |
| serie |
| ]; |
| }, |
| _getEdgeQueryTarget: function (serie, edge, type) { |
| type = type || 'normal'; |
| return [ |
| edge.itemStyle && edge.itemStyle[type], |
| serie.itemStyle[type].chordStyle |
| ]; |
| }, |
| _buildChords: function (series) { |
| var graphs = []; |
| var mainSerie = series[0]; |
| var nodeFilter = function (n) { |
| return n.layout.size > 0; |
| }; |
| for (var i = 0; i < series.length; i++) { |
| var serie = series[i]; |
| if (this.selectedMap[serie.name]) { |
| var graph; |
| if (serie.data && serie.matrix) { |
| graph = this._getSerieGraphFromDataMatrix(serie, mainSerie); |
| } else if (serie.nodes && serie.links) { |
| graph = this._getSerieGraphFromNodeLinks(serie, mainSerie); |
| } |
| graph.filterNode(nodeFilter, this); |
| graphs.push(graph); |
| graph.__serie = serie; |
| } |
| } |
| if (!graphs.length) { |
| return; |
| } |
| var mainGraph = graphs[0]; |
| if (!mainSerie.ribbonType) { |
| var minRadius = mainSerie.minRadius; |
| var maxRadius = mainSerie.maxRadius; |
| var min = Infinity, max = -Infinity; |
| mainGraph.eachNode(function (node) { |
| max = Math.max(node.layout.size, max); |
| min = Math.min(node.layout.size, min); |
| }); |
| var multiplier = (maxRadius - minRadius) / (max - min); |
| mainGraph.eachNode(function (node) { |
| var queryTarget = this._getNodeQueryTarget(mainSerie, node); |
| var symbolSize = this.query(queryTarget, 'symbolSize'); |
| if (max === min) { |
| node.layout.size = symbolSize || min; |
| } else { |
| node.layout.size = symbolSize || (node.layout.size - min) * multiplier + minRadius; |
| } |
| }, this); |
| } |
| var layout = new ChordLayout(); |
| layout.clockWise = mainSerie.clockWise; |
| layout.startAngle = mainSerie.startAngle * Math.PI / 180; |
| if (!layout.clockWise) { |
| layout.startAngle = -layout.startAngle; |
| } |
| layout.padding = mainSerie.padding * Math.PI / 180; |
| layout.sort = mainSerie.sort; |
| layout.sortSub = mainSerie.sortSub; |
| layout.directed = mainSerie.ribbonType; |
| layout.run(graphs); |
| var showLabel = this.query(mainSerie, 'itemStyle.normal.label.show'); |
| if (mainSerie.ribbonType) { |
| this._buildSectors(mainSerie, 0, mainGraph, mainSerie, graphs); |
| if (showLabel) { |
| this._buildLabels(mainSerie, 0, mainGraph, mainSerie, graphs); |
| } |
| for (var i = 0, j = 0; i < series.length; i++) { |
| if (this.selectedMap[series[i].name]) { |
| this._buildRibbons(series, i, graphs[j++], mainSerie); |
| } |
| } |
| if (mainSerie.showScale) { |
| this._buildScales(mainSerie, 0, mainGraph); |
| } |
| } else { |
| this._buildNodeIcons(mainSerie, 0, mainGraph, mainSerie, graphs); |
| if (showLabel) { |
| this._buildLabels(mainSerie, 0, mainGraph, mainSerie, graphs); |
| } |
| for (var i = 0, j = 0; i < series.length; i++) { |
| if (this.selectedMap[series[i].name]) { |
| this._buildEdgeCurves(series, i, graphs[j++], mainSerie, mainGraph); |
| } |
| } |
| } |
| this._initHoverHandler(series, graphs); |
| }, |
| _getSerieGraphFromDataMatrix: function (serie, mainSerie) { |
| var nodesData = []; |
| var count = 0; |
| var matrix = []; |
| for (var i = 0; i < serie.matrix.length; i++) { |
| matrix[i] = serie.matrix[i].slice(); |
| } |
| var data = serie.data || serie.nodes; |
| for (var i = 0; i < data.length; i++) { |
| var node = {}; |
| var group = data[i]; |
| group.rawIndex = i; |
| for (var key in group) { |
| if (key === 'name') { |
| node['id'] = group['name']; |
| } else { |
| node[key] = group[key]; |
| } |
| } |
| var category = this._getNodeCategory(mainSerie, group); |
| var name = category ? category.name : group.name; |
| this.selectedMap[name] = this.isSelected(name); |
| if (this.selectedMap[name]) { |
| nodesData.push(node); |
| count++; |
| } else { |
| matrix.splice(count, 1); |
| for (var j = 0; j < matrix.length; j++) { |
| matrix[j].splice(count, 1); |
| } |
| } |
| } |
| var graph = Graph.fromMatrix(nodesData, matrix, true); |
| graph.eachNode(function (n, idx) { |
| n.layout = { size: n.data.outValue }; |
| n.rawIndex = n.data.rawIndex; |
| }); |
| graph.eachEdge(function (e) { |
| e.layout = { weight: e.data.weight }; |
| }); |
| return graph; |
| }, |
| _getSerieGraphFromNodeLinks: function (serie, mainSerie) { |
| var graph = new Graph(true); |
| var nodes = serie.data || serie.nodes; |
| for (var i = 0, len = nodes.length; i < len; i++) { |
| var n = nodes[i]; |
| if (!n || n.ignore) { |
| continue; |
| } |
| var category = this._getNodeCategory(mainSerie, n); |
| var name = category ? category.name : n.name; |
| this.selectedMap[name] = this.isSelected(name); |
| if (this.selectedMap[name]) { |
| var node = graph.addNode(n.name, n); |
| node.rawIndex = i; |
| } |
| } |
| for (var i = 0, len = serie.links.length; i < len; i++) { |
| var e = serie.links[i]; |
| var n1 = e.source; |
| var n2 = e.target; |
| if (typeof n1 === 'number') { |
| n1 = nodes[n1]; |
| if (n1) { |
| n1 = n1.name; |
| } |
| } |
| if (typeof n2 === 'number') { |
| n2 = nodes[n2]; |
| if (n2) { |
| n2 = n2.name; |
| } |
| } |
| var edge = graph.addEdge(n1, n2, e); |
| if (edge) { |
| edge.rawIndex = i; |
| } |
| } |
| graph.eachNode(function (n) { |
| var value = n.data.value; |
| if (value == null) { |
| value = 0; |
| if (mainSerie.ribbonType) { |
| for (var i = 0; i < n.outEdges.length; i++) { |
| value += n.outEdges[i].data.weight || 0; |
| } |
| } else { |
| for (var i = 0; i < n.edges.length; i++) { |
| value += n.edges[i].data.weight || 0; |
| } |
| } |
| } |
| n.layout = { size: value }; |
| }); |
| graph.eachEdge(function (e) { |
| e.layout = { weight: e.data.weight == null ? 1 : e.data.weight }; |
| }); |
| return graph; |
| }, |
| _initHoverHandler: function (series, graphs) { |
| var mainSerie = series[0]; |
| var mainGraph = graphs[0]; |
| var self = this; |
| mainGraph.eachNode(function (node) { |
| node.shape.onmouseover = function () { |
| mainGraph.eachNode(function (n) { |
| n.shape.style.opacity = 0.1; |
| if (n.labelShape) { |
| n.labelShape.style.opacity = 0.1; |
| n.labelShape.modSelf(); |
| } |
| n.shape.modSelf(); |
| }); |
| for (var i = 0; i < graphs.length; i++) { |
| for (var j = 0; j < graphs[i].edges.length; j++) { |
| var e = graphs[i].edges[j]; |
| var queryTarget = self._getEdgeQueryTarget(graphs[i].__serie, e.data); |
| e.shape.style.opacity = self.deepQuery(queryTarget, 'opacity') * 0.1; |
| e.shape.modSelf(); |
| } |
| } |
| node.shape.style.opacity = 1; |
| if (node.labelShape) { |
| node.labelShape.style.opacity = 1; |
| } |
| for (var i = 0; i < graphs.length; i++) { |
| var n = graphs[i].getNodeById(node.id); |
| if (n) { |
| for (var j = 0; j < n.outEdges.length; j++) { |
| var e = n.outEdges[j]; |
| var queryTarget = self._getEdgeQueryTarget(graphs[i].__serie, e.data); |
| e.shape.style.opacity = self.deepQuery(queryTarget, 'opacity'); |
| var other = graphs[0].getNodeById(e.node2.id); |
| if (other) { |
| if (other.shape) { |
| other.shape.style.opacity = 1; |
| } |
| if (other.labelShape) { |
| other.labelShape.style.opacity = 1; |
| } |
| } |
| } |
| } |
| } |
| self.zr.refreshNextFrame(); |
| }; |
| node.shape.onmouseout = function () { |
| mainGraph.eachNode(function (n) { |
| n.shape.style.opacity = 1; |
| if (n.labelShape) { |
| n.labelShape.style.opacity = 1; |
| n.labelShape.modSelf(); |
| } |
| n.shape.modSelf(); |
| }); |
| for (var i = 0; i < graphs.length; i++) { |
| for (var j = 0; j < graphs[i].edges.length; j++) { |
| var e = graphs[i].edges[j]; |
| var queryTarget = [ |
| e.data, |
| mainSerie |
| ]; |
| e.shape.style.opacity = self.deepQuery(queryTarget, 'itemStyle.normal.chordStyle.opacity'); |
| e.shape.modSelf(); |
| } |
| } |
| self.zr.refreshNextFrame(); |
| }; |
| }); |
| }, |
| _buildSectors: function (serie, serieIdx, graph, mainSerie) { |
| var center = this.parseCenter(this.zr, mainSerie.center); |
| var radius = this.parseRadius(this.zr, mainSerie.radius); |
| var clockWise = mainSerie.clockWise; |
| var sign = clockWise ? 1 : -1; |
| graph.eachNode(function (node) { |
| var category = this._getNodeCategory(mainSerie, node.data); |
| var color = category ? this.getColor(category.name) : this.getColor(node.id); |
| var startAngle = node.layout.startAngle / Math.PI * 180 * sign; |
| var endAngle = node.layout.endAngle / Math.PI * 180 * sign; |
| var sector = new SectorShape({ |
| zlevel: this.getZlevelBase(), |
| style: { |
| x: center[0], |
| y: center[1], |
| r0: radius[0], |
| r: radius[1], |
| startAngle: startAngle, |
| endAngle: endAngle, |
| brushType: 'fill', |
| opacity: 1, |
| color: color, |
| clockWise: clockWise |
| }, |
| clickable: mainSerie.clickable, |
| highlightStyle: { brushType: 'fill' } |
| }); |
| sector.style.lineWidth = this.deepQuery([ |
| node.data, |
| mainSerie |
| ], 'itemStyle.normal.borderWidth'); |
| sector.highlightStyle.lineWidth = this.deepQuery([ |
| node.data, |
| mainSerie |
| ], 'itemStyle.emphasis.borderWidth'); |
| sector.style.strokeColor = this.deepQuery([ |
| node.data, |
| mainSerie |
| ], 'itemStyle.normal.borderColor'); |
| sector.highlightStyle.strokeColor = this.deepQuery([ |
| node.data, |
| mainSerie |
| ], 'itemStyle.emphasis.borderColor'); |
| if (sector.style.lineWidth > 0) { |
| sector.style.brushType = 'both'; |
| } |
| if (sector.highlightStyle.lineWidth > 0) { |
| sector.highlightStyle.brushType = 'both'; |
| } |
| ecData.pack(sector, serie, serieIdx, node.data, node.rawIndex, node.id, node.category); |
| this.shapeList.push(sector); |
| node.shape = sector; |
| }, this); |
| }, |
| _buildNodeIcons: function (serie, serieIdx, graph, mainSerie) { |
| var center = this.parseCenter(this.zr, mainSerie.center); |
| var radius = this.parseRadius(this.zr, mainSerie.radius); |
| var r = radius[1]; |
| graph.eachNode(function (node) { |
| var startAngle = node.layout.startAngle; |
| var endAngle = node.layout.endAngle; |
| var angle = (startAngle + endAngle) / 2; |
| var x = r * Math.cos(angle); |
| var y = r * Math.sin(angle); |
| var queryTarget = this._getNodeQueryTarget(mainSerie, node.data); |
| var category = this._getNodeCategory(mainSerie, node.data); |
| var color = this.deepQuery(queryTarget, 'itemStyle.normal.color'); |
| if (!color) { |
| color = category ? this.getColor(category.name) : this.getColor(node.id); |
| } |
| var iconShape = new IconShape({ |
| zlevel: this.getZlevelBase(), |
| z: 1, |
| style: { |
| x: -node.layout.size, |
| y: -node.layout.size, |
| width: node.layout.size * 2, |
| height: node.layout.size * 2, |
| iconType: this.deepQuery(queryTarget, 'symbol'), |
| color: color, |
| brushType: 'both', |
| lineWidth: this.deepQuery(queryTarget, 'itemStyle.normal.borderWidth'), |
| strokeColor: this.deepQuery(queryTarget, 'itemStyle.normal.borderColor') |
| }, |
| highlightStyle: { |
| color: this.deepQuery(queryTarget, 'itemStyle.emphasis.color'), |
| lineWidth: this.deepQuery(queryTarget, 'itemStyle.emphasis.borderWidth'), |
| strokeColor: this.deepQuery(queryTarget, 'itemStyle.emphasis.borderColor') |
| }, |
| clickable: mainSerie.clickable, |
| position: [ |
| x + center[0], |
| y + center[1] |
| ] |
| }); |
| ecData.pack(iconShape, serie, serieIdx, node.data, node.rawIndex, node.id, node.category); |
| this.shapeList.push(iconShape); |
| node.shape = iconShape; |
| }, this); |
| }, |
| _buildLabels: function (serie, serieIdx, graph, mainSerie) { |
| var labelColor = this.query(mainSerie, 'itemStyle.normal.label.color'); |
| var rotateLabel = this.query(mainSerie, 'itemStyle.normal.label.rotate'); |
| var labelDistance = this.query(mainSerie, 'itemStyle.normal.label.distance'); |
| var center = this.parseCenter(this.zr, mainSerie.center); |
| var radius = this.parseRadius(this.zr, mainSerie.radius); |
| var clockWise = mainSerie.clockWise; |
| var sign = clockWise ? 1 : -1; |
| graph.eachNode(function (node) { |
| var startAngle = node.layout.startAngle / Math.PI * 180 * sign; |
| var endAngle = node.layout.endAngle / Math.PI * 180 * sign; |
| var angle = (startAngle * -sign + endAngle * -sign) / 2; |
| angle %= 360; |
| if (angle < 0) { |
| angle += 360; |
| } |
| var isRightSide = angle <= 90 || angle >= 270; |
| angle = angle * Math.PI / 180; |
| var v = [ |
| Math.cos(angle), |
| -Math.sin(angle) |
| ]; |
| var distance = 0; |
| if (mainSerie.ribbonType) { |
| distance = mainSerie.showScaleText ? 35 + labelDistance : labelDistance; |
| } else { |
| distance = labelDistance + node.layout.size; |
| } |
| var start = vec2.scale([], v, radius[1] + distance); |
| vec2.add(start, start, center); |
| var labelShape = { |
| zlevel: this.getZlevelBase() + 1, |
| hoverable: false, |
| style: { |
| text: node.data.label == null ? node.id : node.data.label, |
| textAlign: isRightSide ? 'left' : 'right', |
| color: labelColor || '#000000' |
| } |
| }; |
| if (rotateLabel) { |
| labelShape.rotation = isRightSide ? angle : Math.PI + angle; |
| if (isRightSide) { |
| labelShape.style.x = radius[1] + distance; |
| } else { |
| labelShape.style.x = -radius[1] - distance; |
| } |
| labelShape.style.y = 0; |
| labelShape.position = center.slice(); |
| } else { |
| labelShape.style.x = start[0]; |
| labelShape.style.y = start[1]; |
| } |
| labelShape.style.textColor = this.deepQuery([ |
| node.data, |
| mainSerie |
| ], 'itemStyle.normal.label.textStyle.color') || '#fff'; |
| labelShape.style.textFont = this.getFont(this.deepQuery([ |
| node.data, |
| mainSerie |
| ], 'itemStyle.normal.label.textStyle')); |
| labelShape = new TextShape(labelShape); |
| this.shapeList.push(labelShape); |
| node.labelShape = labelShape; |
| }, this); |
| }, |
| _buildRibbons: function (series, serieIdx, graph, mainSerie) { |
| var serie = series[serieIdx]; |
| var center = this.parseCenter(this.zr, mainSerie.center); |
| var radius = this.parseRadius(this.zr, mainSerie.radius); |
| graph.eachEdge(function (edge, idx) { |
| var color; |
| var other = graph.getEdge(edge.node2, edge.node1); |
| if (!other || edge.shape) { |
| return; |
| } |
| if (other.shape) { |
| edge.shape = other.shape; |
| return; |
| } |
| var s0 = edge.layout.startAngle / Math.PI * 180; |
| var s1 = edge.layout.endAngle / Math.PI * 180; |
| var t0 = other.layout.startAngle / Math.PI * 180; |
| var t1 = other.layout.endAngle / Math.PI * 180; |
| if (series.length === 1) { |
| if (edge.layout.weight <= other.layout.weight) { |
| color = this.getColor(edge.node1.id); |
| } else { |
| color = this.getColor(edge.node2.id); |
| } |
| } else { |
| color = this.getColor(serie.name); |
| } |
| var queryTarget = this._getEdgeQueryTarget(serie, edge.data); |
| var queryTargetEmphasis = this._getEdgeQueryTarget(serie, edge.data, 'emphasis'); |
| var ribbon = new RibbonShape({ |
| zlevel: this.getZlevelBase(), |
| style: { |
| x: center[0], |
| y: center[1], |
| r: radius[0], |
| source0: s0, |
| source1: s1, |
| target0: t0, |
| target1: t1, |
| brushType: 'both', |
| opacity: this.deepQuery(queryTarget, 'opacity'), |
| color: color, |
| lineWidth: this.deepQuery(queryTarget, 'borderWidth'), |
| strokeColor: this.deepQuery(queryTarget, 'borderColor'), |
| clockWise: mainSerie.clockWise |
| }, |
| clickable: mainSerie.clickable, |
| highlightStyle: { |
| brushType: 'both', |
| opacity: this.deepQuery(queryTargetEmphasis, 'opacity'), |
| lineWidth: this.deepQuery(queryTargetEmphasis, 'borderWidth'), |
| strokeColor: this.deepQuery(queryTargetEmphasis, 'borderColor') |
| } |
| }); |
| ecData.pack(ribbon, serie, serieIdx, edge.data, edge.rawIndex == null ? idx : edge.rawIndex, edge.data.name || edge.node1.id + '-' + edge.node2.id, edge.node1.id, edge.node2.id); |
| this.shapeList.push(ribbon); |
| edge.shape = ribbon; |
| }, this); |
| }, |
| _buildEdgeCurves: function (series, serieIdx, graph, mainSerie, mainGraph) { |
| var serie = series[serieIdx]; |
| var center = this.parseCenter(this.zr, mainSerie.center); |
| graph.eachEdge(function (e, idx) { |
| var node1 = mainGraph.getNodeById(e.node1.id); |
| var node2 = mainGraph.getNodeById(e.node2.id); |
| var shape1 = node1.shape; |
| var shape2 = node2.shape; |
| var queryTarget = this._getEdgeQueryTarget(serie, e.data); |
| var queryTargetEmphasis = this._getEdgeQueryTarget(serie, e.data, 'emphasis'); |
| var curveShape = new BezierCurveShape({ |
| zlevel: this.getZlevelBase(), |
| z: 0, |
| style: { |
| xStart: shape1.position[0], |
| yStart: shape1.position[1], |
| xEnd: shape2.position[0], |
| yEnd: shape2.position[1], |
| cpX1: center[0], |
| cpY1: center[1], |
| lineWidth: this.deepQuery(queryTarget, 'width'), |
| strokeColor: this.deepQuery(queryTarget, 'color'), |
| opacity: this.deepQuery(queryTarget, 'opacity') |
| }, |
| highlightStyle: { |
| lineWidth: this.deepQuery(queryTargetEmphasis, 'width'), |
| strokeColor: this.deepQuery(queryTargetEmphasis, 'color'), |
| opacity: this.deepQuery(queryTargetEmphasis, 'opacity') |
| } |
| }); |
| ecData.pack(curveShape, serie, serieIdx, e.data, e.rawIndex == null ? idx : e.rawIndex, e.data.name || e.node1.id + '-' + e.node2.id, e.node1.id, e.node2.id); |
| this.shapeList.push(curveShape); |
| e.shape = curveShape; |
| }, this); |
| }, |
| _buildScales: function (serie, serieIdx, graph) { |
| var clockWise = serie.clockWise; |
| var center = this.parseCenter(this.zr, serie.center); |
| var radius = this.parseRadius(this.zr, serie.radius); |
| var sign = clockWise ? 1 : -1; |
| var sumValue = 0; |
| var maxValue = -Infinity; |
| var unitPostfix; |
| var unitScale; |
| if (serie.showScaleText) { |
| graph.eachNode(function (node) { |
| var val = node.data.value; |
| if (val > maxValue) { |
| maxValue = val; |
| } |
| sumValue += val; |
| }); |
| if (maxValue > 10000000000) { |
| unitPostfix = 'b'; |
| unitScale = 1e-9; |
| } else if (maxValue > 10000000) { |
| unitPostfix = 'm'; |
| unitScale = 0.000001; |
| } else if (maxValue > 10000) { |
| unitPostfix = 'k'; |
| unitScale = 0.001; |
| } else { |
| unitPostfix = ''; |
| unitScale = 1; |
| } |
| } |
| var unitValue = sumValue / (360 - serie.padding); |
| graph.eachNode(function (node) { |
| var startAngle = node.layout.startAngle / Math.PI * 180; |
| var endAngle = node.layout.endAngle / Math.PI * 180; |
| var scaleAngle = startAngle; |
| while (true) { |
| if (clockWise && scaleAngle > endAngle || !clockWise && scaleAngle < endAngle) { |
| break; |
| } |
| var theta = scaleAngle / 180 * Math.PI; |
| var v = [ |
| Math.cos(theta), |
| Math.sin(theta) |
| ]; |
| var start = vec2.scale([], v, radius[1] + 1); |
| vec2.add(start, start, center); |
| var end = vec2.scale([], v, radius[1] + this.scaleLineLength); |
| vec2.add(end, end, center); |
| var scaleShape = new LineShape({ |
| zlevel: this.getZlevelBase() - 1, |
| hoverable: false, |
| style: { |
| xStart: start[0], |
| yStart: start[1], |
| xEnd: end[0], |
| yEnd: end[1], |
| lineCap: 'round', |
| brushType: 'stroke', |
| strokeColor: '#666', |
| lineWidth: 1 |
| } |
| }); |
| this.shapeList.push(scaleShape); |
| scaleAngle += sign * this.scaleUnitAngle; |
| } |
| if (!serie.showScaleText) { |
| return; |
| } |
| var scaleTextAngle = startAngle; |
| var step = unitValue * 5 * this.scaleUnitAngle; |
| var scaleValue = 0; |
| while (true) { |
| if (clockWise && scaleTextAngle > endAngle || !clockWise && scaleTextAngle < endAngle) { |
| break; |
| } |
| var theta = scaleTextAngle; |
| theta = theta % 360; |
| if (theta < 0) { |
| theta += 360; |
| } |
| var isRightSide = theta <= 90 || theta >= 270; |
| var textShape = new TextShape({ |
| zlevel: this.getZlevelBase() - 1, |
| hoverable: false, |
| style: { |
| x: isRightSide ? radius[1] + this.scaleLineLength + 4 : -radius[1] - this.scaleLineLength - 4, |
| y: 0, |
| text: Math.round(scaleValue * 10) / 10 + unitPostfix, |
| textAlign: isRightSide ? 'left' : 'right' |
| }, |
| position: center.slice(), |
| rotation: isRightSide ? [ |
| -theta / 180 * Math.PI, |
| 0, |
| 0 |
| ] : [ |
| -(theta + 180) / 180 * Math.PI, |
| 0, |
| 0 |
| ] |
| }); |
| this.shapeList.push(textShape); |
| scaleValue += step * unitScale; |
| scaleTextAngle += sign * this.scaleUnitAngle * 5; |
| } |
| }, this); |
| }, |
| refresh: function (newOption) { |
| if (newOption) { |
| this.option = newOption; |
| this.series = newOption.series; |
| } |
| this.legend = this.component.legend; |
| if (this.legend) { |
| this.getColor = function (param) { |
| return this.legend.getColor(param); |
| }; |
| this.isSelected = function (param) { |
| return this.legend.isSelected(param); |
| }; |
| } else { |
| var colorMap = {}; |
| var count = 0; |
| this.getColor = function (key) { |
| if (colorMap[key]) { |
| return colorMap[key]; |
| } |
| if (!colorMap[key]) { |
| colorMap[key] = this.zr.getColor(count++); |
| } |
| return colorMap[key]; |
| }; |
| this.isSelected = function () { |
| return true; |
| }; |
| } |
| this.backupShapeList(); |
| this._init(); |
| }, |
| reformOption: function (opt) { |
| var _merge = zrUtil.merge; |
| opt = _merge(opt || {}, this.ecTheme.chord); |
| opt.itemStyle.normal.label.textStyle = _merge(opt.itemStyle.normal.label.textStyle || {}, this.ecTheme.textStyle); |
| } |
| }; |
| zrUtil.inherits(Chord, ChartBase); |
| zrUtil.inherits(Chord, ComponentBase); |
| require('../chart').define('chord', Chord); |
| return Chord; |
| });define('echarts/util/shape/Ribbon', [ |
| 'require', |
| 'zrender/shape/Base', |
| 'zrender/shape/util/PathProxy', |
| 'zrender/tool/util', |
| 'zrender/tool/area' |
| ], function (require) { |
| var Base = require('zrender/shape/Base'); |
| var PathProxy = require('zrender/shape/util/PathProxy'); |
| var zrUtil = require('zrender/tool/util'); |
| var area = require('zrender/tool/area'); |
| function RibbonShape(options) { |
| Base.call(this, options); |
| this._pathProxy = new PathProxy(); |
| } |
| RibbonShape.prototype = { |
| type: 'ribbon', |
| buildPath: function (ctx, style) { |
| var clockWise = style.clockWise || false; |
| var path = this._pathProxy; |
| path.begin(ctx); |
| var cx = style.x; |
| var cy = style.y; |
| var r = style.r; |
| var s0 = style.source0 / 180 * Math.PI; |
| var s1 = style.source1 / 180 * Math.PI; |
| var t0 = style.target0 / 180 * Math.PI; |
| var t1 = style.target1 / 180 * Math.PI; |
| var sx0 = cx + Math.cos(s0) * r; |
| var sy0 = cy + Math.sin(s0) * r; |
| var sx1 = cx + Math.cos(s1) * r; |
| var sy1 = cy + Math.sin(s1) * r; |
| var tx0 = cx + Math.cos(t0) * r; |
| var ty0 = cy + Math.sin(t0) * r; |
| var tx1 = cx + Math.cos(t1) * r; |
| var ty1 = cy + Math.sin(t1) * r; |
| path.moveTo(sx0, sy0); |
| path.arc(cx, cy, style.r, s0, s1, !clockWise); |
| path.bezierCurveTo((cx - sx1) * 0.7 + sx1, (cy - sy1) * 0.7 + sy1, (cx - tx0) * 0.7 + tx0, (cy - ty0) * 0.7 + ty0, tx0, ty0); |
| if (style.source0 === style.target0 && style.source1 === style.target1) { |
| return; |
| } |
| path.arc(cx, cy, style.r, t0, t1, !clockWise); |
| path.bezierCurveTo((cx - tx1) * 0.7 + tx1, (cy - ty1) * 0.7 + ty1, (cx - sx0) * 0.7 + sx0, (cy - sy0) * 0.7 + sy0, sx0, sy0); |
| }, |
| getRect: function (style) { |
| if (style.__rect) { |
| return style.__rect; |
| } |
| if (!this._pathProxy.isEmpty()) { |
| this.buildPath(null, style); |
| } |
| return this._pathProxy.fastBoundingRect(); |
| }, |
| isCover: function (x, y) { |
| var rect = this.getRect(this.style); |
| if (x >= rect.x && x <= rect.x + rect.width && y >= rect.y && y <= rect.y + rect.height) { |
| return area.isInsidePath(this._pathProxy.pathCommands, 0, 'fill', x, y); |
| } |
| } |
| }; |
| zrUtil.inherits(RibbonShape, Base); |
| return RibbonShape; |
| });define('zrender/shape/BezierCurve', [ |
| 'require', |
| './Base', |
| '../tool/util' |
| ], function (require) { |
| 'use strict'; |
| var Base = require('./Base'); |
| var BezierCurve = function (options) { |
| this.brushTypeOnly = 'stroke'; |
| this.textPosition = 'end'; |
| Base.call(this, options); |
| }; |
| BezierCurve.prototype = { |
| type: 'bezier-curve', |
| buildPath: function (ctx, style) { |
| ctx.moveTo(style.xStart, style.yStart); |
| if (typeof style.cpX2 != 'undefined' && typeof style.cpY2 != 'undefined') { |
| ctx.bezierCurveTo(style.cpX1, style.cpY1, style.cpX2, style.cpY2, style.xEnd, style.yEnd); |
| } else { |
| ctx.quadraticCurveTo(style.cpX1, style.cpY1, style.xEnd, style.yEnd); |
| } |
| }, |
| getRect: function (style) { |
| if (style.__rect) { |
| return style.__rect; |
| } |
| var _minX = Math.min(style.xStart, style.xEnd, style.cpX1); |
| var _minY = Math.min(style.yStart, style.yEnd, style.cpY1); |
| var _maxX = Math.max(style.xStart, style.xEnd, style.cpX1); |
| var _maxY = Math.max(style.yStart, style.yEnd, style.cpY1); |
| var _x2 = style.cpX2; |
| var _y2 = style.cpY2; |
| if (typeof _x2 != 'undefined' && typeof _y2 != 'undefined') { |
| _minX = Math.min(_minX, _x2); |
| _minY = Math.min(_minY, _y2); |
| _maxX = Math.max(_maxX, _x2); |
| _maxY = Math.max(_maxY, _y2); |
| } |
| var lineWidth = style.lineWidth || 1; |
| style.__rect = { |
| x: _minX - lineWidth, |
| y: _minY - lineWidth, |
| width: _maxX - _minX + lineWidth, |
| height: _maxY - _minY + lineWidth |
| }; |
| return style.__rect; |
| } |
| }; |
| require('../tool/util').inherits(BezierCurve, Base); |
| return BezierCurve; |
| });define('echarts/data/Graph', [ |
| 'require', |
| 'zrender/tool/util' |
| ], function (require) { |
| var util = require('zrender/tool/util'); |
| 'use strict'; |
| var Graph = function (directed) { |
| this._directed = directed || false; |
| this.nodes = []; |
| this.edges = []; |
| this._nodesMap = {}; |
| this._edgesMap = {}; |
| }; |
| Graph.prototype.isDirected = function () { |
| return this._directed; |
| }; |
| Graph.prototype.addNode = function (id, data) { |
| if (this._nodesMap[id]) { |
| return this._nodesMap[id]; |
| } |
| var node = new Graph.Node(id, data); |
| this.nodes.push(node); |
| this._nodesMap[id] = node; |
| return node; |
| }; |
| Graph.prototype.getNodeById = function (id) { |
| return this._nodesMap[id]; |
| }; |
| Graph.prototype.addEdge = function (n1, n2, data) { |
| if (typeof n1 == 'string') { |
| n1 = this._nodesMap[n1]; |
| } |
| if (typeof n2 == 'string') { |
| n2 = this._nodesMap[n2]; |
| } |
| if (!n1 || !n2) { |
| return; |
| } |
| var key = n1.id + '-' + n2.id; |
| if (this._edgesMap[key]) { |
| return this._edgesMap[key]; |
| } |
| var edge = new Graph.Edge(n1, n2, data); |
| if (this._directed) { |
| n1.outEdges.push(edge); |
| n2.inEdges.push(edge); |
| } |
| n1.edges.push(edge); |
| if (n1 !== n2) { |
| n2.edges.push(edge); |
| } |
| this.edges.push(edge); |
| this._edgesMap[key] = edge; |
| return edge; |
| }; |
| Graph.prototype.removeEdge = function (edge) { |
| var n1 = edge.node1; |
| var n2 = edge.node2; |
| var key = n1.id + '-' + n2.id; |
| if (this._directed) { |
| n1.outEdges.splice(util.indexOf(n1.outEdges, edge), 1); |
| n2.inEdges.splice(util.indexOf(n2.inEdges, edge), 1); |
| } |
| n1.edges.splice(util.indexOf(n1.edges, edge), 1); |
| if (n1 !== n2) { |
| n2.edges.splice(util.indexOf(n2.edges, edge), 1); |
| } |
| delete this._edgesMap[key]; |
| this.edges.splice(util.indexOf(this.edges, edge), 1); |
| }; |
| Graph.prototype.getEdge = function (n1, n2) { |
| if (typeof n1 !== 'string') { |
| n1 = n1.id; |
| } |
| if (typeof n2 !== 'string') { |
| n2 = n2.id; |
| } |
| if (this._directed) { |
| return this._edgesMap[n1 + '-' + n2] || this._edgesMap[n2 + '-' + n1]; |
| } else { |
| return this._edgesMap[n1 + '-' + n2]; |
| } |
| }; |
| Graph.prototype.removeNode = function (node) { |
| if (typeof node === 'string') { |
| node = this._nodesMap[node]; |
| if (!node) { |
| return; |
| } |
| } |
| delete this._nodesMap[node.id]; |
| this.nodes.splice(util.indexOf(this.nodes, node), 1); |
| for (var i = 0; i < this.edges.length;) { |
| var edge = this.edges[i]; |
| if (edge.node1 === node || edge.node2 === node) { |
| this.removeEdge(edge); |
| } else { |
| i++; |
| } |
| } |
| }; |
| Graph.prototype.filterNode = function (cb, context) { |
| var len = this.nodes.length; |
| for (var i = 0; i < len;) { |
| if (cb.call(context, this.nodes[i], i)) { |
| i++; |
| } else { |
| this.removeNode(this.nodes[i]); |
| len--; |
| } |
| } |
| }; |
| Graph.prototype.filterEdge = function (cb, context) { |
| var len = this.edges.length; |
| for (var i = 0; i < len;) { |
| if (cb.call(context, this.edges[i], i)) { |
| i++; |
| } else { |
| this.removeEdge(this.edges[i]); |
| len--; |
| } |
| } |
| }; |
| Graph.prototype.eachNode = function (cb, context) { |
| var len = this.nodes.length; |
| for (var i = 0; i < len; i++) { |
| if (this.nodes[i]) { |
| cb.call(context, this.nodes[i], i); |
| } |
| } |
| }; |
| Graph.prototype.eachEdge = function (cb, context) { |
| var len = this.edges.length; |
| for (var i = 0; i < len; i++) { |
| if (this.edges[i]) { |
| cb.call(context, this.edges[i], i); |
| } |
| } |
| }; |
| Graph.prototype.clear = function () { |
| this.nodes.length = 0; |
| this.edges.length = 0; |
| this._nodesMap = {}; |
| this._edgesMap = {}; |
| }; |
| Graph.prototype.breadthFirstTraverse = function (cb, startNode, direction, context) { |
| if (typeof startNode === 'string') { |
| startNode = this._nodesMap[startNode]; |
| } |
| if (!startNode) { |
| return; |
| } |
| var edgeType = 'edges'; |
| if (direction === 'out') { |
| edgeType = 'outEdges'; |
| } else if (direction === 'in') { |
| edgeType = 'inEdges'; |
| } |
| for (var i = 0; i < this.nodes.length; i++) { |
| this.nodes[i].__visited = false; |
| } |
| if (cb.call(context, startNode, null)) { |
| return; |
| } |
| var queue = [startNode]; |
| while (queue.length) { |
| var currentNode = queue.shift(); |
| var edges = currentNode[edgeType]; |
| for (var i = 0; i < edges.length; i++) { |
| var e = edges[i]; |
| var otherNode = e.node1 === currentNode ? e.node2 : e.node1; |
| if (!otherNode.__visited) { |
| if (cb.call(otherNode, otherNode, currentNode)) { |
| return; |
| } |
| queue.push(otherNode); |
| otherNode.__visited = true; |
| } |
| } |
| } |
| }; |
| Graph.prototype.clone = function () { |
| var graph = new Graph(this._directed); |
| for (var i = 0; i < this.nodes.length; i++) { |
| graph.addNode(this.nodes[i].id, this.nodes[i].data); |
| } |
| for (var i = 0; i < this.edges.length; i++) { |
| var e = this.edges[i]; |
| graph.addEdge(e.node1.id, e.node2.id, e.data); |
| } |
| return graph; |
| }; |
| var Node = function (id, data) { |
| this.id = id; |
| this.data = data || null; |
| this.inEdges = []; |
| this.outEdges = []; |
| this.edges = []; |
| }; |
| Node.prototype.degree = function () { |
| return this.edges.length; |
| }; |
| Node.prototype.inDegree = function () { |
| return this.inEdges.length; |
| }; |
| Node.prototype.outDegree = function () { |
| return this.outEdges.length; |
| }; |
| var Edge = function (node1, node2, data) { |
| this.node1 = node1; |
| this.node2 = node2; |
| this.data = data || null; |
| }; |
| Graph.Node = Node; |
| Graph.Edge = Edge; |
| Graph.fromMatrix = function (nodesData, matrix, directed) { |
| if (!matrix || !matrix.length || matrix[0].length !== matrix.length || nodesData.length !== matrix.length) { |
| return; |
| } |
| var size = matrix.length; |
| var graph = new Graph(directed); |
| for (var i = 0; i < size; i++) { |
| var node = graph.addNode(nodesData[i].id, nodesData[i]); |
| node.data.value = 0; |
| if (directed) { |
| node.data.outValue = node.data.inValue = 0; |
| } |
| } |
| for (var i = 0; i < size; i++) { |
| for (var j = 0; j < size; j++) { |
| var item = matrix[i][j]; |
| if (directed) { |
| graph.nodes[i].data.outValue += item; |
| graph.nodes[j].data.inValue += item; |
| } |
| graph.nodes[i].data.value += item; |
| graph.nodes[j].data.value += item; |
| } |
| } |
| for (var i = 0; i < size; i++) { |
| for (var j = i; j < size; j++) { |
| var item = matrix[i][j]; |
| if (item === 0) { |
| continue; |
| } |
| var n1 = graph.nodes[i]; |
| var n2 = graph.nodes[j]; |
| var edge = graph.addEdge(n1, n2, {}); |
| edge.data.weight = item; |
| if (i !== j) { |
| if (directed && matrix[j][i]) { |
| var inEdge = graph.addEdge(n2, n1, {}); |
| inEdge.data.weight = matrix[j][i]; |
| } |
| } |
| } |
| } |
| return graph; |
| }; |
| return Graph; |
| });define('echarts/layout/Chord', ['require'], function (require) { |
| var ChordLayout = function (opts) { |
| opts = opts || {}; |
| this.sort = opts.sort || null; |
| this.sortSub = opts.sortSub || null; |
| this.padding = 0.05; |
| this.startAngle = opts.startAngle || 0; |
| this.clockWise = opts.clockWise == null ? false : opts.clockWise; |
| this.center = opts.center || [ |
| 0, |
| 0 |
| ]; |
| this.directed = true; |
| }; |
| ChordLayout.prototype.run = function (graphs) { |
| if (!(graphs instanceof Array)) { |
| graphs = [graphs]; |
| } |
| var gl = graphs.length; |
| if (!gl) { |
| return; |
| } |
| var graph0 = graphs[0]; |
| var nl = graph0.nodes.length; |
| var groups = []; |
| var sumSize = 0; |
| for (var i = 0; i < nl; i++) { |
| var g0node = graph0.nodes[i]; |
| var group = { |
| size: 0, |
| subGroups: [], |
| node: g0node |
| }; |
| groups.push(group); |
| var sumWeight = 0; |
| for (var k = 0; k < graphs.length; k++) { |
| var graph = graphs[k]; |
| var node = graph.getNodeById(g0node.id); |
| if (!node) { |
| continue; |
| } |
| group.size += node.layout.size; |
| var edges = this.directed ? node.outEdges : node.edges; |
| for (var j = 0; j < edges.length; j++) { |
| var e = edges[j]; |
| var w = e.layout.weight; |
| group.subGroups.push({ |
| weight: w, |
| edge: e, |
| graph: graph |
| }); |
| sumWeight += w; |
| } |
| } |
| sumSize += group.size; |
| var multiplier = group.size / sumWeight; |
| for (var j = 0; j < group.subGroups.length; j++) { |
| group.subGroups[j].weight *= multiplier; |
| } |
| if (this.sortSub === 'ascending') { |
| group.subGroups.sort(compareSubGroups); |
| } else if (this.sort === 'descending') { |
| group.subGroups.sort(compareSubGroups); |
| group.subGroups.reverse(); |
| } |
| } |
| if (this.sort === 'ascending') { |
| groups.sort(compareGroups); |
| } else if (this.sort === 'descending') { |
| groups.sort(compareGroups); |
| groups.reverse(); |
| } |
| var multiplier = (Math.PI * 2 - this.padding * nl) / sumSize; |
| var angle = this.startAngle; |
| var sign = this.clockWise ? 1 : -1; |
| for (var i = 0; i < nl; i++) { |
| var group = groups[i]; |
| group.node.layout.startAngle = angle; |
| group.node.layout.endAngle = angle + sign * group.size * multiplier; |
| group.node.layout.subGroups = []; |
| for (var j = 0; j < group.subGroups.length; j++) { |
| var subGroup = group.subGroups[j]; |
| subGroup.edge.layout.startAngle = angle; |
| angle += sign * subGroup.weight * multiplier; |
| subGroup.edge.layout.endAngle = angle; |
| } |
| angle = group.node.layout.endAngle + sign * this.padding; |
| } |
| }; |
| var compareSubGroups = function (a, b) { |
| return a.weight - b.weight; |
| }; |
| var compareGroups = function (a, b) { |
| return a.size - b.size; |
| }; |
| return ChordLayout; |
| });define('echarts/chart/force', [ |
| 'require', |
| '../component/base', |
| './base', |
| '../data/Graph', |
| '../layout/Force', |
| 'zrender/shape/Line', |
| 'zrender/shape/BezierCurve', |
| 'zrender/shape/Image', |
| '../util/shape/Icon', |
| '../config', |
| '../util/ecData', |
| 'zrender/tool/util', |
| 'zrender/config', |
| 'zrender/tool/vector', |
| '../chart' |
| ], function (require) { |
| 'use strict'; |
| var ComponentBase = require('../component/base'); |
| var ChartBase = require('./base'); |
| var Graph = require('../data/Graph'); |
| var ForceLayout = require('../layout/Force'); |
| var LineShape = require('zrender/shape/Line'); |
| var BezierCurveShape = require('zrender/shape/BezierCurve'); |
| var ImageShape = require('zrender/shape/Image'); |
| var IconShape = require('../util/shape/Icon'); |
| var ecConfig = require('../config'); |
| var ecData = require('../util/ecData'); |
| var zrUtil = require('zrender/tool/util'); |
| var zrConfig = require('zrender/config'); |
| var vec2 = require('zrender/tool/vector'); |
| function Force(ecTheme, messageCenter, zr, option, myChart) { |
| var self = this; |
| ComponentBase.call(this, ecTheme, messageCenter, zr, option, myChart); |
| ChartBase.call(this); |
| this.__nodePositionMap = {}; |
| this._graph = new Graph(true); |
| this._layout = new ForceLayout(); |
| this._layout.onupdate = function () { |
| self._step(); |
| }; |
| this._steps = 1; |
| this.ondragstart = function () { |
| ondragstart.apply(self, arguments); |
| }; |
| this.ondragend = function () { |
| ondragend.apply(self, arguments); |
| }; |
| this.ondrop = function () { |
| }; |
| this.shapeHandler.ondragstart = function () { |
| self.isDragstart = true; |
| }; |
| this.onmousemove = function () { |
| onmousemove.apply(self, arguments); |
| }; |
| this.refresh(option); |
| } |
| Force.prototype = { |
| constructor: Force, |
| type: ecConfig.CHART_TYPE_FORCE, |
| _init: function () { |
| var legend = this.component.legend; |
| var series = this.series; |
| var serieName; |
| this.clear(); |
| for (var i = 0, l = series.length; i < l; i++) { |
| var serie = series[i]; |
| if (serie.type === ecConfig.CHART_TYPE_FORCE) { |
| series[i] = this.reformOption(series[i]); |
| serieName = series[i].name || ''; |
| this.selectedMap[serieName] = legend ? legend.isSelected(serieName) : true; |
| if (!this.selectedMap[serieName]) { |
| continue; |
| } |
| this.buildMark(i); |
| this._initSerie(serie, i); |
| break; |
| } |
| } |
| }, |
| _getNodeCategory: function (serie, node) { |
| return serie.categories && serie.categories[node.category || 0]; |
| }, |
| _getNodeQueryTarget: function (serie, node, type) { |
| type = type || 'normal'; |
| var category = this._getNodeCategory(serie, node) || {}; |
| return [ |
| node.itemStyle && node.itemStyle[type], |
| category && category.itemStyle && category.itemStyle[type], |
| serie.itemStyle[type].nodeStyle |
| ]; |
| }, |
| _getEdgeQueryTarget: function (serie, edge, type) { |
| type = type || 'normal'; |
| return [ |
| edge.itemStyle && edge.itemStyle[type], |
| serie.itemStyle[type].linkStyle |
| ]; |
| }, |
| _initSerie: function (serie, serieIdx) { |
| this._temperature = 1; |
| if (serie.data) { |
| this._graph = this._getSerieGraphFromDataMatrix(serie); |
| } else { |
| this._graph = this._getSerieGraphFromNodeLinks(serie); |
| } |
| this._buildLinkShapes(serie, serieIdx); |
| this._buildNodeShapes(serie, serieIdx); |
| this.zr.modLayer(this.getZlevelBase(), { |
| panable: serie.roam === true || serie.roam === 'move', |
| zoomable: serie.roam === true || serie.roam === 'scale' |
| }); |
| this._initLayout(serie); |
| this._step(); |
| }, |
| _getSerieGraphFromDataMatrix: function (serie) { |
| var nodesData = []; |
| var count = 0; |
| var matrix = []; |
| for (var i = 0; i < serie.matrix.length; i++) { |
| matrix[i] = serie.matrix[i].slice(); |
| } |
| var data = serie.data || serie.nodes; |
| for (var i = 0; i < data.length; i++) { |
| var node = {}; |
| var group = data[i]; |
| for (var key in group) { |
| if (key === 'name') { |
| node['id'] = group['name']; |
| } else { |
| node[key] = group[key]; |
| } |
| } |
| var category = this._getNodeCategory(serie, group); |
| var name = category ? category.name : group.name; |
| this.selectedMap[name] = this.isSelected(name); |
| if (this.selectedMap[name]) { |
| nodesData.push(node); |
| count++; |
| } else { |
| matrix.splice(count, 1); |
| for (var j = 0; j < matrix.length; j++) { |
| matrix[j].splice(count, 1); |
| } |
| } |
| } |
| var graph = Graph.fromMatrix(nodesData, matrix, true); |
| graph.eachNode(function (n, idx) { |
| n.layout = { |
| size: n.data.value, |
| mass: 0 |
| }; |
| n.rawIndex = idx; |
| }); |
| graph.eachEdge(function (e) { |
| e.layout = { weight: e.data.weight }; |
| }); |
| return graph; |
| }, |
| _getSerieGraphFromNodeLinks: function (serie) { |
| var graph = new Graph(true); |
| var nodes = serie.data || serie.nodes; |
| for (var i = 0, len = nodes.length; i < len; i++) { |
| var n = nodes[i]; |
| if (!n || n.ignore) { |
| continue; |
| } |
| var category = this._getNodeCategory(serie, n); |
| var name = category ? category.name : n.name; |
| this.selectedMap[name] = this.isSelected(name); |
| if (this.selectedMap[name]) { |
| var node = graph.addNode(n.name, n); |
| node.rawIndex = i; |
| } |
| } |
| for (var i = 0, len = serie.links.length; i < len; i++) { |
| var e = serie.links[i]; |
| var n1 = e.source; |
| var n2 = e.target; |
| if (typeof n1 === 'number') { |
| n1 = nodes[n1]; |
| if (n1) { |
| n1 = n1.name; |
| } |
| } |
| if (typeof n2 === 'number') { |
| n2 = nodes[n2]; |
| if (n2) { |
| n2 = n2.name; |
| } |
| } |
| var edge = graph.addEdge(n1, n2, e); |
| if (edge) { |
| edge.rawIndex = i; |
| } |
| } |
| graph.eachNode(function (n) { |
| var value = n.data.value; |
| if (value == null) { |
| value = 0; |
| for (var i = 0; i < n.edges.length; i++) { |
| value += n.edges[i].data.weight || 0; |
| } |
| } |
| n.layout = { |
| size: value, |
| mass: 0 |
| }; |
| }); |
| graph.eachEdge(function (e) { |
| e.layout = { weight: e.data.weight == null ? 1 : e.data.weight }; |
| }); |
| return graph; |
| }, |
| _initLayout: function (serie) { |
| var graph = this._graph; |
| var len = graph.nodes.length; |
| var minRadius = this.query(serie, 'minRadius'); |
| var maxRadius = this.query(serie, 'maxRadius'); |
| this._steps = serie.steps || 1; |
| this._layout.center = this.parseCenter(this.zr, serie.center); |
| this._layout.width = this.parsePercent(serie.size, this.zr.getWidth()); |
| this._layout.height = this.parsePercent(serie.size, this.zr.getHeight()); |
| this._layout.large = serie.large; |
| this._layout.scaling = serie.scaling; |
| this._layout.ratioScaling = serie.ratioScaling; |
| this._layout.gravity = serie.gravity; |
| this._layout.temperature = 1; |
| this._layout.coolDown = serie.coolDown; |
| this._layout.preventNodeEdgeOverlap = serie.preventOverlap; |
| this._layout.preventNodeOverlap = serie.preventOverlap; |
| var min = Infinity; |
| var max = -Infinity; |
| for (var i = 0; i < len; i++) { |
| var gNode = graph.nodes[i]; |
| max = Math.max(gNode.layout.size, max); |
| min = Math.min(gNode.layout.size, min); |
| } |
| var divider = max - min; |
| for (var i = 0; i < len; i++) { |
| var gNode = graph.nodes[i]; |
| if (divider > 0) { |
| gNode.layout.size = (gNode.layout.size - min) * (maxRadius - minRadius) / divider + minRadius; |
| gNode.layout.mass = gNode.layout.size / maxRadius; |
| } else { |
| gNode.layout.size = (maxRadius - minRadius) / 2; |
| gNode.layout.mass = 0.5; |
| } |
| } |
| for (var i = 0; i < len; i++) { |
| var gNode = graph.nodes[i]; |
| if (typeof this.__nodePositionMap[gNode.id] !== 'undefined') { |
| gNode.layout.position = vec2.create(); |
| vec2.copy(gNode.layout.position, this.__nodePositionMap[gNode.id]); |
| } else if (typeof gNode.data.initial !== 'undefined') { |
| gNode.layout.position = vec2.create(); |
| vec2.copy(gNode.layout.position, gNode.data.initial); |
| } else { |
| var center = this._layout.center; |
| var size = Math.min(this._layout.width, this._layout.height); |
| gNode.layout.position = _randomInSquare(center[0], center[1], size * 0.8); |
| } |
| var style = gNode.shape.style; |
| var radius = gNode.layout.size; |
| style.width = style.width || radius * 2; |
| style.height = style.height || radius * 2; |
| style.x = -style.width / 2; |
| style.y = -style.height / 2; |
| vec2.copy(gNode.shape.position, gNode.layout.position); |
| } |
| len = graph.edges.length; |
| max = -Infinity; |
| for (var i = 0; i < len; i++) { |
| var e = graph.edges[i]; |
| if (e.layout.weight > max) { |
| max = e.layout.weight; |
| } |
| } |
| for (var i = 0; i < len; i++) { |
| var e = graph.edges[i]; |
| e.layout.weight /= max; |
| } |
| this._layout.init(graph, serie.useWorker); |
| }, |
| _buildNodeShapes: function (serie, serieIdx) { |
| var graph = this._graph; |
| var categories = this.query(serie, 'categories'); |
| graph.eachNode(function (node) { |
| var category = this._getNodeCategory(serie, node.data); |
| var queryTarget = [ |
| node.data, |
| category, |
| serie |
| ]; |
| var styleQueryTarget = this._getNodeQueryTarget(serie, node.data); |
| var emphasisStyleQueryTarget = this._getNodeQueryTarget(serie, node.data, 'emphasis'); |
| var shape = new IconShape({ |
| style: { |
| x: 0, |
| y: 0, |
| color: this.deepQuery(styleQueryTarget, 'color'), |
| brushType: 'both', |
| strokeColor: this.deepQuery(styleQueryTarget, 'strokeColor') || this.deepQuery(styleQueryTarget, 'borderColor'), |
| lineWidth: this.deepQuery(styleQueryTarget, 'lineWidth') || this.deepQuery(styleQueryTarget, 'borderWidth') |
| }, |
| highlightStyle: { |
| color: this.deepQuery(emphasisStyleQueryTarget, 'color', 'emphasis'), |
| strokeColor: this.deepQuery(emphasisStyleQueryTarget, 'strokeColor', 'emphasis') || this.deepQuery(emphasisStyleQueryTarget, 'borderColor', 'emphasis'), |
| lineWidth: this.deepQuery(emphasisStyleQueryTarget, 'lineWidth', 'emphasis') || this.deepQuery(emphasisStyleQueryTarget, 'borderWidth', 'emphasis') |
| }, |
| clickable: serie.clickable, |
| zlevel: this.getZlevelBase() |
| }); |
| if (!shape.style.color) { |
| shape.style.color = category ? this.getColor(category.name) : this.getColor(node.id); |
| } |
| shape.style.iconType = this.deepQuery(queryTarget, 'symbol'); |
| shape.style.width = shape.style.height = (this.deepQuery(queryTarget, 'symbolSize') || 0) * 2; |
| if (shape.style.iconType.match('image')) { |
| shape.style.image = shape.style.iconType.replace(new RegExp('^image:\\/\\/'), ''); |
| shape = new ImageShape({ |
| style: shape.style, |
| highlightStyle: shape.highlightStyle, |
| clickable: shape.clickable |
| }); |
| } |
| if (this.deepQuery(queryTarget, 'itemStyle.normal.label.show')) { |
| shape.style.text = node.data.label == null ? node.id : node.data.label; |
| shape.style.textPosition = this.deepQuery(queryTarget, 'itemStyle.normal.label.position'); |
| shape.style.textColor = this.deepQuery(queryTarget, 'itemStyle.normal.label.textStyle.color'); |
| shape.style.textFont = this.getFont(this.deepQuery(queryTarget, 'itemStyle.normal.label.textStyle') || {}); |
| } |
| if (this.deepQuery(queryTarget, 'itemStyle.emphasis.label.show')) { |
| shape.highlightStyle.textPosition = this.deepQuery(queryTarget, 'itemStyle.emphasis.label.position'); |
| shape.highlightStyle.textColor = this.deepQuery(queryTarget, 'itemStyle.emphasis.label.textStyle.color'); |
| shape.highlightStyle.textFont = this.getFont(this.deepQuery(queryTarget, 'itemStyle.emphasis.label.textStyle') || {}); |
| } |
| if (this.deepQuery(queryTarget, 'draggable')) { |
| this.setCalculable(shape); |
| shape.dragEnableTime = 0; |
| shape.draggable = true; |
| shape.ondragstart = this.shapeHandler.ondragstart; |
| shape.ondragover = null; |
| } |
| var categoryName = ''; |
| if (typeof node.category !== 'undefined') { |
| var category = categories[node.category]; |
| categoryName = category && category.name || ''; |
| } |
| ecData.pack(shape, serie, serieIdx, node.data, node.rawIndex, node.data.name || '', node.category); |
| this.shapeList.push(shape); |
| this.zr.addShape(shape); |
| node.shape = shape; |
| }, this); |
| }, |
| _buildLinkShapes: function (serie, serieIdx) { |
| var graph = this._graph; |
| var len = graph.edges.length; |
| for (var i = 0; i < len; i++) { |
| var gEdge = graph.edges[i]; |
| var link = gEdge.data; |
| var source = gEdge.node1; |
| var target = gEdge.node2; |
| var queryTarget = this._getEdgeQueryTarget(serie, gEdge); |
| var linkType = this.deepQuery(queryTarget, 'type'); |
| if (serie.linkSymbol && serie.linkSymbol !== 'none') { |
| linkType = 'line'; |
| } |
| var LinkShapeCtor = linkType === 'line' ? LineShape : BezierCurveShape; |
| var linkShape = new LinkShapeCtor({ |
| style: { |
| xStart: 0, |
| yStart: 0, |
| xEnd: 0, |
| yEnd: 0, |
| lineWidth: 1 |
| }, |
| clickable: this.query(serie, 'clickable'), |
| highlightStyle: {}, |
| zlevel: this.getZlevelBase() |
| }); |
| zrUtil.merge(linkShape.style, this.query(serie, 'itemStyle.normal.linkStyle'), true); |
| zrUtil.merge(linkShape.highlightStyle, this.query(serie, 'itemStyle.emphasis.linkStyle'), true); |
| if (typeof link.itemStyle !== 'undefined') { |
| if (link.itemStyle.normal) { |
| zrUtil.merge(linkShape.style, link.itemStyle.normal, true); |
| } |
| if (link.itemStyle.emphasis) { |
| zrUtil.merge(linkShape.highlightStyle, link.itemStyle.emphasis, true); |
| } |
| } |
| linkShape.style.lineWidth = linkShape.style.lineWidth || linkShape.style.width; |
| linkShape.style.strokeColor = linkShape.style.strokeColor || linkShape.style.color; |
| linkShape.highlightStyle.lineWidth = linkShape.highlightStyle.lineWidth || linkShape.highlightStyle.width; |
| linkShape.highlightStyle.strokeColor = linkShape.highlightStyle.strokeColor || linkShape.highlightStyle.color; |
| ecData.pack(linkShape, serie, serieIdx, gEdge.data, gEdge.rawIndex == null ? i : gEdge.rawIndex, gEdge.data.name || source.id + ' - ' + target.id, source.id, target.id); |
| this.shapeList.push(linkShape); |
| this.zr.addShape(linkShape); |
| gEdge.shape = linkShape; |
| if (serie.linkSymbol && serie.linkSymbol !== 'none') { |
| var symbolShape = new IconShape({ |
| style: { |
| x: -5, |
| y: 0, |
| width: serie.linkSymbolSize[0], |
| height: serie.linkSymbolSize[1], |
| iconType: serie.linkSymbol, |
| brushType: 'fill', |
| color: linkShape.style.strokeColor, |
| opacity: linkShape.style.opacity, |
| shadowBlur: linkShape.style.shadowBlur, |
| shadowColor: linkShape.style.shadowColor, |
| shadowOffsetX: linkShape.style.shadowOffsetX, |
| shadowOffsetY: linkShape.style.shadowOffsetY |
| }, |
| highlightStyle: { brushType: 'fill' }, |
| position: [ |
| 0, |
| 0 |
| ], |
| rotation: 0 |
| }); |
| linkShape._symbolShape = symbolShape; |
| this.shapeList.push(symbolShape); |
| this.zr.addShape(symbolShape); |
| } |
| } |
| }, |
| _updateLinkShapes: function () { |
| var v = vec2.create(); |
| var edges = this._graph.edges; |
| for (var i = 0, len = edges.length; i < len; i++) { |
| var edge = edges[i]; |
| var sourceShape = edge.node1.shape; |
| var targetShape = edge.node2.shape; |
| var p1 = sourceShape.position; |
| var p2 = targetShape.position; |
| edge.shape.style.xStart = p1[0]; |
| edge.shape.style.yStart = p1[1]; |
| edge.shape.style.xEnd = p2[0]; |
| edge.shape.style.yEnd = p2[1]; |
| if (edge.shape.type === 'bezier-curve') { |
| edge.shape.style.cpX1 = (p1[0] + p2[0]) / 2 - (p2[1] - p1[1]) / 4; |
| edge.shape.style.cpY1 = (p1[1] + p2[1]) / 2 - (p1[0] - p2[0]) / 4; |
| } |
| edge.shape.modSelf(); |
| if (edge.shape._symbolShape) { |
| var symbolShape = edge.shape._symbolShape; |
| vec2.copy(symbolShape.position, targetShape.position); |
| vec2.sub(v, sourceShape.position, targetShape.position); |
| vec2.normalize(v, v); |
| vec2.scaleAndAdd(symbolShape.position, symbolShape.position, v, targetShape.style.width / 2 + 2); |
| var angle = Math.atan2(v[1], v[0]); |
| symbolShape.rotation = Math.PI / 2 - angle; |
| symbolShape.modSelf(); |
| } |
| } |
| }, |
| _syncNodePositions: function () { |
| var graph = this._graph; |
| for (var i = 0; i < graph.nodes.length; i++) { |
| var gNode = graph.nodes[i]; |
| var position = gNode.layout.position; |
| var node = gNode.data; |
| var shape = gNode.shape; |
| if (shape.fixed || node.fixX && node.fixY) { |
| vec2.copy(position, shape.position); |
| } else if (node.fixX) { |
| position[0] = shape.position[0]; |
| shape.position[1] = position[1]; |
| } else if (node.fixY) { |
| position[1] = shape.position[1]; |
| shape.position[0] = position[0]; |
| } else if (isNaN(node.fixX - 0) == false && isNaN(node.fixY - 0) == false) { |
| shape.position[0] += (position[0] - shape.position[0]) * node.fixX; |
| position[0] = shape.position[0]; |
| shape.position[1] += (position[1] - shape.position[1]) * node.fixY; |
| position[1] = shape.position[1]; |
| } else if (isNaN(node.fixX - 0) == false) { |
| shape.position[0] += (position[0] - shape.position[0]) * node.fixX; |
| position[0] = shape.position[0]; |
| shape.position[1] = position[1]; |
| } else if (isNaN(node.fixY - 0) == false) { |
| shape.position[1] += (position[1] - shape.position[1]) * node.fixY; |
| position[1] = shape.position[1]; |
| shape.position[0] = position[0]; |
| } else { |
| vec2.copy(shape.position, position); |
| } |
| var nodeName = node.name; |
| if (nodeName) { |
| var gPos = this.__nodePositionMap[nodeName]; |
| if (!gPos) { |
| gPos = this.__nodePositionMap[nodeName] = vec2.create(); |
| } |
| vec2.copy(gPos, position); |
| } |
| shape.modSelf(); |
| } |
| }, |
| _step: function (e) { |
| this._syncNodePositions(); |
| this._updateLinkShapes(); |
| this.zr.refreshNextFrame(); |
| if (this._layout.temperature > 0.01) { |
| this._layout.step(this._steps); |
| } else { |
| this.messageCenter.dispatch(ecConfig.EVENT.FORCE_LAYOUT_END, {}, {}, this.myChart); |
| } |
| }, |
| refresh: function (newOption) { |
| if (newOption) { |
| this.option = newOption; |
| this.series = this.option.series; |
| } |
| this.legend = this.component.legend; |
| if (this.legend) { |
| this.getColor = function (param) { |
| return this.legend.getColor(param); |
| }; |
| this.isSelected = function (param) { |
| return this.legend.isSelected(param); |
| }; |
| } else { |
| var colorMap = {}; |
| var count = 0; |
| this.getColor = function (key) { |
| if (colorMap[key]) { |
| return colorMap[key]; |
| } |
| if (!colorMap[key]) { |
| colorMap[key] = this.zr.getColor(count++); |
| } |
| return colorMap[key]; |
| }; |
| this.isSelected = function () { |
| return true; |
| }; |
| } |
| this._init(); |
| }, |
| dispose: function () { |
| this.clear(); |
| this.shapeList = null; |
| this.effectList = null; |
| this._layout.dispose(); |
| this._layout = null; |
| this.__nodePositionMap = {}; |
| }, |
| getPosition: function () { |
| var position = []; |
| this._graph.eachNode(function (n) { |
| if (n.layout) { |
| position.push({ |
| name: n.data.name, |
| position: Array.prototype.slice.call(n.layout.position) |
| }); |
| } |
| }); |
| return position; |
| } |
| }; |
| function ondragstart(param) { |
| if (!this.isDragstart || !param.target) { |
| return; |
| } |
| var shape = param.target; |
| shape.fixed = true; |
| this.isDragstart = false; |
| this.zr.on(zrConfig.EVENT.MOUSEMOVE, this.onmousemove); |
| } |
| function onmousemove() { |
| this._layout.temperature = 0.8; |
| this._step(); |
| } |
| function ondragend(param, status) { |
| if (!this.isDragend || !param.target) { |
| return; |
| } |
| var shape = param.target; |
| shape.fixed = false; |
| status.dragIn = true; |
| status.needRefresh = false; |
| this.isDragend = false; |
| this.zr.un(zrConfig.EVENT.MOUSEMOVE, this.onmousemove); |
| } |
| function _randomInSquare(x, y, size) { |
| var v = vec2.create(); |
| v[0] = (Math.random() - 0.5) * size + x; |
| v[1] = (Math.random() - 0.5) * size + y; |
| return v; |
| } |
| zrUtil.inherits(Force, ChartBase); |
| zrUtil.inherits(Force, ComponentBase); |
| require('../chart').define('force', Force); |
| return Force; |
| });define('echarts/layout/Force', [ |
| 'require', |
| './forceLayoutWorker', |
| 'zrender/tool/vector' |
| ], function (require) { |
| var ForceLayoutWorker = require('./forceLayoutWorker'); |
| var vec2 = require('zrender/tool/vector'); |
| var requestAnimationFrame = window.requestAnimationFrame || window.msRequestAnimationFrame || window.mozRequestAnimationFrame || window.webkitRequestAnimationFrame || function (func) { |
| setTimeout(func, 16); |
| }; |
| var ArrayCtor = typeof Float32Array == 'undefined' ? Array : Float32Array; |
| var workerUrl; |
| function getToken() { |
| return Math.round(new Date().getTime() / 100) % 10000000; |
| } |
| function createWorkerUrl() { |
| if (typeof Worker !== 'undefined' && typeof Blob !== 'undefined') { |
| try { |
| var blob = new Blob([ForceLayoutWorker.getWorkerCode()]); |
| workerUrl = window.URL.createObjectURL(blob); |
| } catch (e) { |
| workerUrl = ''; |
| } |
| } |
| return workerUrl; |
| } |
| var ForceLayout = function (opts) { |
| if (typeof workerUrl === 'undefined') { |
| createWorkerUrl(); |
| } |
| opts = opts || {}; |
| this.width = opts.width || 500; |
| this.height = opts.height || 500; |
| this.center = opts.center || [ |
| this.width / 2, |
| this.height / 2 |
| ]; |
| this.ratioScaling = opts.ratioScaling || false; |
| this.scaling = opts.scaling || 1; |
| this.gravity = typeof opts.gravity !== 'undefined' ? opts.gravity : 1; |
| this.large = opts.large || false; |
| this.preventNodeOverlap = opts.preventNodeOverlap || false; |
| this.preventNodeEdgeOverlap = opts.preventNodeEdgeOverlap || false; |
| this.maxSpeedIncrease = opts.maxSpeedIncrease || 1; |
| this.onupdate = opts.onupdate || function () { |
| }; |
| this.temperature = opts.temperature || 1; |
| this.coolDown = opts.coolDown || 0.99; |
| this._layout = null; |
| this._layoutWorker = null; |
| this._token = 0; |
| var self = this; |
| var _$onupdate = this._$onupdate; |
| this._$onupdate = function (e) { |
| _$onupdate.call(self, e); |
| }; |
| }; |
| ForceLayout.prototype.updateConfig = function () { |
| var width = this.width; |
| var height = this.height; |
| var size = Math.min(width, height); |
| var config = { |
| center: this.center, |
| width: this.ratioScaling ? width : size, |
| height: this.ratioScaling ? height : size, |
| scaling: this.scaling || 1, |
| gravity: this.gravity || 1, |
| barnesHutOptimize: this.large, |
| preventNodeOverlap: this.preventNodeOverlap, |
| preventNodeEdgeOverlap: this.preventNodeEdgeOverlap, |
| maxSpeedIncrease: this.maxSpeedIncrease |
| }; |
| if (this._layoutWorker) { |
| this._layoutWorker.postMessage({ |
| cmd: 'updateConfig', |
| config: config |
| }); |
| } else { |
| for (var name in config) { |
| this._layout[name] = config[name]; |
| } |
| } |
| }; |
| ForceLayout.prototype.init = function (graph, useWorker) { |
| if (workerUrl && useWorker) { |
| try { |
| if (!this._layoutWorker) { |
| this._layoutWorker = new Worker(workerUrl); |
| this._layoutWorker.onmessage = this._$onupdate; |
| } |
| this._layout = null; |
| } catch (e) { |
| this._layoutWorker = null; |
| if (!this._layout) { |
| this._layout = new ForceLayoutWorker(); |
| } |
| } |
| } else { |
| if (!this._layout) { |
| this._layout = new ForceLayoutWorker(); |
| } |
| if (this._layoutWorker) { |
| this._layoutWorker.terminate(); |
| this._layoutWorker = null; |
| } |
| } |
| this.temperature = 1; |
| this.graph = graph; |
| var len = graph.nodes.length; |
| var positionArr = new ArrayCtor(len * 2); |
| var massArr = new ArrayCtor(len); |
| var sizeArr = new ArrayCtor(len); |
| for (var i = 0; i < len; i++) { |
| var n = graph.nodes[i]; |
| positionArr[i * 2] = n.layout.position[0]; |
| positionArr[i * 2 + 1] = n.layout.position[1]; |
| massArr[i] = typeof n.layout.mass === 'undefined' ? 1 : n.layout.mass; |
| sizeArr[i] = typeof n.layout.size === 'undefined' ? 1 : n.layout.size; |
| n.layout.__index = i; |
| } |
| len = graph.edges.length; |
| var edgeArr = new ArrayCtor(len * 2); |
| var edgeWeightArr = new ArrayCtor(len); |
| for (var i = 0; i < len; i++) { |
| var edge = graph.edges[i]; |
| edgeArr[i * 2] = edge.node1.layout.__index; |
| edgeArr[i * 2 + 1] = edge.node2.layout.__index; |
| edgeWeightArr[i] = edge.layout.weight || 1; |
| } |
| this._token = getToken(); |
| if (this._layoutWorker) { |
| this._layoutWorker.postMessage({ |
| cmd: 'init', |
| nodesPosition: positionArr, |
| nodesMass: massArr, |
| nodesSize: sizeArr, |
| edges: edgeArr, |
| edgesWeight: edgeWeightArr, |
| token: this._token |
| }); |
| } else { |
| this._layout.setToken(this._token); |
| this._layout.initNodes(positionArr, massArr, sizeArr); |
| this._layout.initEdges(edgeArr, edgeWeightArr); |
| } |
| this.updateConfig(); |
| }; |
| ForceLayout.prototype.step = function (steps) { |
| var nodes = this.graph.nodes; |
| if (this._layoutWorker) { |
| var positionArr = new ArrayCtor(nodes.length * 2 + 1); |
| for (var i = 0; i < nodes.length; i++) { |
| var n = nodes[i]; |
| positionArr[i * 2 + 1] = n.layout.position[0]; |
| positionArr[i * 2 + 2] = n.layout.position[1]; |
| } |
| this._layoutWorker.postMessage(positionArr.buffer, [positionArr.buffer]); |
| this._layoutWorker.postMessage({ |
| cmd: 'update', |
| steps: steps, |
| temperature: this.temperature, |
| coolDown: this.coolDown |
| }); |
| for (var i = 0; i < steps; i++) { |
| this.temperature *= this.coolDown; |
| } |
| } else { |
| requestAnimationFrame(this._$onupdate); |
| for (var i = 0; i < nodes.length; i++) { |
| var n = nodes[i]; |
| vec2.copy(this._layout.nodes[i].position, n.layout.position); |
| } |
| for (var i = 0; i < steps; i++) { |
| this._layout.temperature = this.temperature; |
| this._layout.update(); |
| this.temperature *= this.coolDown; |
| } |
| } |
| }; |
| ForceLayout.prototype._$onupdate = function (e) { |
| if (this._layoutWorker) { |
| var positionArr = new Float32Array(e.data); |
| var token = positionArr[0]; |
| if (token === this._token) { |
| for (var i = 0; i < this.graph.nodes.length; i++) { |
| var n = this.graph.nodes[i]; |
| n.layout.position[0] = positionArr[i * 2 + 1]; |
| n.layout.position[1] = positionArr[i * 2 + 2]; |
| } |
| this.onupdate && this.onupdate(); |
| } |
| } else if (this._layout) { |
| if (this._layout.tokenMatch(this._token)) { |
| for (var i = 0; i < this.graph.nodes.length; i++) { |
| var n = this.graph.nodes[i]; |
| vec2.copy(n.layout.position, this._layout.nodes[i].position); |
| } |
| this.onupdate && this.onupdate(); |
| } |
| } |
| }; |
| ForceLayout.prototype.dispose = function () { |
| if (this._layoutWorker) { |
| this._layoutWorker.terminate(); |
| } |
| this._layoutWorker = null; |
| this._layout = null; |
| this._token = 0; |
| }; |
| return ForceLayout; |
| });define('echarts/layout/forceLayoutWorker', [ |
| 'require', |
| 'zrender/tool/vector' |
| ], function __echartsForceLayoutWorker(require) { |
| 'use strict'; |
| var vec2; |
| var inWorker = typeof window === 'undefined' && typeof require === 'undefined'; |
| if (inWorker) { |
| vec2 = { |
| create: function (x, y) { |
| var out = new Float32Array(2); |
| out[0] = x || 0; |
| out[1] = y || 0; |
| return out; |
| }, |
| dist: function (a, b) { |
| var x = b[0] - a[0]; |
| var y = b[1] - a[1]; |
| return Math.sqrt(x * x + y * y); |
| }, |
| len: function (a) { |
| var x = a[0]; |
| var y = a[1]; |
| return Math.sqrt(x * x + y * y); |
| }, |
| scaleAndAdd: function (out, a, b, scale) { |
| out[0] = a[0] + b[0] * scale; |
| out[1] = a[1] + b[1] * scale; |
| return out; |
| }, |
| scale: function (out, a, b) { |
| out[0] = a[0] * b; |
| out[1] = a[1] * b; |
| return out; |
| }, |
| add: function (out, a, b) { |
| out[0] = a[0] + b[0]; |
| out[1] = a[1] + b[1]; |
| return out; |
| }, |
| sub: function (out, a, b) { |
| out[0] = a[0] - b[0]; |
| out[1] = a[1] - b[1]; |
| return out; |
| }, |
| dot: function (v1, v2) { |
| return v1[0] * v2[0] + v1[1] * v2[1]; |
| }, |
| normalize: function (out, a) { |
| var x = a[0]; |
| var y = a[1]; |
| var len = x * x + y * y; |
| if (len > 0) { |
| len = 1 / Math.sqrt(len); |
| out[0] = a[0] * len; |
| out[1] = a[1] * len; |
| } |
| return out; |
| }, |
| negate: function (out, a) { |
| out[0] = -a[0]; |
| out[1] = -a[1]; |
| return out; |
| }, |
| copy: function (out, a) { |
| out[0] = a[0]; |
| out[1] = a[1]; |
| return out; |
| }, |
| set: function (out, x, y) { |
| out[0] = x; |
| out[1] = y; |
| return out; |
| } |
| }; |
| } else { |
| vec2 = require('zrender/tool/vector'); |
| } |
| var ArrayCtor = typeof Float32Array == 'undefined' ? Array : Float32Array; |
| function Region() { |
| this.subRegions = []; |
| this.nSubRegions = 0; |
| this.node = null; |
| this.mass = 0; |
| this.centerOfMass = null; |
| this.bbox = new ArrayCtor(4); |
| this.size = 0; |
| } |
| Region.prototype.beforeUpdate = function () { |
| for (var i = 0; i < this.nSubRegions; i++) { |
| this.subRegions[i].beforeUpdate(); |
| } |
| this.mass = 0; |
| if (this.centerOfMass) { |
| this.centerOfMass[0] = 0; |
| this.centerOfMass[1] = 0; |
| } |
| this.nSubRegions = 0; |
| this.node = null; |
| }; |
| Region.prototype.afterUpdate = function () { |
| this.subRegions.length = this.nSubRegions; |
| for (var i = 0; i < this.nSubRegions; i++) { |
| this.subRegions[i].afterUpdate(); |
| } |
| }; |
| Region.prototype.addNode = function (node) { |
| if (this.nSubRegions === 0) { |
| if (this.node == null) { |
| this.node = node; |
| return; |
| } else { |
| this._addNodeToSubRegion(this.node); |
| this.node = null; |
| } |
| } |
| this._addNodeToSubRegion(node); |
| this._updateCenterOfMass(node); |
| }; |
| Region.prototype.findSubRegion = function (x, y) { |
| for (var i = 0; i < this.nSubRegions; i++) { |
| var region = this.subRegions[i]; |
| if (region.contain(x, y)) { |
| return region; |
| } |
| } |
| }; |
| Region.prototype.contain = function (x, y) { |
| return this.bbox[0] <= x && this.bbox[2] >= x && this.bbox[1] <= y && this.bbox[3] >= y; |
| }; |
| Region.prototype.setBBox = function (minX, minY, maxX, maxY) { |
| this.bbox[0] = minX; |
| this.bbox[1] = minY; |
| this.bbox[2] = maxX; |
| this.bbox[3] = maxY; |
| this.size = (maxX - minX + maxY - minY) / 2; |
| }; |
| Region.prototype._newSubRegion = function () { |
| var subRegion = this.subRegions[this.nSubRegions]; |
| if (!subRegion) { |
| subRegion = new Region(); |
| this.subRegions[this.nSubRegions] = subRegion; |
| } |
| this.nSubRegions++; |
| return subRegion; |
| }; |
| Region.prototype._addNodeToSubRegion = function (node) { |
| var subRegion = this.findSubRegion(node.position[0], node.position[1]); |
| var bbox = this.bbox; |
| if (!subRegion) { |
| var cx = (bbox[0] + bbox[2]) / 2; |
| var cy = (bbox[1] + bbox[3]) / 2; |
| var w = (bbox[2] - bbox[0]) / 2; |
| var h = (bbox[3] - bbox[1]) / 2; |
| var xi = node.position[0] >= cx ? 1 : 0; |
| var yi = node.position[1] >= cy ? 1 : 0; |
| var subRegion = this._newSubRegion(); |
| subRegion.setBBox(xi * w + bbox[0], yi * h + bbox[1], (xi + 1) * w + bbox[0], (yi + 1) * h + bbox[1]); |
| } |
| subRegion.addNode(node); |
| }; |
| Region.prototype._updateCenterOfMass = function (node) { |
| if (this.centerOfMass == null) { |
| this.centerOfMass = vec2.create(); |
| } |
| var x = this.centerOfMass[0] * this.mass; |
| var y = this.centerOfMass[1] * this.mass; |
| x += node.position[0] * node.mass; |
| y += node.position[1] * node.mass; |
| this.mass += node.mass; |
| this.centerOfMass[0] = x / this.mass; |
| this.centerOfMass[1] = y / this.mass; |
| }; |
| function GraphNode() { |
| this.position = vec2.create(); |
| this.force = vec2.create(); |
| this.forcePrev = vec2.create(); |
| this.speed = vec2.create(); |
| this.speedPrev = vec2.create(); |
| this.mass = 1; |
| this.inDegree = 0; |
| this.outDegree = 0; |
| } |
| function GraphEdge(node1, node2) { |
| this.node1 = node1; |
| this.node2 = node2; |
| this.weight = 1; |
| } |
| function ForceLayout() { |
| this.barnesHutOptimize = false; |
| this.barnesHutTheta = 1.5; |
| this.repulsionByDegree = false; |
| this.preventNodeOverlap = false; |
| this.preventNodeEdgeOverlap = false; |
| this.strongGravity = true; |
| this.gravity = 1; |
| this.scaling = 1; |
| this.edgeWeightInfluence = 1; |
| this.center = [ |
| 0, |
| 0 |
| ]; |
| this.width = 500; |
| this.height = 500; |
| this.maxSpeedIncrease = 1; |
| this.nodes = []; |
| this.edges = []; |
| this.bbox = new ArrayCtor(4); |
| this._rootRegion = new Region(); |
| this._rootRegion.centerOfMass = vec2.create(); |
| this._massArr = null; |
| this._k = 0; |
| } |
| ForceLayout.prototype.nodeToNodeRepulsionFactor = function (mass, d, k) { |
| return k * k * mass / d; |
| }; |
| ForceLayout.prototype.edgeToNodeRepulsionFactor = function (mass, d, k) { |
| return k * mass / d; |
| }; |
| ForceLayout.prototype.attractionFactor = function (w, d, k) { |
| return w * d / k; |
| }; |
| ForceLayout.prototype.initNodes = function (positionArr, massArr, sizeArr) { |
| this.temperature = 1; |
| var nNodes = positionArr.length / 2; |
| this.nodes.length = 0; |
| var haveSize = typeof sizeArr !== 'undefined'; |
| for (var i = 0; i < nNodes; i++) { |
| var node = new GraphNode(); |
| node.position[0] = positionArr[i * 2]; |
| node.position[1] = positionArr[i * 2 + 1]; |
| node.mass = massArr[i]; |
| if (haveSize) { |
| node.size = sizeArr[i]; |
| } |
| this.nodes.push(node); |
| } |
| this._massArr = massArr; |
| if (haveSize) { |
| this._sizeArr = sizeArr; |
| } |
| }; |
| ForceLayout.prototype.initEdges = function (edgeArr, edgeWeightArr) { |
| var nEdges = edgeArr.length / 2; |
| this.edges.length = 0; |
| var edgeHaveWeight = typeof edgeWeightArr !== 'undefined'; |
| for (var i = 0; i < nEdges; i++) { |
| var sIdx = edgeArr[i * 2]; |
| var tIdx = edgeArr[i * 2 + 1]; |
| var sNode = this.nodes[sIdx]; |
| var tNode = this.nodes[tIdx]; |
| if (!sNode || !tNode) { |
| continue; |
| } |
| sNode.outDegree++; |
| tNode.inDegree++; |
| var edge = new GraphEdge(sNode, tNode); |
| if (edgeHaveWeight) { |
| edge.weight = edgeWeightArr[i]; |
| } |
| this.edges.push(edge); |
| } |
| }; |
| ForceLayout.prototype.update = function () { |
| var nNodes = this.nodes.length; |
| this.updateBBox(); |
| this._k = 0.4 * this.scaling * Math.sqrt(this.width * this.height / nNodes); |
| if (this.barnesHutOptimize) { |
| this._rootRegion.setBBox(this.bbox[0], this.bbox[1], this.bbox[2], this.bbox[3]); |
| this._rootRegion.beforeUpdate(); |
| for (var i = 0; i < nNodes; i++) { |
| this._rootRegion.addNode(this.nodes[i]); |
| } |
| this._rootRegion.afterUpdate(); |
| } else { |
| var mass = 0; |
| var centerOfMass = this._rootRegion.centerOfMass; |
| vec2.set(centerOfMass, 0, 0); |
| for (var i = 0; i < nNodes; i++) { |
| var node = this.nodes[i]; |
| mass += node.mass; |
| vec2.scaleAndAdd(centerOfMass, centerOfMass, node.position, node.mass); |
| } |
| if (mass > 0) { |
| vec2.scale(centerOfMass, centerOfMass, 1 / mass); |
| } |
| } |
| this.updateForce(); |
| this.updatePosition(); |
| }; |
| ForceLayout.prototype.updateForce = function () { |
| var nNodes = this.nodes.length; |
| for (var i = 0; i < nNodes; i++) { |
| var node = this.nodes[i]; |
| vec2.copy(node.forcePrev, node.force); |
| vec2.copy(node.speedPrev, node.speed); |
| vec2.set(node.force, 0, 0); |
| } |
| this.updateNodeNodeForce(); |
| if (this.gravity > 0) { |
| this.updateGravityForce(); |
| } |
| this.updateEdgeForce(); |
| if (this.preventNodeEdgeOverlap) { |
| this.updateNodeEdgeForce(); |
| } |
| }; |
| ForceLayout.prototype.updatePosition = function () { |
| var nNodes = this.nodes.length; |
| var v = vec2.create(); |
| for (var i = 0; i < nNodes; i++) { |
| var node = this.nodes[i]; |
| var speed = node.speed; |
| vec2.scale(node.force, node.force, 1 / 30); |
| var df = vec2.len(node.force) + 0.1; |
| var scale = Math.min(df, 500) / df; |
| vec2.scale(node.force, node.force, scale); |
| vec2.add(speed, speed, node.force); |
| vec2.scale(speed, speed, this.temperature); |
| vec2.sub(v, speed, node.speedPrev); |
| var swing = vec2.len(v); |
| if (swing > 0) { |
| vec2.scale(v, v, 1 / swing); |
| var base = vec2.len(node.speedPrev); |
| if (base > 0) { |
| swing = Math.min(swing / base, this.maxSpeedIncrease) * base; |
| vec2.scaleAndAdd(speed, node.speedPrev, v, swing); |
| } |
| } |
| var ds = vec2.len(speed); |
| var scale = Math.min(ds, 100) / (ds + 0.1); |
| vec2.scale(speed, speed, scale); |
| vec2.add(node.position, node.position, speed); |
| } |
| }; |
| ForceLayout.prototype.updateNodeNodeForce = function () { |
| var nNodes = this.nodes.length; |
| for (var i = 0; i < nNodes; i++) { |
| var na = this.nodes[i]; |
| if (this.barnesHutOptimize) { |
| this.applyRegionToNodeRepulsion(this._rootRegion, na); |
| } else { |
| for (var j = i + 1; j < nNodes; j++) { |
| var nb = this.nodes[j]; |
| this.applyNodeToNodeRepulsion(na, nb, false); |
| } |
| } |
| } |
| }; |
| ForceLayout.prototype.updateGravityForce = function () { |
| for (var i = 0; i < this.nodes.length; i++) { |
| this.applyNodeGravity(this.nodes[i]); |
| } |
| }; |
| ForceLayout.prototype.updateEdgeForce = function () { |
| for (var i = 0; i < this.edges.length; i++) { |
| this.applyEdgeAttraction(this.edges[i]); |
| } |
| }; |
| ForceLayout.prototype.updateNodeEdgeForce = function () { |
| for (var i = 0; i < this.nodes.length; i++) { |
| for (var j = 0; j < this.edges.length; j++) { |
| this.applyEdgeToNodeRepulsion(this.edges[j], this.nodes[i]); |
| } |
| } |
| }; |
| ForceLayout.prototype.applyRegionToNodeRepulsion = function () { |
| var v = vec2.create(); |
| return function applyRegionToNodeRepulsion(region, node) { |
| if (region.node) { |
| this.applyNodeToNodeRepulsion(region.node, node, true); |
| } else { |
| if (region.mass === 0 && node.mass === 0) { |
| return; |
| } |
| vec2.sub(v, node.position, region.centerOfMass); |
| var d2 = v[0] * v[0] + v[1] * v[1]; |
| if (d2 > this.barnesHutTheta * region.size * region.size) { |
| var factor = this._k * this._k * (node.mass + region.mass) / (d2 + 1); |
| vec2.scaleAndAdd(node.force, node.force, v, factor * 2); |
| } else { |
| for (var i = 0; i < region.nSubRegions; i++) { |
| this.applyRegionToNodeRepulsion(region.subRegions[i], node); |
| } |
| } |
| } |
| }; |
| }(); |
| ForceLayout.prototype.applyNodeToNodeRepulsion = function () { |
| var v = vec2.create(); |
| return function applyNodeToNodeRepulsion(na, nb, oneWay) { |
| if (na === nb) { |
| return; |
| } |
| if (na.mass === 0 && nb.mass === 0) { |
| return; |
| } |
| vec2.sub(v, na.position, nb.position); |
| var d2 = v[0] * v[0] + v[1] * v[1]; |
| if (d2 === 0) { |
| return; |
| } |
| var factor; |
| var mass = na.mass + nb.mass; |
| var d = Math.sqrt(d2); |
| vec2.scale(v, v, 1 / d); |
| if (this.preventNodeOverlap) { |
| d = d - na.size - nb.size; |
| if (d > 0) { |
| factor = this.nodeToNodeRepulsionFactor(mass, d, this._k); |
| } else if (d <= 0) { |
| factor = this._k * this._k * 10 * mass; |
| } |
| } else { |
| factor = this.nodeToNodeRepulsionFactor(mass, d, this._k); |
| } |
| if (!oneWay) { |
| vec2.scaleAndAdd(na.force, na.force, v, factor * 2); |
| } |
| vec2.scaleAndAdd(nb.force, nb.force, v, -factor * 2); |
| }; |
| }(); |
| ForceLayout.prototype.applyEdgeAttraction = function () { |
| var v = vec2.create(); |
| return function applyEdgeAttraction(edge) { |
| var na = edge.node1; |
| var nb = edge.node2; |
| vec2.sub(v, na.position, nb.position); |
| var d = vec2.len(v); |
| var w; |
| if (this.edgeWeightInfluence === 0) { |
| w = 1; |
| } else if (this.edgeWeightInfluence == 1) { |
| w = edge.weight; |
| } else { |
| w = Math.pow(edge.weight, this.edgeWeightInfluence); |
| } |
| var factor; |
| if (this.preventOverlap) { |
| d = d - na.size - nb.size; |
| if (d <= 0) { |
| return; |
| } |
| } |
| var factor = this.attractionFactor(w, d, this._k); |
| vec2.scaleAndAdd(na.force, na.force, v, -factor); |
| vec2.scaleAndAdd(nb.force, nb.force, v, factor); |
| }; |
| }(); |
| ForceLayout.prototype.applyNodeGravity = function () { |
| var v = vec2.create(); |
| return function (node) { |
| vec2.sub(v, this.center, node.position); |
| if (this.width > this.height) { |
| v[1] *= this.width / this.height; |
| } else { |
| v[0] *= this.height / this.width; |
| } |
| var d = vec2.len(v) / 100; |
| if (this.strongGravity) { |
| vec2.scaleAndAdd(node.force, node.force, v, d * this.gravity * node.mass); |
| } else { |
| vec2.scaleAndAdd(node.force, node.force, v, this.gravity * node.mass / (d + 1)); |
| } |
| }; |
| }(); |
| ForceLayout.prototype.applyEdgeToNodeRepulsion = function () { |
| var v12 = vec2.create(); |
| var v13 = vec2.create(); |
| var p = vec2.create(); |
| return function (e, n3) { |
| var n1 = e.node1; |
| var n2 = e.node2; |
| if (n1 === n3 || n2 === n3) { |
| return; |
| } |
| vec2.sub(v12, n2.position, n1.position); |
| vec2.sub(v13, n3.position, n1.position); |
| var len12 = vec2.len(v12); |
| vec2.scale(v12, v12, 1 / len12); |
| var len = vec2.dot(v12, v13); |
| if (len < 0 || len > len12) { |
| return; |
| } |
| vec2.scaleAndAdd(p, n1.position, v12, len); |
| var dist = vec2.dist(p, n3.position) - n3.size; |
| var factor = this.edgeToNodeRepulsionFactor(n3.mass, Math.max(dist, 0.1), 100); |
| vec2.sub(v12, n3.position, p); |
| vec2.normalize(v12, v12); |
| vec2.scaleAndAdd(n3.force, n3.force, v12, factor); |
| vec2.scaleAndAdd(n1.force, n1.force, v12, -factor); |
| vec2.scaleAndAdd(n2.force, n2.force, v12, -factor); |
| }; |
| }(); |
| ForceLayout.prototype.updateBBox = function () { |
| var minX = Infinity; |
| var minY = Infinity; |
| var maxX = -Infinity; |
| var maxY = -Infinity; |
| for (var i = 0; i < this.nodes.length; i++) { |
| var pos = this.nodes[i].position; |
| minX = Math.min(minX, pos[0]); |
| minY = Math.min(minY, pos[1]); |
| maxX = Math.max(maxX, pos[0]); |
| maxY = Math.max(maxY, pos[1]); |
| } |
| this.bbox[0] = minX; |
| this.bbox[1] = minY; |
| this.bbox[2] = maxX; |
| this.bbox[3] = maxY; |
| }; |
| ForceLayout.getWorkerCode = function () { |
| var str = __echartsForceLayoutWorker.toString(); |
| return str.slice(str.indexOf('{') + 1, str.lastIndexOf('return')); |
| }; |
| ForceLayout.prototype.setToken = function (token) { |
| this._token = token; |
| }; |
| ForceLayout.prototype.tokenMatch = function (token) { |
| return token === this._token; |
| }; |
| if (inWorker) { |
| var forceLayout = null; |
| self.onmessage = function (e) { |
| if (e.data instanceof ArrayBuffer) { |
| if (!forceLayout) |
| return; |
| var positionArr = new Float32Array(e.data); |
| var nNodes = (positionArr.length - 1) / 2; |
| for (var i = 0; i < nNodes; i++) { |
| var node = forceLayout.nodes[i]; |
| node.position[0] = positionArr[i * 2 + 1]; |
| node.position[1] = positionArr[i * 2 + 2]; |
| } |
| return; |
| } |
| switch (e.data.cmd) { |
| case 'init': |
| if (!forceLayout) { |
| forceLayout = new ForceLayout(); |
| } |
| forceLayout.initNodes(e.data.nodesPosition, e.data.nodesMass, e.data.nodesSize); |
| forceLayout.initEdges(e.data.edges, e.data.edgesWeight); |
| forceLayout._token = e.data.token; |
| break; |
| case 'updateConfig': |
| if (forceLayout) { |
| for (var name in e.data.config) { |
| forceLayout[name] = e.data.config[name]; |
| } |
| } |
| break; |
| case 'update': |
| var steps = e.data.steps; |
| if (forceLayout) { |
| var nNodes = forceLayout.nodes.length; |
| var positionArr = new Float32Array(nNodes * 2 + 1); |
| forceLayout.temperature = e.data.temperature; |
| for (var i = 0; i < steps; i++) { |
| forceLayout.update(); |
| forceLayout.temperature *= e.data.coolDown; |
| } |
| for (var i = 0; i < nNodes; i++) { |
| var node = forceLayout.nodes[i]; |
| positionArr[i * 2 + 1] = node.position[0]; |
| positionArr[i * 2 + 2] = node.position[1]; |
| } |
| positionArr[0] = forceLayout._token; |
| self.postMessage(positionArr.buffer, [positionArr.buffer]); |
| } else { |
| var emptyArr = new Float32Array(); |
| self.postMessage(emptyArr.buffer, [emptyArr.buffer]); |
| } |
| break; |
| } |
| }; |
| } |
| return ForceLayout; |
| });define('echarts/chart/map', [ |
| 'require', |
| '../component/base', |
| './base', |
| 'zrender/shape/Text', |
| 'zrender/shape/Path', |
| 'zrender/shape/Circle', |
| 'zrender/shape/Rectangle', |
| 'zrender/shape/Line', |
| 'zrender/shape/Polygon', |
| 'zrender/shape/Ellipse', |
| '../component/dataRange', |
| '../component/roamController', |
| '../config', |
| '../util/ecData', |
| 'zrender/tool/util', |
| 'zrender/config', |
| 'zrender/tool/event', |
| '../util/mapData/params', |
| '../util/mapData/textFixed', |
| '../util/mapData/geoCoord', |
| '../util/projection/svg', |
| '../util/projection/normal', |
| '../chart' |
| ], function (require) { |
| var ComponentBase = require('../component/base'); |
| var ChartBase = require('./base'); |
| var TextShape = require('zrender/shape/Text'); |
| var PathShape = require('zrender/shape/Path'); |
| var CircleShape = require('zrender/shape/Circle'); |
| var RectangleShape = require('zrender/shape/Rectangle'); |
| var LineShape = require('zrender/shape/Line'); |
| var PolygonShape = require('zrender/shape/Polygon'); |
| var EllipseShape = require('zrender/shape/Ellipse'); |
| require('../component/dataRange'); |
| require('../component/roamController'); |
| var ecConfig = require('../config'); |
| var ecData = require('../util/ecData'); |
| var zrUtil = require('zrender/tool/util'); |
| var zrConfig = require('zrender/config'); |
| var zrEvent = require('zrender/tool/event'); |
| var _mapParams = require('../util/mapData/params').params; |
| var _textFixed = require('../util/mapData/textFixed'); |
| var _geoCoord = require('../util/mapData/geoCoord'); |
| function Map(ecTheme, messageCenter, zr, option, myChart) { |
| ComponentBase.call(this, ecTheme, messageCenter, zr, option, myChart); |
| ChartBase.call(this); |
| var self = this; |
| self._onmousewheel = function (params) { |
| return self.__onmousewheel(params); |
| }; |
| self._onmousedown = function (params) { |
| return self.__onmousedown(params); |
| }; |
| self._onmousemove = function (params) { |
| return self.__onmousemove(params); |
| }; |
| self._onmouseup = function (params) { |
| return self.__onmouseup(params); |
| }; |
| self._onroamcontroller = function (params) { |
| return self.__onroamcontroller(params); |
| }; |
| self._ondrhoverlink = function (params) { |
| return self.__ondrhoverlink(params); |
| }; |
| this._isAlive = true; |
| this._selectedMode = {}; |
| this._activeMapType = {}; |
| this._clickable = {}; |
| this._hoverable = {}; |
| this._showLegendSymbol = {}; |
| this._selected = {}; |
| this._mapTypeMap = {}; |
| this._mapDataMap = {}; |
| this._nameMap = {}; |
| this._specialArea = {}; |
| this._refreshDelayTicket; |
| this._mapDataRequireCounter; |
| this._markAnimation = false; |
| this._hoverLinkMap = {}; |
| this._roamMap = {}; |
| this._scaleLimitMap = {}; |
| this._mx; |
| this._my; |
| this._mousedown; |
| this._justMove; |
| this._curMapType; |
| this.refresh(option); |
| this.zr.on(zrConfig.EVENT.MOUSEWHEEL, this._onmousewheel); |
| this.zr.on(zrConfig.EVENT.MOUSEDOWN, this._onmousedown); |
| messageCenter.bind(ecConfig.EVENT.ROAMCONTROLLER, this._onroamcontroller); |
| messageCenter.bind(ecConfig.EVENT.DATA_RANGE_HOVERLINK, this._ondrhoverlink); |
| } |
| Map.prototype = { |
| type: ecConfig.CHART_TYPE_MAP, |
| _buildShape: function () { |
| var series = this.series; |
| this.selectedMap = {}; |
| this._activeMapType = {}; |
| var legend = this.component.legend; |
| var seriesName; |
| var valueData = {}; |
| var mapType; |
| var data; |
| var name; |
| var mapSeries = {}; |
| var mapValuePrecision = {}; |
| var valueCalculation = {}; |
| for (var i = 0, l = series.length; i < l; i++) { |
| if (series[i].type == ecConfig.CHART_TYPE_MAP) { |
| series[i] = this.reformOption(series[i]); |
| mapType = series[i].mapType; |
| mapSeries[mapType] = mapSeries[mapType] || {}; |
| mapSeries[mapType][i] = true; |
| mapValuePrecision[mapType] = mapValuePrecision[mapType] || series[i].mapValuePrecision; |
| this._scaleLimitMap[mapType] = this._scaleLimitMap[mapType] || {}; |
| series[i].scaleLimit && zrUtil.merge(this._scaleLimitMap[mapType], series[i].scaleLimit, true); |
| this._roamMap[mapType] = series[i].roam || this._roamMap[mapType]; |
| this._hoverLinkMap[mapType] = series[i].dataRangeHoverLink || this._hoverLinkMap[mapType]; |
| this._nameMap[mapType] = this._nameMap[mapType] || {}; |
| series[i].nameMap && zrUtil.merge(this._nameMap[mapType], series[i].nameMap, true); |
| this._activeMapType[mapType] = true; |
| if (series[i].textFixed) { |
| zrUtil.merge(_textFixed, series[i].textFixed, true); |
| } |
| if (series[i].geoCoord) { |
| zrUtil.merge(_geoCoord, series[i].geoCoord, true); |
| } |
| this._selectedMode[mapType] = this._selectedMode[mapType] || series[i].selectedMode; |
| if (this._hoverable[mapType] == null || this._hoverable[mapType]) { |
| this._hoverable[mapType] = series[i].hoverable; |
| } |
| if (this._clickable[mapType] == null || this._clickable[mapType]) { |
| this._clickable[mapType] = series[i].clickable; |
| } |
| if (this._showLegendSymbol[mapType] == null || this._showLegendSymbol[mapType]) { |
| this._showLegendSymbol[mapType] = series[i].showLegendSymbol; |
| } |
| valueCalculation[mapType] = valueCalculation[mapType] || series[i].mapValueCalculation; |
| seriesName = series[i].name; |
| this.selectedMap[seriesName] = legend ? legend.isSelected(seriesName) : true; |
| if (this.selectedMap[seriesName]) { |
| valueData[mapType] = valueData[mapType] || {}; |
| data = series[i].data; |
| for (var j = 0, k = data.length; j < k; j++) { |
| name = this._nameChange(mapType, data[j].name); |
| valueData[mapType][name] = valueData[mapType][name] || { seriesIndex: [] }; |
| for (var key in data[j]) { |
| if (key != 'value') { |
| valueData[mapType][name][key] = data[j][key]; |
| } else if (!isNaN(data[j].value)) { |
| valueData[mapType][name].value == null && (valueData[mapType][name].value = 0); |
| valueData[mapType][name].value += data[j].value; |
| } |
| } |
| valueData[mapType][name].seriesIndex.push(i); |
| } |
| } |
| } |
| } |
| this._mapDataRequireCounter = 0; |
| for (var mt in valueData) { |
| this._mapDataRequireCounter++; |
| } |
| this._clearSelected(); |
| if (this._mapDataRequireCounter === 0) { |
| this.clear(); |
| this.zr && this.zr.delShape(this.lastShapeList); |
| this.lastShapeList = []; |
| } |
| for (var mt in valueData) { |
| if (valueCalculation[mt] && valueCalculation[mt] == 'average') { |
| for (var k in valueData[mt]) { |
| valueData[mt][k].value = (valueData[mt][k].value / valueData[mt][k].seriesIndex.length).toFixed(mapValuePrecision[mt]) - 0; |
| } |
| } |
| this._mapDataMap[mt] = this._mapDataMap[mt] || {}; |
| if (this._mapDataMap[mt].mapData) { |
| this._mapDataCallback(mt, valueData[mt], mapSeries[mt])(this._mapDataMap[mt].mapData); |
| } else if (_mapParams[mt.replace(/\|.*/, '')].getGeoJson) { |
| this._specialArea[mt] = _mapParams[mt.replace(/\|.*/, '')].specialArea || this._specialArea[mt]; |
| _mapParams[mt.replace(/\|.*/, '')].getGeoJson(this._mapDataCallback(mt, valueData[mt], mapSeries[mt])); |
| } |
| } |
| }, |
| _mapDataCallback: function (mt, vd, ms) { |
| var self = this; |
| return function (md) { |
| if (!self._isAlive || self._activeMapType[mt] == null) { |
| return; |
| } |
| if (mt.indexOf('|') != -1) { |
| md = self._getSubMapData(mt, md); |
| } |
| self._mapDataMap[mt].mapData = md; |
| if (md.firstChild) { |
| self._mapDataMap[mt].rate = 1; |
| self._mapDataMap[mt].projection = require('../util/projection/svg'); |
| } else { |
| self._mapDataMap[mt].rate = 0.75; |
| self._mapDataMap[mt].projection = require('../util/projection/normal'); |
| } |
| self._buildMap(mt, self._getProjectionData(mt, md, ms), vd, ms); |
| self._buildMark(mt, ms); |
| if (--self._mapDataRequireCounter <= 0) { |
| self.addShapeList(); |
| self.zr.refresh(); |
| } |
| }; |
| }, |
| _clearSelected: function () { |
| for (var k in this._selected) { |
| if (!this._activeMapType[this._mapTypeMap[k]]) { |
| delete this._selected[k]; |
| delete this._mapTypeMap[k]; |
| } |
| } |
| }, |
| _getSubMapData: function (mapType, mapData) { |
| var subType = mapType.replace(/^.*\|/, ''); |
| var features = mapData.features; |
| for (var i = 0, l = features.length; i < l; i++) { |
| if (features[i].properties && features[i].properties.name == subType) { |
| features = features[i]; |
| if (subType == 'United States of America' && features.geometry.coordinates.length > 1) { |
| features = { |
| geometry: { |
| coordinates: features.geometry.coordinates.slice(5, 6), |
| type: features.geometry.type |
| }, |
| id: features.id, |
| properties: features.properties, |
| type: features.type |
| }; |
| } |
| break; |
| } |
| } |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [features] |
| }; |
| }, |
| _getProjectionData: function (mapType, mapData, mapSeries) { |
| var normalProjection = this._mapDataMap[mapType].projection; |
| var province = []; |
| var bbox = this._mapDataMap[mapType].bbox || normalProjection.getBbox(mapData, this._specialArea[mapType]); |
| var transform; |
| if (!this._mapDataMap[mapType].hasRoam) { |
| transform = this._getTransform(bbox, mapSeries, this._mapDataMap[mapType].rate); |
| } else { |
| transform = this._mapDataMap[mapType].transform; |
| } |
| var lastTransform = this._mapDataMap[mapType].lastTransform || { scale: {} }; |
| var pathArray; |
| if (transform.left != lastTransform.left || transform.top != lastTransform.top || transform.scale.x != lastTransform.scale.x || transform.scale.y != lastTransform.scale.y) { |
| pathArray = normalProjection.geoJson2Path(mapData, transform, this._specialArea[mapType]); |
| lastTransform = zrUtil.clone(transform); |
| } else { |
| transform = this._mapDataMap[mapType].transform; |
| pathArray = this._mapDataMap[mapType].pathArray; |
| } |
| this._mapDataMap[mapType].bbox = bbox; |
| this._mapDataMap[mapType].transform = transform; |
| this._mapDataMap[mapType].lastTransform = lastTransform; |
| this._mapDataMap[mapType].pathArray = pathArray; |
| var position = [ |
| transform.left, |
| transform.top |
| ]; |
| for (var i = 0, l = pathArray.length; i < l; i++) { |
| province.push(this._getSingleProvince(mapType, pathArray[i], position)); |
| } |
| if (this._specialArea[mapType]) { |
| for (var area in this._specialArea[mapType]) { |
| province.push(this._getSpecialProjectionData(mapType, mapData, area, this._specialArea[mapType][area], position)); |
| } |
| } |
| if (mapType == 'china') { |
| var leftTop = this.geo2pos(mapType, _geoCoord['南海诸岛'] || _mapParams['南海诸岛'].textCoord); |
| var scale = transform.scale.x / 10.5; |
| var textPosition = [ |
| 32 * scale + leftTop[0], |
| 83 * scale + leftTop[1] |
| ]; |
| if (_textFixed['南海诸岛']) { |
| textPosition[0] += _textFixed['南海诸岛'][0]; |
| textPosition[1] += _textFixed['南海诸岛'][1]; |
| } |
| province.push({ |
| name: this._nameChange(mapType, '南海诸岛'), |
| path: _mapParams['南海诸岛'].getPath(leftTop, scale), |
| position: position, |
| textX: textPosition[0], |
| textY: textPosition[1] |
| }); |
| } |
| return province; |
| }, |
| _getSpecialProjectionData: function (mapType, mapData, areaName, mapSize, position) { |
| mapData = this._getSubMapData('x|' + areaName, mapData); |
| var normalProjection = require('../util/projection/normal'); |
| var bbox = normalProjection.getBbox(mapData); |
| var leftTop = this.geo2pos(mapType, [ |
| mapSize.left, |
| mapSize.top |
| ]); |
| var rightBottom = this.geo2pos(mapType, [ |
| mapSize.left + mapSize.width, |
| mapSize.top + mapSize.height |
| ]); |
| var width = Math.abs(rightBottom[0] - leftTop[0]); |
| var height = Math.abs(rightBottom[1] - leftTop[1]); |
| var mapWidth = bbox.width; |
| var mapHeight = bbox.height; |
| var xScale = width / 0.75 / mapWidth; |
| var yScale = height / mapHeight; |
| if (xScale > yScale) { |
| xScale = yScale * 0.75; |
| width = mapWidth * xScale; |
| } else { |
| yScale = xScale; |
| xScale = yScale * 0.75; |
| height = mapHeight * yScale; |
| } |
| var transform = { |
| OffsetLeft: leftTop[0], |
| OffsetTop: leftTop[1], |
| scale: { |
| x: xScale, |
| y: yScale |
| } |
| }; |
| var pathArray = normalProjection.geoJson2Path(mapData, transform); |
| return this._getSingleProvince(mapType, pathArray[0], position); |
| }, |
| _getSingleProvince: function (mapType, path, position) { |
| var textPosition; |
| var name = path.properties.name; |
| var textFixed = _textFixed[name] || [ |
| 0, |
| 0 |
| ]; |
| if (_geoCoord[name]) { |
| textPosition = this.geo2pos(mapType, _geoCoord[name]); |
| } else if (path.cp) { |
| textPosition = [ |
| path.cp[0] + textFixed[0], |
| path.cp[1] + textFixed[1] |
| ]; |
| } else { |
| var bbox = this._mapDataMap[mapType].bbox; |
| textPosition = this.geo2pos(mapType, [ |
| bbox.left + bbox.width / 2, |
| bbox.top + bbox.height / 2 |
| ]); |
| textPosition[0] += textFixed[0]; |
| textPosition[1] += textFixed[1]; |
| } |
| path.name = this._nameChange(mapType, name); |
| path.position = position; |
| path.textX = textPosition[0]; |
| path.textY = textPosition[1]; |
| return path; |
| }, |
| _getTransform: function (bbox, mapSeries, rate) { |
| var series = this.series; |
| var mapLocation; |
| var x; |
| var cusX; |
| var y; |
| var cusY; |
| var width; |
| var height; |
| var zrWidth = this.zr.getWidth(); |
| var zrHeight = this.zr.getHeight(); |
| var padding = Math.round(Math.min(zrWidth, zrHeight) * 0.02); |
| for (var key in mapSeries) { |
| mapLocation = series[key].mapLocation || {}; |
| cusX = mapLocation.x || cusX; |
| cusY = mapLocation.y || cusY; |
| width = mapLocation.width || width; |
| height = mapLocation.height || height; |
| } |
| x = this.parsePercent(cusX, zrWidth); |
| x = isNaN(x) ? padding : x; |
| y = this.parsePercent(cusY, zrHeight); |
| y = isNaN(y) ? padding : y; |
| width = width == null ? zrWidth - x - 2 * padding : this.parsePercent(width, zrWidth); |
| height = height == null ? zrHeight - y - 2 * padding : this.parsePercent(height, zrHeight); |
| var mapWidth = bbox.width; |
| var mapHeight = bbox.height; |
| var xScale = width / rate / mapWidth; |
| var yScale = height / mapHeight; |
| if (xScale > yScale) { |
| xScale = yScale * rate; |
| width = mapWidth * xScale; |
| } else { |
| yScale = xScale; |
| xScale = yScale * rate; |
| height = mapHeight * yScale; |
| } |
| if (isNaN(cusX)) { |
| cusX = cusX || 'center'; |
| switch (cusX + '') { |
| case 'center': |
| x = Math.floor((zrWidth - width) / 2); |
| break; |
| case 'right': |
| x = zrWidth - width; |
| break; |
| } |
| } |
| if (isNaN(cusY)) { |
| cusY = cusY || 'center'; |
| switch (cusY + '') { |
| case 'center': |
| y = Math.floor((zrHeight - height) / 2); |
| break; |
| case 'bottom': |
| y = zrHeight - height; |
| break; |
| } |
| } |
| return { |
| left: x, |
| top: y, |
| width: width, |
| height: height, |
| baseScale: 1, |
| scale: { |
| x: xScale, |
| y: yScale |
| } |
| }; |
| }, |
| _buildMap: function (mapType, mapData, valueData, mapSeries) { |
| var series = this.series; |
| var legend = this.component.legend; |
| var dataRange = this.component.dataRange; |
| var seriesName; |
| var name; |
| var data; |
| var value; |
| var queryTarget; |
| var defaultOption = this.ecTheme.map; |
| var color; |
| var font; |
| var style; |
| var highlightStyle; |
| var shape; |
| var textShape; |
| for (var i = 0, l = mapData.length; i < l; i++) { |
| style = zrUtil.clone(mapData[i]); |
| highlightStyle = { |
| name: style.name, |
| path: style.path, |
| position: zrUtil.clone(style.position) |
| }; |
| name = style.name; |
| data = valueData[name]; |
| if (data) { |
| queryTarget = [data]; |
| seriesName = ''; |
| for (var j = 0, k = data.seriesIndex.length; j < k; j++) { |
| queryTarget.push(series[data.seriesIndex[j]]); |
| seriesName += series[data.seriesIndex[j]].name + ' '; |
| if (legend && this._showLegendSymbol[mapType] && legend.hasColor(series[data.seriesIndex[j]].name)) { |
| this.shapeList.push(new CircleShape({ |
| zlevel: this._zlevelBase + 1, |
| position: zrUtil.clone(style.position), |
| _mapType: mapType, |
| style: { |
| x: style.textX + 3 + j * 7, |
| y: style.textY - 10, |
| r: 3, |
| color: legend.getColor(series[data.seriesIndex[j]].name) |
| }, |
| hoverable: false |
| })); |
| } |
| } |
| queryTarget.push(defaultOption); |
| value = data.value; |
| } else { |
| data = '-'; |
| seriesName = ''; |
| queryTarget = []; |
| for (var key in mapSeries) { |
| queryTarget.push(series[key]); |
| } |
| queryTarget.push(defaultOption); |
| value = '-'; |
| } |
| color = dataRange && !isNaN(value) ? dataRange.getColor(value) : null; |
| style.color = style.color || color || this.getItemStyleColor(this.deepQuery(queryTarget, 'itemStyle.normal.color'), data.seriesIndex, -1, data) || this.deepQuery(queryTarget, 'itemStyle.normal.areaStyle.color'); |
| style.strokeColor = style.strokeColor || this.deepQuery(queryTarget, 'itemStyle.normal.borderColor'); |
| style.lineWidth = style.lineWidth || this.deepQuery(queryTarget, 'itemStyle.normal.borderWidth'); |
| highlightStyle.color = this.getItemStyleColor(this.deepQuery(queryTarget, 'itemStyle.emphasis.color'), data.seriesIndex, -1, data) || this.deepQuery(queryTarget, 'itemStyle.emphasis.areaStyle.color') || style.color; |
| highlightStyle.strokeColor = this.deepQuery(queryTarget, 'itemStyle.emphasis.borderColor') || style.strokeColor; |
| highlightStyle.lineWidth = this.deepQuery(queryTarget, 'itemStyle.emphasis.borderWidth') || style.lineWidth; |
| style.brushType = highlightStyle.brushType = style.brushType || 'both'; |
| style.lineJoin = highlightStyle.lineJoin = 'round'; |
| style._name = highlightStyle._name = name; |
| font = this.deepQuery(queryTarget, 'itemStyle.normal.label.textStyle'); |
| textShape = { |
| zlevel: this._zlevelBase + 1, |
| position: zrUtil.clone(style.position), |
| _mapType: mapType, |
| _geo: this.pos2geo(mapType, [ |
| style.textX, |
| style.textY |
| ]), |
| style: { |
| brushType: 'fill', |
| x: style.textX, |
| y: style.textY, |
| text: this.getLabelText(name, value, queryTarget, 'normal'), |
| _name: name, |
| textAlign: 'center', |
| color: this.deepQuery(queryTarget, 'itemStyle.normal.label.show') ? this.deepQuery(queryTarget, 'itemStyle.normal.label.textStyle.color') : 'rgba(0,0,0,0)', |
| textFont: this.getFont(font) |
| } |
| }; |
| textShape._style = zrUtil.clone(textShape.style); |
| textShape.highlightStyle = zrUtil.clone(textShape.style); |
| if (this.deepQuery(queryTarget, 'itemStyle.emphasis.label.show')) { |
| textShape.highlightStyle.text = this.getLabelText(name, value, queryTarget, 'emphasis'); |
| textShape.highlightStyle.color = this.deepQuery(queryTarget, 'itemStyle.emphasis.label.textStyle.color') || textShape.style.color; |
| font = this.deepQuery(queryTarget, 'itemStyle.emphasis.label.textStyle') || font; |
| textShape.highlightStyle.textFont = this.getFont(font); |
| } else { |
| textShape.highlightStyle.color = 'rgba(0,0,0,0)'; |
| } |
| shape = { |
| zlevel: this._zlevelBase, |
| position: zrUtil.clone(style.position), |
| style: style, |
| highlightStyle: highlightStyle, |
| _style: zrUtil.clone(style), |
| _mapType: mapType |
| }; |
| if (style.scale != null) { |
| shape.scale = zrUtil.clone(style.scale); |
| } |
| textShape = new TextShape(textShape); |
| switch (shape.style.shapeType) { |
| case 'rectangle': |
| shape = new RectangleShape(shape); |
| break; |
| case 'line': |
| shape = new LineShape(shape); |
| break; |
| case 'circle': |
| shape = new CircleShape(shape); |
| break; |
| case 'polygon': |
| shape = new PolygonShape(shape); |
| break; |
| case 'ellipse': |
| shape = new EllipseShape(shape); |
| break; |
| default: |
| shape = new PathShape(shape); |
| if (shape.buildPathArray) { |
| shape.style.pathArray = shape.buildPathArray(shape.style.path); |
| } |
| break; |
| } |
| if (this._selectedMode[mapType] && this._selected[name] || data.selected && this._selected[name] !== false) { |
| textShape.style = textShape.highlightStyle; |
| shape.style = shape.highlightStyle; |
| } |
| textShape.clickable = shape.clickable = this._clickable[mapType] && (data.clickable == null || data.clickable); |
| if (this._selectedMode[mapType]) { |
| this._selected[name] = this._selected[name] != null ? this._selected[name] : data.selected; |
| this._mapTypeMap[name] = mapType; |
| if (data.selectable == null || data.selectable) { |
| shape.clickable = textShape.clickable = true; |
| shape.onclick = textShape.onclick = this.shapeHandler.onclick; |
| } |
| } |
| if (this._hoverable[mapType] && (data.hoverable == null || data.hoverable)) { |
| textShape.hoverable = shape.hoverable = true; |
| shape.hoverConnect = textShape.id; |
| textShape.hoverConnect = shape.id; |
| } else { |
| textShape.hoverable = shape.hoverable = false; |
| } |
| ecData.pack(textShape, { |
| name: seriesName, |
| tooltip: this.deepQuery(queryTarget, 'tooltip') |
| }, 0, data, 0, name); |
| this.shapeList.push(textShape); |
| ecData.pack(shape, { |
| name: seriesName, |
| tooltip: this.deepQuery(queryTarget, 'tooltip') |
| }, 0, data, 0, name); |
| this.shapeList.push(shape); |
| } |
| }, |
| _buildMark: function (mapType, mapSeries) { |
| this._seriesIndexToMapType = this._seriesIndexToMapType || {}; |
| this.markAttachStyle = this.markAttachStyle || {}; |
| var position = [ |
| this._mapDataMap[mapType].transform.left, |
| this._mapDataMap[mapType].transform.top |
| ]; |
| if (mapType == 'none') { |
| position = [ |
| 0, |
| 0 |
| ]; |
| } |
| for (var sIdx in mapSeries) { |
| this._seriesIndexToMapType[sIdx] = mapType; |
| this.markAttachStyle[sIdx] = { |
| position: position, |
| _mapType: mapType |
| }; |
| this.buildMark(sIdx); |
| } |
| }, |
| getMarkCoord: function (seriesIndex, mpData) { |
| return mpData.geoCoord || _geoCoord[mpData.name] ? this.geo2pos(this._seriesIndexToMapType[seriesIndex], mpData.geoCoord || _geoCoord[mpData.name]) : [ |
| 0, |
| 0 |
| ]; |
| }, |
| getMarkGeo: function (mpData) { |
| return mpData.geoCoord || _geoCoord[mpData.name]; |
| }, |
| _nameChange: function (mapType, name) { |
| return this._nameMap[mapType][name] || name; |
| }, |
| getLabelText: function (name, value, queryTarget, status) { |
| var formatter = this.deepQuery(queryTarget, 'itemStyle.' + status + '.label.formatter'); |
| if (formatter) { |
| if (typeof formatter == 'function') { |
| return formatter.call(this.myChart, name, value); |
| } else if (typeof formatter == 'string') { |
| formatter = formatter.replace('{a}', '{a0}').replace('{b}', '{b0}'); |
| formatter = formatter.replace('{a0}', name).replace('{b0}', value); |
| return formatter; |
| } |
| } else { |
| return name; |
| } |
| }, |
| _findMapTypeByPos: function (mx, my) { |
| var transform; |
| var left; |
| var top; |
| var width; |
| var height; |
| for (var mapType in this._mapDataMap) { |
| transform = this._mapDataMap[mapType].transform; |
| if (!transform || !this._roamMap[mapType] || !this._activeMapType[mapType]) { |
| continue; |
| } |
| left = transform.left; |
| top = transform.top; |
| width = transform.width; |
| height = transform.height; |
| if (mx >= left && mx <= left + width && my >= top && my <= top + height) { |
| return mapType; |
| } |
| } |
| return; |
| }, |
| __onmousewheel: function (params) { |
| if (this.shapeList.length <= 0) { |
| return; |
| } |
| var event = params.event; |
| var mx = zrEvent.getX(event); |
| var my = zrEvent.getY(event); |
| var delta; |
| var eventDelta = zrEvent.getDelta(event); |
| var mapType; |
| var mapTypeControl = params.mapTypeControl; |
| if (!mapTypeControl) { |
| mapTypeControl = {}; |
| mapType = this._findMapTypeByPos(mx, my); |
| if (mapType && this._roamMap[mapType] && this._roamMap[mapType] != 'move') { |
| mapTypeControl[mapType] = true; |
| } |
| } |
| var haveScale = false; |
| for (mapType in mapTypeControl) { |
| if (mapTypeControl[mapType]) { |
| haveScale = true; |
| var transform = this._mapDataMap[mapType].transform; |
| var left = transform.left; |
| var top = transform.top; |
| var width = transform.width; |
| var height = transform.height; |
| var geoAndPos = this.pos2geo(mapType, [ |
| mx - left, |
| my - top |
| ]); |
| if (eventDelta > 0) { |
| delta = 1.2; |
| if (this._scaleLimitMap[mapType].max != null && transform.baseScale >= this._scaleLimitMap[mapType].max) { |
| continue; |
| } |
| } else { |
| delta = 1 / 1.2; |
| if (this._scaleLimitMap[mapType].min != null && transform.baseScale <= this._scaleLimitMap[mapType].min) { |
| continue; |
| } |
| } |
| transform.baseScale *= delta; |
| transform.scale.x *= delta; |
| transform.scale.y *= delta; |
| transform.width = width * delta; |
| transform.height = height * delta; |
| this._mapDataMap[mapType].hasRoam = true; |
| this._mapDataMap[mapType].transform = transform; |
| geoAndPos = this.geo2pos(mapType, geoAndPos); |
| transform.left -= geoAndPos[0] - (mx - left); |
| transform.top -= geoAndPos[1] - (my - top); |
| this._mapDataMap[mapType].transform = transform; |
| this.clearEffectShape(true); |
| for (var i = 0, l = this.shapeList.length; i < l; i++) { |
| if (this.shapeList[i]._mapType == mapType) { |
| this.shapeList[i].position[0] = transform.left; |
| this.shapeList[i].position[1] = transform.top; |
| if (this.shapeList[i].type == 'path' || this.shapeList[i].type == 'symbol' || this.shapeList[i].type == 'circle' || this.shapeList[i].type == 'rectangle' || this.shapeList[i].type == 'polygon' || this.shapeList[i].type == 'line' || this.shapeList[i].type == 'ellipse') { |
| this.shapeList[i].scale[0] *= delta; |
| this.shapeList[i].scale[1] *= delta; |
| } else if (this.shapeList[i].type == 'mark-line') { |
| this.shapeList[i].style.pointListLength = undefined; |
| this.shapeList[i].style.pointList = false; |
| geoAndPos = this.geo2pos(mapType, this.shapeList[i]._geo[0]); |
| this.shapeList[i].style.xStart = geoAndPos[0]; |
| this.shapeList[i].style.yStart = geoAndPos[1]; |
| geoAndPos = this.geo2pos(mapType, this.shapeList[i]._geo[1]); |
| this.shapeList[i]._x = this.shapeList[i].style.xEnd = geoAndPos[0]; |
| this.shapeList[i]._y = this.shapeList[i].style.yEnd = geoAndPos[1]; |
| } else if (this.shapeList[i].type == 'icon') { |
| geoAndPos = this.geo2pos(mapType, this.shapeList[i]._geo); |
| this.shapeList[i].style.x = this.shapeList[i].style._x = geoAndPos[0] - this.shapeList[i].style.width / 2; |
| this.shapeList[i].style.y = this.shapeList[i].style._y = geoAndPos[1] - this.shapeList[i].style.height / 2; |
| } else { |
| geoAndPos = this.geo2pos(mapType, this.shapeList[i]._geo); |
| this.shapeList[i].style.x = geoAndPos[0]; |
| this.shapeList[i].style.y = geoAndPos[1]; |
| if (this.shapeList[i].type == 'text') { |
| this.shapeList[i]._style.x = this.shapeList[i].highlightStyle.x = geoAndPos[0]; |
| this.shapeList[i]._style.y = this.shapeList[i].highlightStyle.y = geoAndPos[1]; |
| } |
| } |
| this.zr.modShape(this.shapeList[i].id); |
| } |
| } |
| } |
| } |
| if (haveScale) { |
| zrEvent.stop(event); |
| this.zr.refresh(); |
| var self = this; |
| clearTimeout(this._refreshDelayTicket); |
| this._refreshDelayTicket = setTimeout(function () { |
| self && self.shapeList && self.animationEffect(); |
| }, 100); |
| this.messageCenter.dispatch(ecConfig.EVENT.MAP_ROAM, params.event, { type: 'scale' }, this.myChart); |
| } |
| }, |
| __onmousedown: function (params) { |
| if (this.shapeList.length <= 0) { |
| return; |
| } |
| var target = params.target; |
| if (target && target.draggable) { |
| return; |
| } |
| var event = params.event; |
| var mx = zrEvent.getX(event); |
| var my = zrEvent.getY(event); |
| var mapType = this._findMapTypeByPos(mx, my); |
| if (mapType && this._roamMap[mapType] && this._roamMap[mapType] != 'scale') { |
| this._mousedown = true; |
| this._mx = mx; |
| this._my = my; |
| this._curMapType = mapType; |
| this.zr.on(zrConfig.EVENT.MOUSEUP, this._onmouseup); |
| var self = this; |
| setTimeout(function () { |
| self.zr.on(zrConfig.EVENT.MOUSEMOVE, self._onmousemove); |
| }, 100); |
| } |
| }, |
| __onmousemove: function (params) { |
| if (!this._mousedown || !this._isAlive) { |
| return; |
| } |
| var event = params.event; |
| var mx = zrEvent.getX(event); |
| var my = zrEvent.getY(event); |
| var transform = this._mapDataMap[this._curMapType].transform; |
| transform.hasRoam = true; |
| transform.left -= this._mx - mx; |
| transform.top -= this._my - my; |
| this._mx = mx; |
| this._my = my; |
| this._mapDataMap[this._curMapType].transform = transform; |
| for (var i = 0, l = this.shapeList.length; i < l; i++) { |
| if (this.shapeList[i]._mapType == this._curMapType) { |
| this.shapeList[i].position[0] = transform.left; |
| this.shapeList[i].position[1] = transform.top; |
| this.zr.modShape(this.shapeList[i].id); |
| } |
| } |
| this.messageCenter.dispatch(ecConfig.EVENT.MAP_ROAM, params.event, { type: 'move' }, this.myChart); |
| this.clearEffectShape(true); |
| this.zr.refresh(); |
| this._justMove = true; |
| zrEvent.stop(event); |
| }, |
| __onmouseup: function (params) { |
| var event = params.event; |
| this._mx = zrEvent.getX(event); |
| this._my = zrEvent.getY(event); |
| this._mousedown = false; |
| var self = this; |
| setTimeout(function () { |
| self._justMove && self.animationEffect(); |
| self._justMove = false; |
| self.zr.un(zrConfig.EVENT.MOUSEMOVE, self._onmousemove); |
| self.zr.un(zrConfig.EVENT.MOUSEUP, self._onmouseup); |
| }, 120); |
| }, |
| __onroamcontroller: function (params) { |
| var event = params.event; |
| event.zrenderX = this.zr.getWidth() / 2; |
| event.zrenderY = this.zr.getHeight() / 2; |
| var mapTypeControl = params.mapTypeControl; |
| var top = 0; |
| var left = 0; |
| var step = params.step; |
| switch (params.roamType) { |
| case 'scaleUp': |
| event.zrenderDelta = 1; |
| this.__onmousewheel({ |
| event: event, |
| mapTypeControl: mapTypeControl |
| }); |
| return; |
| case 'scaleDown': |
| event.zrenderDelta = -1; |
| this.__onmousewheel({ |
| event: event, |
| mapTypeControl: mapTypeControl |
| }); |
| return; |
| case 'up': |
| top = -step; |
| break; |
| case 'down': |
| top = step; |
| break; |
| case 'left': |
| left = -step; |
| break; |
| case 'right': |
| left = step; |
| break; |
| } |
| var transform; |
| var curMapType; |
| for (curMapType in mapTypeControl) { |
| if (!this._mapDataMap[curMapType] || !this._activeMapType[curMapType]) { |
| continue; |
| } |
| transform = this._mapDataMap[curMapType].transform; |
| transform.hasRoam = true; |
| transform.left -= left; |
| transform.top -= top; |
| this._mapDataMap[curMapType].transform = transform; |
| } |
| for (var i = 0, l = this.shapeList.length; i < l; i++) { |
| curMapType = this.shapeList[i]._mapType; |
| if (!mapTypeControl[curMapType] || !this._activeMapType[curMapType]) { |
| continue; |
| } |
| transform = this._mapDataMap[curMapType].transform; |
| this.shapeList[i].position[0] = transform.left; |
| this.shapeList[i].position[1] = transform.top; |
| this.zr.modShape(this.shapeList[i].id); |
| } |
| this.messageCenter.dispatch(ecConfig.EVENT.MAP_ROAM, params.event, { type: 'move' }, this.myChart); |
| this.clearEffectShape(true); |
| this.zr.refresh(); |
| clearTimeout(this.dircetionTimer); |
| var self = this; |
| this.dircetionTimer = setTimeout(function () { |
| self.animationEffect(); |
| }, 150); |
| }, |
| __ondrhoverlink: function (param) { |
| var curMapType; |
| var value; |
| for (var i = 0, l = this.shapeList.length; i < l; i++) { |
| curMapType = this.shapeList[i]._mapType; |
| if (!this._hoverLinkMap[curMapType] || !this._activeMapType[curMapType]) { |
| continue; |
| } |
| value = ecData.get(this.shapeList[i], 'value'); |
| if (value != null && value >= param.valueMin && value <= param.valueMax) { |
| this.zr.addHoverShape(this.shapeList[i]); |
| } |
| } |
| }, |
| onclick: function (params) { |
| if (!this.isClick || !params.target || this._justMove || params.target.type == 'icon') { |
| return; |
| } |
| this.isClick = false; |
| var target = params.target; |
| var name = target.style._name; |
| var len = this.shapeList.length; |
| var mapType = target._mapType || ''; |
| if (this._selectedMode[mapType] == 'single') { |
| for (var p in this._selected) { |
| if (this._selected[p] && this._mapTypeMap[p] == mapType) { |
| for (var i = 0; i < len; i++) { |
| if (this.shapeList[i].style._name == p && this.shapeList[i]._mapType == mapType) { |
| this.shapeList[i].style = this.shapeList[i]._style; |
| this.zr.modShape(this.shapeList[i].id); |
| } |
| } |
| p != name && (this._selected[p] = false); |
| } |
| } |
| } |
| this._selected[name] = !this._selected[name]; |
| for (var i = 0; i < len; i++) { |
| if (this.shapeList[i].style._name == name && this.shapeList[i]._mapType == mapType) { |
| if (this._selected[name]) { |
| this.shapeList[i].style = this.shapeList[i].highlightStyle; |
| } else { |
| this.shapeList[i].style = this.shapeList[i]._style; |
| } |
| this.zr.modShape(this.shapeList[i].id); |
| } |
| } |
| this.messageCenter.dispatch(ecConfig.EVENT.MAP_SELECTED, params.event, { |
| selected: this._selected, |
| target: name |
| }, this.myChart); |
| this.zr.refresh(); |
| var self = this; |
| setTimeout(function () { |
| self.zr.trigger(zrConfig.EVENT.MOUSEMOVE, params.event); |
| }, 100); |
| }, |
| refresh: function (newOption) { |
| if (newOption) { |
| this.option = newOption; |
| this.series = newOption.series; |
| } |
| if (this._mapDataRequireCounter > 0) { |
| this.clear(); |
| } else { |
| this.backupShapeList(); |
| } |
| this._buildShape(); |
| this.zr.refreshHover(); |
| }, |
| ondataRange: function (param, status) { |
| if (this.component.dataRange) { |
| this.refresh(); |
| status.needRefresh = true; |
| } |
| return; |
| }, |
| pos2geo: function (mapType, p) { |
| if (!this._mapDataMap[mapType].transform) { |
| return null; |
| } |
| return this._mapDataMap[mapType].projection.pos2geo(this._mapDataMap[mapType].transform, p); |
| }, |
| getGeoByPos: function (mapType, p) { |
| if (!this._mapDataMap[mapType].transform) { |
| return null; |
| } |
| var position = [ |
| this._mapDataMap[mapType].transform.left, |
| this._mapDataMap[mapType].transform.top |
| ]; |
| if (p instanceof Array) { |
| p[0] -= position[0]; |
| p[1] -= position[1]; |
| } else { |
| p.x -= position[0]; |
| p.y -= position[1]; |
| } |
| return this.pos2geo(mapType, p); |
| }, |
| geo2pos: function (mapType, p) { |
| if (!this._mapDataMap[mapType].transform) { |
| return null; |
| } |
| return this._mapDataMap[mapType].projection.geo2pos(this._mapDataMap[mapType].transform, p); |
| }, |
| getPosByGeo: function (mapType, p) { |
| if (!this._mapDataMap[mapType].transform) { |
| return null; |
| } |
| var pos = this.geo2pos(mapType, p); |
| pos[0] += this._mapDataMap[mapType].transform.left; |
| pos[1] += this._mapDataMap[mapType].transform.top; |
| return pos; |
| }, |
| getMapPosition: function (mapType) { |
| if (!this._mapDataMap[mapType].transform) { |
| return null; |
| } |
| return [ |
| this._mapDataMap[mapType].transform.left, |
| this._mapDataMap[mapType].transform.top |
| ]; |
| }, |
| onbeforDispose: function () { |
| this._isAlive = false; |
| this.zr.un(zrConfig.EVENT.MOUSEWHEEL, this._onmousewheel); |
| this.zr.un(zrConfig.EVENT.MOUSEDOWN, this._onmousedown); |
| this.messageCenter.unbind(ecConfig.EVENT.ROAMCONTROLLER, this._onroamcontroller); |
| this.messageCenter.unbind(ecConfig.EVENT.DATA_RANGE_HOVERLINK, this._ondrhoverlink); |
| } |
| }; |
| zrUtil.inherits(Map, ChartBase); |
| zrUtil.inherits(Map, ComponentBase); |
| require('../chart').define('map', Map); |
| return Map; |
| });define('zrender/shape/Path', [ |
| 'require', |
| './Base', |
| './util/PathProxy', |
| '../tool/util' |
| ], function (require) { |
| var Base = require('./Base'); |
| var PathProxy = require('./util/PathProxy'); |
| var PathSegment = PathProxy.PathSegment; |
| var vMag = function (v) { |
| return Math.sqrt(v[0] * v[0] + v[1] * v[1]); |
| }; |
| var vRatio = function (u, v) { |
| return (u[0] * v[0] + u[1] * v[1]) / (vMag(u) * vMag(v)); |
| }; |
| var vAngle = function (u, v) { |
| return (u[0] * v[1] < u[1] * v[0] ? -1 : 1) * Math.acos(vRatio(u, v)); |
| }; |
| var Path = function (options) { |
| Base.call(this, options); |
| }; |
| Path.prototype = { |
| type: 'path', |
| buildPathArray: function (data, x, y) { |
| if (!data) { |
| return []; |
| } |
| x = x || 0; |
| y = y || 0; |
| var cs = data; |
| var cc = [ |
| 'm', |
| 'M', |
| 'l', |
| 'L', |
| 'v', |
| 'V', |
| 'h', |
| 'H', |
| 'z', |
| 'Z', |
| 'c', |
| 'C', |
| 'q', |
| 'Q', |
| 't', |
| 'T', |
| 's', |
| 'S', |
| 'a', |
| 'A' |
| ]; |
| cs = cs.replace(/-/g, ' -'); |
| cs = cs.replace(/ /g, ' '); |
| cs = cs.replace(/ /g, ','); |
| cs = cs.replace(/,,/g, ','); |
| var n; |
| for (n = 0; n < cc.length; n++) { |
| cs = cs.replace(new RegExp(cc[n], 'g'), '|' + cc[n]); |
| } |
| var arr = cs.split('|'); |
| var ca = []; |
| var cpx = 0; |
| var cpy = 0; |
| for (n = 1; n < arr.length; n++) { |
| var str = arr[n]; |
| var c = str.charAt(0); |
| str = str.slice(1); |
| str = str.replace(new RegExp('e,-', 'g'), 'e-'); |
| var p = str.split(','); |
| if (p.length > 0 && p[0] === '') { |
| p.shift(); |
| } |
| for (var i = 0; i < p.length; i++) { |
| p[i] = parseFloat(p[i]); |
| } |
| while (p.length > 0) { |
| if (isNaN(p[0])) { |
| break; |
| } |
| var cmd = null; |
| var points = []; |
| var ctlPtx; |
| var ctlPty; |
| var prevCmd; |
| var rx; |
| var ry; |
| var psi; |
| var fa; |
| var fs; |
| var x1 = cpx; |
| var y1 = cpy; |
| switch (c) { |
| case 'l': |
| cpx += p.shift(); |
| cpy += p.shift(); |
| cmd = 'L'; |
| points.push(cpx, cpy); |
| break; |
| case 'L': |
| cpx = p.shift(); |
| cpy = p.shift(); |
| points.push(cpx, cpy); |
| break; |
| case 'm': |
| cpx += p.shift(); |
| cpy += p.shift(); |
| cmd = 'M'; |
| points.push(cpx, cpy); |
| c = 'l'; |
| break; |
| case 'M': |
| cpx = p.shift(); |
| cpy = p.shift(); |
| cmd = 'M'; |
| points.push(cpx, cpy); |
| c = 'L'; |
| break; |
| case 'h': |
| cpx += p.shift(); |
| cmd = 'L'; |
| points.push(cpx, cpy); |
| break; |
| case 'H': |
| cpx = p.shift(); |
| cmd = 'L'; |
| points.push(cpx, cpy); |
| break; |
| case 'v': |
| cpy += p.shift(); |
| cmd = 'L'; |
| points.push(cpx, cpy); |
| break; |
| case 'V': |
| cpy = p.shift(); |
| cmd = 'L'; |
| points.push(cpx, cpy); |
| break; |
| case 'C': |
| points.push(p.shift(), p.shift(), p.shift(), p.shift()); |
| cpx = p.shift(); |
| cpy = p.shift(); |
| points.push(cpx, cpy); |
| break; |
| case 'c': |
| points.push(cpx + p.shift(), cpy + p.shift(), cpx + p.shift(), cpy + p.shift()); |
| cpx += p.shift(); |
| cpy += p.shift(); |
| cmd = 'C'; |
| points.push(cpx, cpy); |
| break; |
| case 'S': |
| ctlPtx = cpx; |
| ctlPty = cpy; |
| prevCmd = ca[ca.length - 1]; |
| if (prevCmd.command === 'C') { |
| ctlPtx = cpx + (cpx - prevCmd.points[2]); |
| ctlPty = cpy + (cpy - prevCmd.points[3]); |
| } |
| points.push(ctlPtx, ctlPty, p.shift(), p.shift()); |
| cpx = p.shift(); |
| cpy = p.shift(); |
| cmd = 'C'; |
| points.push(cpx, cpy); |
| break; |
| case 's': |
| ctlPtx = cpx, ctlPty = cpy; |
| prevCmd = ca[ca.length - 1]; |
| if (prevCmd.command === 'C') { |
| ctlPtx = cpx + (cpx - prevCmd.points[2]); |
| ctlPty = cpy + (cpy - prevCmd.points[3]); |
| } |
| points.push(ctlPtx, ctlPty, cpx + p.shift(), cpy + p.shift()); |
| cpx += p.shift(); |
| cpy += p.shift(); |
| cmd = 'C'; |
| points.push(cpx, cpy); |
| break; |
| case 'Q': |
| points.push(p.shift(), p.shift()); |
| cpx = p.shift(); |
| cpy = p.shift(); |
| points.push(cpx, cpy); |
| break; |
| case 'q': |
| points.push(cpx + p.shift(), cpy + p.shift()); |
| cpx += p.shift(); |
| cpy += p.shift(); |
| cmd = 'Q'; |
| points.push(cpx, cpy); |
| break; |
| case 'T': |
| ctlPtx = cpx, ctlPty = cpy; |
| prevCmd = ca[ca.length - 1]; |
| if (prevCmd.command === 'Q') { |
| ctlPtx = cpx + (cpx - prevCmd.points[0]); |
| ctlPty = cpy + (cpy - prevCmd.points[1]); |
| } |
| cpx = p.shift(); |
| cpy = p.shift(); |
| cmd = 'Q'; |
| points.push(ctlPtx, ctlPty, cpx, cpy); |
| break; |
| case 't': |
| ctlPtx = cpx, ctlPty = cpy; |
| prevCmd = ca[ca.length - 1]; |
| if (prevCmd.command === 'Q') { |
| ctlPtx = cpx + (cpx - prevCmd.points[0]); |
| ctlPty = cpy + (cpy - prevCmd.points[1]); |
| } |
| cpx += p.shift(); |
| cpy += p.shift(); |
| cmd = 'Q'; |
| points.push(ctlPtx, ctlPty, cpx, cpy); |
| break; |
| case 'A': |
| rx = p.shift(); |
| ry = p.shift(); |
| psi = p.shift(); |
| fa = p.shift(); |
| fs = p.shift(); |
| x1 = cpx, y1 = cpy; |
| cpx = p.shift(), cpy = p.shift(); |
| cmd = 'A'; |
| points = this._convertPoint(x1, y1, cpx, cpy, fa, fs, rx, ry, psi); |
| break; |
| case 'a': |
| rx = p.shift(); |
| ry = p.shift(); |
| psi = p.shift(); |
| fa = p.shift(); |
| fs = p.shift(); |
| x1 = cpx, y1 = cpy; |
| cpx += p.shift(); |
| cpy += p.shift(); |
| cmd = 'A'; |
| points = this._convertPoint(x1, y1, cpx, cpy, fa, fs, rx, ry, psi); |
| break; |
| } |
| for (var j = 0, l = points.length; j < l; j += 2) { |
| points[j] += x; |
| points[j + 1] += y; |
| } |
| ca.push(new PathSegment(cmd || c, points)); |
| } |
| if (c === 'z' || c === 'Z') { |
| ca.push(new PathSegment('z', [])); |
| } |
| } |
| return ca; |
| }, |
| _convertPoint: function (x1, y1, x2, y2, fa, fs, rx, ry, psiDeg) { |
| var psi = psiDeg * (Math.PI / 180); |
| var xp = Math.cos(psi) * (x1 - x2) / 2 + Math.sin(psi) * (y1 - y2) / 2; |
| var yp = -1 * Math.sin(psi) * (x1 - x2) / 2 + Math.cos(psi) * (y1 - y2) / 2; |
| var lambda = xp * xp / (rx * rx) + yp * yp / (ry * ry); |
| if (lambda > 1) { |
| rx *= Math.sqrt(lambda); |
| ry *= Math.sqrt(lambda); |
| } |
| var f = Math.sqrt((rx * rx * (ry * ry) - rx * rx * (yp * yp) - ry * ry * (xp * xp)) / (rx * rx * (yp * yp) + ry * ry * (xp * xp))); |
| if (fa === fs) { |
| f *= -1; |
| } |
| if (isNaN(f)) { |
| f = 0; |
| } |
| var cxp = f * rx * yp / ry; |
| var cyp = f * -ry * xp / rx; |
| var cx = (x1 + x2) / 2 + Math.cos(psi) * cxp - Math.sin(psi) * cyp; |
| var cy = (y1 + y2) / 2 + Math.sin(psi) * cxp + Math.cos(psi) * cyp; |
| var theta = vAngle([ |
| 1, |
| 0 |
| ], [ |
| (xp - cxp) / rx, |
| (yp - cyp) / ry |
| ]); |
| var u = [ |
| (xp - cxp) / rx, |
| (yp - cyp) / ry |
| ]; |
| var v = [ |
| (-1 * xp - cxp) / rx, |
| (-1 * yp - cyp) / ry |
| ]; |
| var dTheta = vAngle(u, v); |
| if (vRatio(u, v) <= -1) { |
| dTheta = Math.PI; |
| } |
| if (vRatio(u, v) >= 1) { |
| dTheta = 0; |
| } |
| if (fs === 0 && dTheta > 0) { |
| dTheta = dTheta - 2 * Math.PI; |
| } |
| if (fs === 1 && dTheta < 0) { |
| dTheta = dTheta + 2 * Math.PI; |
| } |
| return [ |
| cx, |
| cy, |
| rx, |
| ry, |
| theta, |
| dTheta, |
| psi, |
| fs |
| ]; |
| }, |
| buildPath: function (ctx, style) { |
| var path = style.path; |
| var x = style.x || 0; |
| var y = style.y || 0; |
| style.pathArray = style.pathArray || this.buildPathArray(path, x, y); |
| var pathArray = style.pathArray; |
| var pointList = style.pointList = []; |
| var singlePointList = []; |
| for (var i = 0, l = pathArray.length; i < l; i++) { |
| if (pathArray[i].command.toUpperCase() == 'M') { |
| singlePointList.length > 0 && pointList.push(singlePointList); |
| singlePointList = []; |
| } |
| var p = pathArray[i].points; |
| for (var j = 0, k = p.length; j < k; j += 2) { |
| singlePointList.push([ |
| p[j], |
| p[j + 1] |
| ]); |
| } |
| } |
| singlePointList.length > 0 && pointList.push(singlePointList); |
| for (var i = 0, l = pathArray.length; i < l; i++) { |
| var c = pathArray[i].command; |
| var p = pathArray[i].points; |
| switch (c) { |
| case 'L': |
| ctx.lineTo(p[0], p[1]); |
| break; |
| case 'M': |
| ctx.moveTo(p[0], p[1]); |
| break; |
| case 'C': |
| ctx.bezierCurveTo(p[0], p[1], p[2], p[3], p[4], p[5]); |
| break; |
| case 'Q': |
| ctx.quadraticCurveTo(p[0], p[1], p[2], p[3]); |
| break; |
| case 'A': |
| var cx = p[0]; |
| var cy = p[1]; |
| var rx = p[2]; |
| var ry = p[3]; |
| var theta = p[4]; |
| var dTheta = p[5]; |
| var psi = p[6]; |
| var fs = p[7]; |
| var r = rx > ry ? rx : ry; |
| var scaleX = rx > ry ? 1 : rx / ry; |
| var scaleY = rx > ry ? ry / rx : 1; |
| ctx.translate(cx, cy); |
| ctx.rotate(psi); |
| ctx.scale(scaleX, scaleY); |
| ctx.arc(0, 0, r, theta, theta + dTheta, 1 - fs); |
| ctx.scale(1 / scaleX, 1 / scaleY); |
| ctx.rotate(-psi); |
| ctx.translate(-cx, -cy); |
| break; |
| case 'z': |
| ctx.closePath(); |
| break; |
| } |
| } |
| return; |
| }, |
| getRect: function (style) { |
| if (style.__rect) { |
| return style.__rect; |
| } |
| var lineWidth; |
| if (style.brushType == 'stroke' || style.brushType == 'fill') { |
| lineWidth = style.lineWidth || 1; |
| } else { |
| lineWidth = 0; |
| } |
| var minX = Number.MAX_VALUE; |
| var maxX = Number.MIN_VALUE; |
| var minY = Number.MAX_VALUE; |
| var maxY = Number.MIN_VALUE; |
| var x = style.x || 0; |
| var y = style.y || 0; |
| var pathArray = style.pathArray || this.buildPathArray(style.path); |
| for (var i = 0; i < pathArray.length; i++) { |
| var p = pathArray[i].points; |
| for (var j = 0; j < p.length; j++) { |
| if (j % 2 === 0) { |
| if (p[j] + x < minX) { |
| minX = p[j]; |
| } |
| if (p[j] + x > maxX) { |
| maxX = p[j]; |
| } |
| } else { |
| if (p[j] + y < minY) { |
| minY = p[j]; |
| } |
| if (p[j] + y > maxY) { |
| maxY = p[j]; |
| } |
| } |
| } |
| } |
| var rect; |
| if (minX === Number.MAX_VALUE || maxX === Number.MIN_VALUE || minY === Number.MAX_VALUE || maxY === Number.MIN_VALUE) { |
| rect = { |
| x: 0, |
| y: 0, |
| width: 0, |
| height: 0 |
| }; |
| } else { |
| rect = { |
| x: Math.round(minX - lineWidth / 2), |
| y: Math.round(minY - lineWidth / 2), |
| width: maxX - minX + lineWidth, |
| height: maxY - minY + lineWidth |
| }; |
| } |
| style.__rect = rect; |
| return rect; |
| } |
| }; |
| require('../tool/util').inherits(Path, Base); |
| return Path; |
| });define('zrender/shape/Ellipse', [ |
| 'require', |
| './Base', |
| '../tool/util' |
| ], function (require) { |
| var Base = require('./Base'); |
| var Ellipse = function (options) { |
| Base.call(this, options); |
| }; |
| Ellipse.prototype = { |
| type: 'ellipse', |
| buildPath: function (ctx, style) { |
| var k = 0.5522848; |
| var x = style.x; |
| var y = style.y; |
| var a = style.a; |
| var b = style.b; |
| var ox = a * k; |
| var oy = b * k; |
| ctx.moveTo(x - a, y); |
| ctx.bezierCurveTo(x - a, y - oy, x - ox, y - b, x, y - b); |
| ctx.bezierCurveTo(x + ox, y - b, x + a, y - oy, x + a, y); |
| ctx.bezierCurveTo(x + a, y + oy, x + ox, y + b, x, y + b); |
| ctx.bezierCurveTo(x - ox, y + b, x - a, y + oy, x - a, y); |
| ctx.closePath(); |
| }, |
| getRect: function (style) { |
| if (style.__rect) { |
| return style.__rect; |
| } |
| var lineWidth; |
| if (style.brushType == 'stroke' || style.brushType == 'fill') { |
| lineWidth = style.lineWidth || 1; |
| } else { |
| lineWidth = 0; |
| } |
| style.__rect = { |
| x: Math.round(style.x - style.a - lineWidth / 2), |
| y: Math.round(style.y - style.b - lineWidth / 2), |
| width: style.a * 2 + lineWidth, |
| height: style.b * 2 + lineWidth |
| }; |
| return style.__rect; |
| } |
| }; |
| require('../tool/util').inherits(Ellipse, Base); |
| return Ellipse; |
| });define('echarts/component/roamController', [ |
| 'require', |
| './base', |
| 'zrender/shape/Rectangle', |
| 'zrender/shape/Sector', |
| 'zrender/shape/Circle', |
| '../config', |
| 'zrender/tool/util', |
| 'zrender/tool/color', |
| 'zrender/tool/event', |
| '../component' |
| ], function (require) { |
| var Base = require('./base'); |
| var RectangleShape = require('zrender/shape/Rectangle'); |
| var SectorShape = require('zrender/shape/Sector'); |
| var CircleShape = require('zrender/shape/Circle'); |
| var ecConfig = require('../config'); |
| var zrUtil = require('zrender/tool/util'); |
| var zrColor = require('zrender/tool/color'); |
| var zrEvent = require('zrender/tool/event'); |
| function RoamController(ecTheme, messageCenter, zr, option, myChart) { |
| if (!option.roamController || !option.roamController.show) { |
| return; |
| } |
| if (!option.roamController.mapTypeControl) { |
| console.error('option.roamController.mapTypeControl has not been defined.'); |
| return; |
| } |
| Base.call(this, ecTheme, messageCenter, zr, option, myChart); |
| this.rcOption = option.roamController; |
| var self = this; |
| this._drictionMouseDown = function (params) { |
| return self.__drictionMouseDown(params); |
| }; |
| this._drictionMouseUp = function (params) { |
| return self.__drictionMouseUp(params); |
| }; |
| this._drictionMouseMove = function (params) { |
| return self.__drictionMouseMove(params); |
| }; |
| this._drictionMouseOut = function (params) { |
| return self.__drictionMouseOut(params); |
| }; |
| this._scaleHandler = function (params) { |
| return self.__scaleHandler(params); |
| }; |
| this.refresh(option); |
| } |
| RoamController.prototype = { |
| type: ecConfig.COMPONENT_TYPE_ROAMCONTROLLER, |
| _buildShape: function () { |
| if (!this.rcOption.show) { |
| return; |
| } |
| this._itemGroupLocation = this._getItemGroupLocation(); |
| this._buildBackground(); |
| this._buildItem(); |
| for (var i = 0, l = this.shapeList.length; i < l; i++) { |
| this.zr.addShape(this.shapeList[i]); |
| } |
| }, |
| _buildItem: function () { |
| this.shapeList.push(this._getDirectionShape('up')); |
| this.shapeList.push(this._getDirectionShape('down')); |
| this.shapeList.push(this._getDirectionShape('left')); |
| this.shapeList.push(this._getDirectionShape('right')); |
| this.shapeList.push(this._getScaleShape('scaleUp')); |
| this.shapeList.push(this._getScaleShape('scaleDown')); |
| }, |
| _getDirectionShape: function (direction) { |
| var r = this._itemGroupLocation.r; |
| var x = this._itemGroupLocation.x + r; |
| var y = this._itemGroupLocation.y + r; |
| var sectorShape = { |
| zlevel: this._zlevelBase, |
| style: { |
| x: x, |
| y: y, |
| r: r, |
| startAngle: -45, |
| endAngle: 45, |
| color: this.rcOption.handleColor, |
| text: '>', |
| textX: x + r / 2 + 4, |
| textY: y - 0.5, |
| textAlign: 'center', |
| textBaseline: 'middle', |
| textPosition: 'specific', |
| textColor: this.rcOption.fillerColor, |
| textFont: Math.floor(r / 2) + 'px arial' |
| }, |
| highlightStyle: { |
| color: zrColor.lift(this.rcOption.handleColor, -0.2), |
| brushType: 'fill' |
| }, |
| clickable: true |
| }; |
| switch (direction) { |
| case 'up': |
| sectorShape.rotation = [ |
| Math.PI / 2, |
| x, |
| y |
| ]; |
| break; |
| case 'left': |
| sectorShape.rotation = [ |
| Math.PI, |
| x, |
| y |
| ]; |
| break; |
| case 'down': |
| sectorShape.rotation = [ |
| -Math.PI / 2, |
| x, |
| y |
| ]; |
| break; |
| } |
| sectorShape = new SectorShape(sectorShape); |
| sectorShape._roamType = direction; |
| sectorShape.onmousedown = this._drictionMouseDown; |
| sectorShape.onmouseup = this._drictionMouseUp; |
| sectorShape.onmousemove = this._drictionMouseMove; |
| sectorShape.onmouseout = this._drictionMouseOut; |
| return sectorShape; |
| }, |
| _getScaleShape: function (text) { |
| var width = this._itemGroupLocation.width; |
| var height = this._itemGroupLocation.height - width; |
| height = height < 0 ? 20 : height; |
| var r = Math.min(width / 2 - 5, height) / 2; |
| var x = this._itemGroupLocation.x + (text === 'scaleDown' ? width - r : r); |
| var y = this._itemGroupLocation.y + this._itemGroupLocation.height - r; |
| var scaleShape = { |
| zlevel: this._zlevelBase, |
| style: { |
| x: x, |
| y: y, |
| r: r, |
| color: this.rcOption.handleColor, |
| text: text === 'scaleDown' ? '-' : '+', |
| textX: x, |
| textY: y - 2, |
| textAlign: 'center', |
| textBaseline: 'middle', |
| textPosition: 'specific', |
| textColor: this.rcOption.fillerColor, |
| textFont: Math.floor(r) + 'px verdana' |
| }, |
| highlightStyle: { |
| color: zrColor.lift(this.rcOption.handleColor, -0.2), |
| brushType: 'fill' |
| }, |
| clickable: true |
| }; |
| scaleShape = new CircleShape(scaleShape); |
| scaleShape._roamType = text; |
| scaleShape.onmousedown = this._scaleHandler; |
| return scaleShape; |
| }, |
| _buildBackground: function () { |
| var padding = this.reformCssArray(this.rcOption.padding); |
| this.shapeList.push(new RectangleShape({ |
| zlevel: this._zlevelBase, |
| hoverable: false, |
| style: { |
| x: this._itemGroupLocation.x - padding[3], |
| y: this._itemGroupLocation.y - padding[0], |
| width: this._itemGroupLocation.width + padding[3] + padding[1], |
| height: this._itemGroupLocation.height + padding[0] + padding[2], |
| brushType: this.rcOption.borderWidth === 0 ? 'fill' : 'both', |
| color: this.rcOption.backgroundColor, |
| strokeColor: this.rcOption.borderColor, |
| lineWidth: this.rcOption.borderWidth |
| } |
| })); |
| }, |
| _getItemGroupLocation: function () { |
| var padding = this.reformCssArray(this.rcOption.padding); |
| var width = this.rcOption.width; |
| var height = this.rcOption.height; |
| var zrWidth = this.zr.getWidth(); |
| var zrHeight = this.zr.getHeight(); |
| var x; |
| switch (this.rcOption.x) { |
| case 'center': |
| x = Math.floor((zrWidth - width) / 2); |
| break; |
| case 'left': |
| x = padding[3] + this.rcOption.borderWidth; |
| break; |
| case 'right': |
| x = zrWidth - width - padding[1] - padding[3] - this.rcOption.borderWidth * 2; |
| break; |
| default: |
| x = this.parsePercent(this.rcOption.x, zrWidth); |
| break; |
| } |
| var y; |
| switch (this.rcOption.y) { |
| case 'top': |
| y = padding[0] + this.rcOption.borderWidth; |
| break; |
| case 'bottom': |
| y = zrHeight - height - padding[0] - padding[2] - this.rcOption.borderWidth * 2; |
| break; |
| case 'center': |
| y = Math.floor((zrHeight - height) / 2); |
| break; |
| default: |
| y = this.parsePercent(this.rcOption.y, zrHeight); |
| break; |
| } |
| return { |
| x: x, |
| y: y, |
| r: width / 2, |
| width: width, |
| height: height |
| }; |
| }, |
| __drictionMouseDown: function (params) { |
| this.mousedown = true; |
| this._drictionHandlerOn(params); |
| }, |
| __drictionMouseUp: function (params) { |
| this.mousedown = false; |
| this._drictionHandlerOff(params); |
| }, |
| __drictionMouseMove: function (params) { |
| if (this.mousedown) { |
| this._drictionHandlerOn(params); |
| } |
| }, |
| __drictionMouseOut: function (params) { |
| this._drictionHandlerOff(params); |
| }, |
| _drictionHandlerOn: function (params) { |
| this._dispatchEvent(params.event, params.target._roamType); |
| clearInterval(this.dircetionTimer); |
| var self = this; |
| this.dircetionTimer = setInterval(function () { |
| self._dispatchEvent(params.event, params.target._roamType); |
| }, 100); |
| zrEvent.stop(params.event); |
| }, |
| _drictionHandlerOff: function (params) { |
| clearInterval(this.dircetionTimer); |
| }, |
| __scaleHandler: function (params) { |
| this._dispatchEvent(params.event, params.target._roamType); |
| zrEvent.stop(params.event); |
| }, |
| _dispatchEvent: function (event, roamType) { |
| this.messageCenter.dispatch(ecConfig.EVENT.ROAMCONTROLLER, event, { |
| roamType: roamType, |
| mapTypeControl: this.rcOption.mapTypeControl, |
| step: this.rcOption.step |
| }, this.myChart); |
| }, |
| refresh: function (newOption) { |
| if (newOption) { |
| this.option = newOption || this.option; |
| this.option.roamController = this.reformOption(this.option.roamController); |
| this.rcOption = this.option.roamController; |
| } |
| this.clear(); |
| this._buildShape(); |
| } |
| }; |
| zrUtil.inherits(RoamController, Base); |
| require('../component').define('roamController', RoamController); |
| return RoamController; |
| });define('echarts/util/mapData/params', ['require'], function (require) { |
| function decode(json) { |
| if (!json.UTF8Encoding) { |
| return json; |
| } |
| var features = json.features; |
| for (var f = 0; f < features.length; f++) { |
| var feature = features[f]; |
| var coordinates = feature.geometry.coordinates; |
| var encodeOffsets = feature.geometry.encodeOffsets; |
| for (var c = 0; c < coordinates.length; c++) { |
| var coordinate = coordinates[c]; |
| if (feature.geometry.type === 'Polygon') { |
| coordinates[c] = decodePolygon(coordinate, encodeOffsets[c]); |
| } else if (feature.geometry.type === 'MultiPolygon') { |
| for (var c2 = 0; c2 < coordinate.length; c2++) { |
| var polygon = coordinate[c2]; |
| coordinate[c2] = decodePolygon(polygon, encodeOffsets[c][c2]); |
| } |
| } |
| } |
| } |
| json.UTF8Encoding = false; |
| return json; |
| } |
| function decodePolygon(coordinate, encodeOffsets) { |
| var result = []; |
| var prevX = encodeOffsets[0]; |
| var prevY = encodeOffsets[1]; |
| for (var i = 0; i < coordinate.length; i += 2) { |
| var x = coordinate.charCodeAt(i) - 64; |
| var y = coordinate.charCodeAt(i + 1) - 64; |
| x = x >> 1 ^ -(x & 1); |
| y = y >> 1 ^ -(y & 1); |
| x += prevX; |
| y += prevY; |
| prevX = x; |
| prevY = y; |
| result.push([ |
| x / 1024, |
| y / 1024 |
| ]); |
| } |
| return result; |
| } |
| var mapParams = { |
| 'none': { |
| getGeoJson: function (callback) { |
| callback({ |
| type: 'FeatureCollection', |
| features: [{ |
| type: 'Feature', |
| geometry: { |
| coordinates: [], |
| encodeOffsets: [], |
| type: 'Polygon' |
| }, |
| properties: {} |
| }] |
| }); |
| } |
| }, |
| 'world': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/world_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| }, |
| 'china': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/china_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| }, |
| '南海诸岛': { |
| textCoord: [ |
| 126, |
| 25 |
| ], |
| getPath: function (leftTop, scale) { |
| var pList = [ |
| [ |
| [ |
| 0, |
| 3.5 |
| ], |
| [ |
| 7, |
| 11.2 |
| ], |
| [ |
| 15, |
| 11.9 |
| ], |
| [ |
| 30, |
| 7 |
| ], |
| [ |
| 42, |
| 0.7 |
| ], |
| [ |
| 52, |
| 0.7 |
| ], |
| [ |
| 56, |
| 7.7 |
| ], |
| [ |
| 59, |
| 0.7 |
| ], |
| [ |
| 64, |
| 0.7 |
| ], |
| [ |
| 64, |
| 0 |
| ], |
| [ |
| 5, |
| 0 |
| ], |
| [ |
| 0, |
| 3.5 |
| ] |
| ], |
| [ |
| [ |
| 13, |
| 16.1 |
| ], |
| [ |
| 19, |
| 14.7 |
| ], |
| [ |
| 16, |
| 21.7 |
| ], |
| [ |
| 11, |
| 23.1 |
| ], |
| [ |
| 13, |
| 16.1 |
| ] |
| ], |
| [ |
| [ |
| 12, |
| 32.2 |
| ], |
| [ |
| 14, |
| 38.5 |
| ], |
| [ |
| 15, |
| 38.5 |
| ], |
| [ |
| 13, |
| 32.2 |
| ], |
| [ |
| 12, |
| 32.2 |
| ] |
| ], |
| [ |
| [ |
| 16, |
| 47.6 |
| ], |
| [ |
| 12, |
| 53.2 |
| ], |
| [ |
| 13, |
| 53.2 |
| ], |
| [ |
| 18, |
| 47.6 |
| ], |
| [ |
| 16, |
| 47.6 |
| ] |
| ], |
| [ |
| [ |
| 6, |
| 64.4 |
| ], |
| [ |
| 8, |
| 70 |
| ], |
| [ |
| 9, |
| 70 |
| ], |
| [ |
| 8, |
| 64.4 |
| ], |
| [ |
| 6, |
| 64.4 |
| ] |
| ], |
| [ |
| [ |
| 23, |
| 82.6 |
| ], |
| [ |
| 29, |
| 79.8 |
| ], |
| [ |
| 30, |
| 79.8 |
| ], |
| [ |
| 25, |
| 82.6 |
| ], |
| [ |
| 23, |
| 82.6 |
| ] |
| ], |
| [ |
| [ |
| 37, |
| 70.7 |
| ], |
| [ |
| 43, |
| 62.3 |
| ], |
| [ |
| 44, |
| 62.3 |
| ], |
| [ |
| 39, |
| 70.7 |
| ], |
| [ |
| 37, |
| 70.7 |
| ] |
| ], |
| [ |
| [ |
| 48, |
| 51.1 |
| ], |
| [ |
| 51, |
| 45.5 |
| ], |
| [ |
| 53, |
| 45.5 |
| ], |
| [ |
| 50, |
| 51.1 |
| ], |
| [ |
| 48, |
| 51.1 |
| ] |
| ], |
| [ |
| [ |
| 51, |
| 35 |
| ], |
| [ |
| 51, |
| 28.7 |
| ], |
| [ |
| 53, |
| 28.7 |
| ], |
| [ |
| 53, |
| 35 |
| ], |
| [ |
| 51, |
| 35 |
| ] |
| ], |
| [ |
| [ |
| 52, |
| 22.4 |
| ], |
| [ |
| 55, |
| 17.5 |
| ], |
| [ |
| 56, |
| 17.5 |
| ], |
| [ |
| 53, |
| 22.4 |
| ], |
| [ |
| 52, |
| 22.4 |
| ] |
| ], |
| [ |
| [ |
| 58, |
| 12.6 |
| ], |
| [ |
| 62, |
| 7 |
| ], |
| [ |
| 63, |
| 7 |
| ], |
| [ |
| 60, |
| 12.6 |
| ], |
| [ |
| 58, |
| 12.6 |
| ] |
| ], |
| [ |
| [ |
| 0, |
| 3.5 |
| ], |
| [ |
| 0, |
| 93.1 |
| ], |
| [ |
| 64, |
| 93.1 |
| ], |
| [ |
| 64, |
| 0 |
| ], |
| [ |
| 63, |
| 0 |
| ], |
| [ |
| 63, |
| 92.4 |
| ], |
| [ |
| 1, |
| 92.4 |
| ], |
| [ |
| 1, |
| 3.5 |
| ], |
| [ |
| 0, |
| 3.5 |
| ] |
| ] |
| ]; |
| var str = ''; |
| var left = leftTop[0]; |
| var top = leftTop[1]; |
| for (var i = 0, l = pList.length; i < l; i++) { |
| str += 'M ' + ((pList[i][0][0] * scale + left).toFixed(2) - 0) + ' ' + ((pList[i][0][1] * scale + top).toFixed(2) - 0) + ' '; |
| for (var j = 1, k = pList[i].length; j < k; j++) { |
| str += 'L ' + ((pList[i][j][0] * scale + left).toFixed(2) - 0) + ' ' + ((pList[i][j][1] * scale + top).toFixed(2) - 0) + ' '; |
| } |
| } |
| return str + ' Z'; |
| } |
| }, |
| '新疆': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/xin_jiang_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| }, |
| '西藏': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/xi_zang_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| }, |
| '内蒙古': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/nei_meng_gu_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| }, |
| '青海': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/qing_hai_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| }, |
| '四川': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/si_chuan_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| }, |
| '黑龙江': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/hei_long_jiang_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| }, |
| '甘肃': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/gan_su_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| }, |
| '云南': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/yun_nan_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| }, |
| '广西': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/guang_xi_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| }, |
| '湖南': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/hu_nan_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| }, |
| '陕西': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/shan_xi_1_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| }, |
| '广东': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/guang_dong_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| }, |
| '吉林': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/ji_lin_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| }, |
| '河北': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/he_bei_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| }, |
| '湖北': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/hu_bei_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| }, |
| '贵州': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/gui_zhou_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| }, |
| '山东': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/shan_dong_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| }, |
| '江西': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/jiang_xi_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| }, |
| '河南': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/he_nan_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| }, |
| '辽宁': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/liao_ning_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| }, |
| '山西': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/shan_xi_2_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| }, |
| '安徽': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/an_hui_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| }, |
| '福建': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/fu_jian_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| }, |
| '浙江': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/zhe_jiang_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| }, |
| '江苏': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/jiang_su_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| }, |
| '重庆': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/chong_qing_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| }, |
| '宁夏': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/ning_xia_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| }, |
| '海南': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/hai_nan_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| }, |
| '台湾': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/tai_wan_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| }, |
| '北京': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/bei_jing_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| }, |
| '天津': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/tian_jin_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| }, |
| '上海': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/shang_hai_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| }, |
| '香港': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/xiang_gang_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| }, |
| '澳门': { |
| getGeoJson: function (callback) { |
| require(['./geoJson/ao_men_geo'], function (md) { |
| callback(decode(md)); |
| }); |
| } |
| } |
| }; |
| return { |
| decode: decode, |
| params: mapParams |
| }; |
| });define('echarts/util/mapData/textFixed', [], function () { |
| return { |
| '广东': [ |
| 0, |
| -10 |
| ], |
| '香港': [ |
| 10, |
| 10 |
| ], |
| '澳门': [ |
| -10, |
| 18 |
| ], |
| '黑龙江': [ |
| 0, |
| 20 |
| ], |
| '天津': [ |
| 5, |
| 5 |
| ], |
| '深圳市': [ |
| -35, |
| 0 |
| ], |
| '红河哈尼族彝族自治州': [ |
| 0, |
| 20 |
| ], |
| '楚雄彝族自治州': [ |
| -5, |
| 15 |
| ], |
| '石河子市': [ |
| -5, |
| 5 |
| ], |
| '五家渠市': [ |
| 0, |
| -10 |
| ], |
| '昌吉回族自治州': [ |
| 10, |
| 10 |
| ], |
| '昌江黎族自治县': [ |
| 0, |
| 20 |
| ], |
| '陵水黎族自治县': [ |
| 0, |
| 20 |
| ], |
| '东方市': [ |
| 0, |
| 20 |
| ], |
| '渭南市': [ |
| 0, |
| 20 |
| ] |
| }; |
| });define('echarts/util/mapData/geoCoord', [], function () { |
| return { |
| 'Russia': [ |
| 100, |
| 60 |
| ], |
| 'United States of America': [ |
| -99, |
| 38 |
| ] |
| }; |
| });define('echarts/util/projection/svg', [ |
| 'require', |
| 'zrender/shape/Path' |
| ], function (require) { |
| var PathShape = require('zrender/shape/Path'); |
| function toFloat(str) { |
| return parseFloat(str || 0); |
| } |
| function getBbox(root) { |
| var svgNode = root.firstChild; |
| while (!(svgNode.nodeName.toLowerCase() == 'svg' && svgNode.nodeType == 1)) { |
| svgNode = svgNode.nextSibling; |
| } |
| var x = toFloat(svgNode.getAttribute('x')); |
| var y = toFloat(svgNode.getAttribute('y')); |
| var width = toFloat(svgNode.getAttribute('width')); |
| var height = toFloat(svgNode.getAttribute('height')); |
| return { |
| left: x, |
| top: y, |
| width: width, |
| height: height |
| }; |
| } |
| function geoJson2Path(root, transform) { |
| var scale = [ |
| transform.scale.x, |
| transform.scale.y |
| ]; |
| var elList = []; |
| function _getShape(root) { |
| var tagName = root.tagName; |
| if (shapeBuilders[tagName]) { |
| var obj = shapeBuilders[tagName](root, scale); |
| if (obj) { |
| obj.scale = scale; |
| obj.properties = { name: root.getAttribute('name') || '' }; |
| obj.id = root.id; |
| extendCommonAttributes(obj, root); |
| elList.push(obj); |
| } |
| } |
| var shapes = root.childNodes; |
| for (var i = 0, len = shapes.length; i < len; i++) { |
| _getShape(shapes[i]); |
| } |
| } |
| _getShape(root); |
| return elList; |
| } |
| function pos2geo(obj, p) { |
| var point = p instanceof Array ? [ |
| p[0] * 1, |
| p[1] * 1 |
| ] : [ |
| p.x * 1, |
| p.y * 1 |
| ]; |
| return [ |
| point[0] / obj.scale.x, |
| point[1] / obj.scale.y |
| ]; |
| } |
| function geo2pos(obj, p) { |
| var point = p instanceof Array ? [ |
| p[0] * 1, |
| p[1] * 1 |
| ] : [ |
| p.x * 1, |
| p.y * 1 |
| ]; |
| return [ |
| point[0] * obj.scale.x, |
| point[1] * obj.scale.y |
| ]; |
| } |
| function trim(str) { |
| return str.replace(/^\s\s*/, '').replace(/\s\s*$/, ''); |
| } |
| function extendCommonAttributes(obj, xmlNode) { |
| var color = xmlNode.getAttribute('fill'); |
| var strokeColor = xmlNode.getAttribute('stroke'); |
| var lineWidth = xmlNode.getAttribute('stroke-width'); |
| var opacity = xmlNode.getAttribute('opacity'); |
| if (color && color != 'none') { |
| obj.color = color; |
| if (strokeColor) { |
| obj.brushType = 'both'; |
| obj.strokeColor = strokeColor; |
| } else { |
| obj.brushType = 'fill'; |
| } |
| } else if (strokeColor && strokeColor != 'none') { |
| obj.strokeColor = strokeColor; |
| obj.brushType = 'stroke'; |
| } |
| if (lineWidth && lineWidth != 'none') { |
| obj.lineWidth = parseFloat(lineWidth); |
| } |
| if (opacity && opacity != 'none') { |
| obj.opacity = parseFloat(opacity); |
| } |
| } |
| function parsePoints(str) { |
| var list = trim(str).replace(/,/g, ' ').split(/\s+/); |
| var points = []; |
| for (var i = 0; i < list.length;) { |
| var x = parseFloat(list[i++]); |
| var y = parseFloat(list[i++]); |
| points.push([ |
| x, |
| y |
| ]); |
| } |
| return points; |
| } |
| var shapeBuilders = { |
| path: function (xmlNode, scale) { |
| var path = xmlNode.getAttribute('d'); |
| var rect = PathShape.prototype.getRect({ path: path }); |
| return { |
| shapeType: 'path', |
| path: path, |
| cp: [ |
| (rect.x + rect.width / 2) * scale[0], |
| (rect.y + rect.height / 2) * scale[1] |
| ] |
| }; |
| }, |
| rect: function (xmlNode, scale) { |
| var x = toFloat(xmlNode.getAttribute('x')); |
| var y = toFloat(xmlNode.getAttribute('y')); |
| var width = toFloat(xmlNode.getAttribute('width')); |
| var height = toFloat(xmlNode.getAttribute('height')); |
| return { |
| shapeType: 'rectangle', |
| x: x, |
| y: y, |
| width: width, |
| height: height, |
| cp: [ |
| (x + width / 2) * scale[0], |
| (y + height / 2) * scale[1] |
| ] |
| }; |
| }, |
| line: function (xmlNode, scale) { |
| var x1 = toFloat(xmlNode.getAttribute('x1')); |
| var y1 = toFloat(xmlNode.getAttribute('y1')); |
| var x2 = toFloat(xmlNode.getAttribute('x2')); |
| var y2 = toFloat(xmlNode.getAttribute('y2')); |
| return { |
| shapeType: 'line', |
| xStart: x1, |
| yStart: y1, |
| xEnd: x2, |
| yEnd: y2, |
| cp: [ |
| (x1 + x2) * 0.5 * scale[0], |
| (y1 + y2) * 0.5 * scale[1] |
| ] |
| }; |
| }, |
| circle: function (xmlNode, scale) { |
| var cx = toFloat(xmlNode.getAttribute('cx')); |
| var cy = toFloat(xmlNode.getAttribute('cy')); |
| var r = toFloat(xmlNode.getAttribute('r')); |
| return { |
| shapeType: 'circle', |
| x: cx, |
| y: cy, |
| r: r, |
| cp: [ |
| cx * scale[0], |
| cy * scale[1] |
| ] |
| }; |
| }, |
| ellipse: function (xmlNode, scale) { |
| var cx = parseFloat(xmlNode.getAttribute('cx') || 0); |
| var cy = parseFloat(xmlNode.getAttribute('cy') || 0); |
| var rx = parseFloat(xmlNode.getAttribute('rx') || 0); |
| var ry = parseFloat(xmlNode.getAttribute('ry') || 0); |
| return { |
| shapeType: 'ellipse', |
| x: cx, |
| y: cy, |
| a: rx, |
| b: ry, |
| cp: [ |
| cx * scale[0], |
| cy * scale[1] |
| ] |
| }; |
| }, |
| polygon: function (xmlNode, scale) { |
| var points = xmlNode.getAttribute('points'); |
| var min = [ |
| Infinity, |
| Infinity |
| ]; |
| var max = [ |
| -Infinity, |
| -Infinity |
| ]; |
| if (points) { |
| points = parsePoints(points); |
| for (var i = 0; i < points.length; i++) { |
| var p = points[i]; |
| min[0] = Math.min(p[0], min[0]); |
| min[1] = Math.min(p[1], min[1]); |
| max[0] = Math.max(p[0], max[0]); |
| max[1] = Math.max(p[1], max[1]); |
| } |
| return { |
| shapeType: 'polygon', |
| pointList: points, |
| cp: [ |
| (min[0] + max[0]) / 2 * scale[0], |
| (min[1] + max[1]) / 2 * scale[0] |
| ] |
| }; |
| } |
| }, |
| polyline: function (xmlNode, scale) { |
| var obj = shapeBuilders.polygon(xmlNode, scale); |
| return obj; |
| } |
| }; |
| return { |
| getBbox: getBbox, |
| geoJson2Path: geoJson2Path, |
| pos2geo: pos2geo, |
| geo2pos: geo2pos |
| }; |
| });define('echarts/util/projection/normal', [], function () { |
| function getBbox(json, specialArea) { |
| specialArea = specialArea || {}; |
| if (!json.srcSize) { |
| parseSrcSize(json, specialArea); |
| } |
| return json.srcSize; |
| } |
| function parseSrcSize(json, specialArea) { |
| specialArea = specialArea || {}; |
| convertorParse.xmin = 360; |
| convertorParse.xmax = -360; |
| convertorParse.ymin = 180; |
| convertorParse.ymax = -180; |
| var shapes = json.features; |
| var geometries; |
| var shape; |
| for (var i = 0, len = shapes.length; i < len; i++) { |
| shape = shapes[i]; |
| if (shape.properties.name && specialArea[shape.properties.name]) { |
| continue; |
| } |
| switch (shape.type) { |
| case 'Feature': |
| convertorParse[shape.geometry.type](shape.geometry.coordinates); |
| break; |
| case 'GeometryCollection': |
| geometries = shape.geometries; |
| for (var j = 0, len2 = geometries.length; j < len2; j++) { |
| convertorParse[geometries[j].type](geometries[j].coordinates); |
| } |
| break; |
| } |
| } |
| json.srcSize = { |
| left: convertorParse.xmin.toFixed(4) * 1, |
| top: convertorParse.ymin.toFixed(4) * 1, |
| width: (convertorParse.xmax - convertorParse.xmin).toFixed(4) * 1, |
| height: (convertorParse.ymax - convertorParse.ymin).toFixed(4) * 1 |
| }; |
| return json; |
| } |
| var convertor = { |
| formatPoint: function (p) { |
| return [ |
| (p[0] < -168.5 && p[1] > 63.8 ? p[0] + 360 : p[0]) + 168.5, |
| 90 - p[1] |
| ]; |
| }, |
| makePoint: function (p) { |
| var self = this; |
| var point = self.formatPoint(p); |
| if (self._bbox.xmin > p[0]) { |
| self._bbox.xmin = p[0]; |
| } |
| if (self._bbox.xmax < p[0]) { |
| self._bbox.xmax = p[0]; |
| } |
| if (self._bbox.ymin > p[1]) { |
| self._bbox.ymin = p[1]; |
| } |
| if (self._bbox.ymax < p[1]) { |
| self._bbox.ymax = p[1]; |
| } |
| var x = (point[0] - convertor.offset.x) * convertor.scale.x + convertor.offset.left; |
| var y = (point[1] - convertor.offset.y) * convertor.scale.y + convertor.offset.top; |
| return [ |
| x, |
| y |
| ]; |
| }, |
| Point: function (coordinates) { |
| coordinates = this.makePoint(coordinates); |
| return coordinates.join(','); |
| }, |
| LineString: function (coordinates) { |
| var str = ''; |
| var point; |
| for (var i = 0, len = coordinates.length; i < len; i++) { |
| point = convertor.makePoint(coordinates[i]); |
| if (i === 0) { |
| str = 'M' + point.join(','); |
| } else { |
| str = str + 'L' + point.join(','); |
| } |
| } |
| return str; |
| }, |
| Polygon: function (coordinates) { |
| var str = ''; |
| for (var i = 0, len = coordinates.length; i < len; i++) { |
| str = str + convertor.LineString(coordinates[i]) + 'z'; |
| } |
| return str; |
| }, |
| MultiPoint: function (coordinates) { |
| var arr = []; |
| for (var i = 0, len = coordinates.length; i < len; i++) { |
| arr.push(convertor.Point(coordinates[i])); |
| } |
| return arr; |
| }, |
| MultiLineString: function (coordinates) { |
| var str = ''; |
| for (var i = 0, len = coordinates.length; i < len; i++) { |
| str += convertor.LineString(coordinates[i]); |
| } |
| return str; |
| }, |
| MultiPolygon: function (coordinates) { |
| var str = ''; |
| for (var i = 0, len = coordinates.length; i < len; i++) { |
| str += convertor.Polygon(coordinates[i]); |
| } |
| return str; |
| } |
| }; |
| var convertorParse = { |
| formatPoint: convertor.formatPoint, |
| makePoint: function (p) { |
| var self = this; |
| var point = self.formatPoint(p); |
| var x = point[0]; |
| var y = point[1]; |
| if (self.xmin > x) { |
| self.xmin = x; |
| } |
| if (self.xmax < x) { |
| self.xmax = x; |
| } |
| if (self.ymin > y) { |
| self.ymin = y; |
| } |
| if (self.ymax < y) { |
| self.ymax = y; |
| } |
| }, |
| Point: function (coordinates) { |
| this.makePoint(coordinates); |
| }, |
| LineString: function (coordinates) { |
| for (var i = 0, len = coordinates.length; i < len; i++) { |
| this.makePoint(coordinates[i]); |
| } |
| }, |
| Polygon: function (coordinates) { |
| for (var i = 0, len = coordinates.length; i < len; i++) { |
| this.LineString(coordinates[i]); |
| } |
| }, |
| MultiPoint: function (coordinates) { |
| for (var i = 0, len = coordinates.length; i < len; i++) { |
| this.Point(coordinates[i]); |
| } |
| }, |
| MultiLineString: function (coordinates) { |
| for (var i = 0, len = coordinates.length; i < len; i++) { |
| this.LineString(coordinates[i]); |
| } |
| }, |
| MultiPolygon: function (coordinates) { |
| for (var i = 0, len = coordinates.length; i < len; i++) { |
| this.Polygon(coordinates[i]); |
| } |
| } |
| }; |
| function geoJson2Path(json, transform, specialArea) { |
| specialArea = specialArea || {}; |
| convertor.scale = null; |
| convertor.offset = null; |
| if (!json.srcSize) { |
| parseSrcSize(json, specialArea); |
| } |
| transform.offset = { |
| x: json.srcSize.left, |
| y: json.srcSize.top, |
| left: transform.OffsetLeft || 0, |
| top: transform.OffsetTop || 0 |
| }; |
| convertor.scale = transform.scale; |
| convertor.offset = transform.offset; |
| var shapes = json.features; |
| var geometries; |
| var pathArray = []; |
| var val; |
| var shape; |
| for (var i = 0, len = shapes.length; i < len; i++) { |
| shape = shapes[i]; |
| if (shape.properties.name && specialArea[shape.properties.name]) { |
| continue; |
| } |
| if (shape.type == 'Feature') { |
| pushApath(shape.geometry, shape); |
| } else if (shape.type == 'GeometryCollection') { |
| geometries = shape.geometries; |
| for (var j = 0, len2 = geometries.length; j < len2; j++) { |
| val = geometries[j]; |
| pushApath(val, val); |
| } |
| } |
| } |
| var shapeType; |
| var shapeCoordinates; |
| var str; |
| function pushApath(gm, shape) { |
| shapeType = gm.type; |
| shapeCoordinates = gm.coordinates; |
| convertor._bbox = { |
| xmin: 360, |
| xmax: -360, |
| ymin: 180, |
| ymax: -180 |
| }; |
| str = convertor[shapeType](shapeCoordinates); |
| pathArray.push({ |
| path: str, |
| cp: shape.properties.cp ? convertor.makePoint(shape.properties.cp) : convertor.makePoint([ |
| (convertor._bbox.xmin + convertor._bbox.xmax) / 2, |
| (convertor._bbox.ymin + convertor._bbox.ymax) / 2 |
| ]), |
| properties: shape.properties, |
| id: shape.id |
| }); |
| } |
| return pathArray; |
| } |
| function pos2geo(obj, p) { |
| var x; |
| var y; |
| if (p instanceof Array) { |
| x = p[0] * 1; |
| y = p[1] * 1; |
| } else { |
| x = p.x * 1; |
| y = p.y * 1; |
| } |
| x = x / obj.scale.x + obj.offset.x - 168.5; |
| x = x > 180 ? x - 360 : x; |
| y = 90 - (y / obj.scale.y + obj.offset.y); |
| return [ |
| x, |
| y |
| ]; |
| } |
| function geo2pos(obj, p) { |
| convertor.offset = obj.offset; |
| convertor.scale = obj.scale; |
| return p instanceof Array ? convertor.makePoint([ |
| p[0] * 1, |
| p[1] * 1 |
| ]) : convertor.makePoint([ |
| p.x * 1, |
| p.y * 1 |
| ]); |
| } |
| return { |
| getBbox: getBbox, |
| geoJson2Path: geoJson2Path, |
| pos2geo: pos2geo, |
| geo2pos: geo2pos |
| }; |
| });define('echarts/util/mapData/geoJson/an_hui_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [ |
| { |
| 'type': 'Feature', |
| 'id': '3415', |
| 'properties': { |
| 'name': '六安市', |
| 'cp': [ |
| 116.3123, |
| 31.8329 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@nJUXUV°UÑnU@mlLVaVln@@bn@VU@xlb@lLnKlVIJUVxnI@lVL@b°VX@bxnVVUnVVnU@kX@VwV@al¥UUnUWa@@wĸULU¥lKUa@aUI@alLVaU¯anWkUKm@XV@VaXlW@aU_UWVUI¯@ma¯W¯I@UU@WWU@U@@UU@VkV@@WUUm@UaU@lK@IUKL@KWmXUWaXI@@a@a@U@U@KV¥lwk°b²JVIVKlV@UXlaUl`UVLVVVUJU@Lnm@_VK@KUIW@J@Xk@WW@UmmXmWk@kK@aUUVmmkUwUmWL@WmU@UJmUULkKWakLWVkIlwULW@X°lUJ@°ULWVwmJ@bmb¯Vkm@@WkWm¯wL@lkXWmXym¯UImJUbkV@Vn¯@V@lUb@mk@maUxmlUbULWn@JLmKUkWKkwUKbmXWxkVUKmLkVV@JUUWL@xkJUUV@X@VVlUbVX@xk¤x¼xWxnnn@Þ¼JVb°aVn@mlnXUJlbVlkz@lUlXJmxVxXnWxXÈWlU@UxU@VX@xUL@UÆmLnV@lWXk@@JlbXblnlJ'], |
| 'encodeOffsets': [[ |
| 118710, |
| 33351 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3408', |
| 'properties': { |
| 'name': '安庆市', |
| 'cp': [ |
| 116.7517, |
| 30.5255 |
| ], |
| 'childNum': 9 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@n°znWXlW@kK°xXnl@Xn@l°Una@anIxXUVK@¯VIkW¯X@VKxklJXUlKXblLVKnVVIV@Xn@XKVnVxlnnUlmV@²óUkVlWbln@VVVIn@lw@WVIXblV@ÈxaUaVIVVnKVLKln@b²K@»U£ÑķġÝÅbKa@Im@Û@kWÓkkmKÅnóJUÅ£W@wĕ@wĉţ¯¯UkK±l¯U¥UÑkÝUķ»Ý¥¯JIUVbUl¯ÈV¼VJU¼Vb@bkLUl@VJ@bUXÇ@lkVmXmKkLVxVL@VkVVVlzWkbmLUUUbVbUVlÒnJlUnLllUL@bUVxlLXVƦÈVU¦WJ'], |
| 'encodeOffsets': [[ |
| 118834, |
| 31759 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3411', |
| 'properties': { |
| 'name': '滁州市', |
| 'cp': [ |
| 118.1909, |
| 32.536 |
| ], |
| 'childNum': 7 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@`nnl@xK@X°KXVIXVlbXVWnXlL@È»LVan@VJêVVn@X@laÞbVayn@_xnWVXnWl@VnUVkI@lnXKVLVV@V@kW@LlVô@J@bVnnKnkVa@»lç@nwKmaUUUVÑ@nmWXalI@alVn@VwUaVU@nlaôJnUVVXlJaXXVK@UV@VWx@nXVWXVUlLUbVULVVnUVbUbVb@@aKÆnnKVK@U@UU@@a@V°¯ÈJVIlķ@aaUaVKU_@mkxUI@aUlyU@@wkKWmUbUnUVWbkJW_J@bn@Vm@@KULk@V@@bVbÅm@LW@UVVbkK@UkKWL@VULUKWIUJUbkK@_WVXUJka@XVa@ky@aVIUUW@@mUlLKWÑUKVan@UkVmmIXKaVaUwVU@UmykU¯@±UUL@WUIVUU@KkIWaaU@kUUaÇUó»mKk¯@y@kWK@bkI¯`mnl¯XWlkVUzUJlbUbVJl@nnm@VULV`XnWÆbmUUnJmUknJ¯km@yk@kUxL@VUbmnn¤lX@`z@JmaULUVl@Xn@xllkXWaaW@UVmUb@mVXWxXbWbUÒnVVnVVUL'], |
| 'encodeOffsets': [[ |
| 120004, |
| 33520 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3418', |
| 'properties': { |
| 'name': '宣城市', |
| 'cp': [ |
| 118.8062, |
| 30.6244 |
| ], |
| 'childNum': 7 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Vb@XLJXxlIXxlVlV@I²¤nlUnVU@VULWVUJ@Lnb@lV@UnV@@VVVlLnbnJUVkUUVWn@@anUVnVJVIV@@nUJVbUb@VUbVK@bn@VbnIlxkllXVlXKWUXUlL°¤UVVb@bUlkXWxXz@IlaUlnUlJVInVÆJULVUnVK°@VnlVnxV@XLlK@wVL@KnUlJXUbnKVLXlUw@VWlLXKm@@a@VLnmlIVVnKn@kVaVlwk@@a@k@VIUa@maUa@wna@kmWUUmVUIVÇ@aKmakUJ@InmUUaVaklX@Vk@m@VU@wnK@alKVUkUkKbmUkm@U£WVk@@UÝbbaÇx@b@WVUa¯@wVwUUV@VwnK@KWaÅ@KIUyUI@WmXóUbWaKm@km@IUyIUaWKx@zUKUL@llVUnkLVVkJWX@VUKUVIkVWakb@VWb@n@JkXUlmL@xkL@`VxLUÈUJ@Vm@@bmIUlUL@VUVVbknm@mKUwKVÈ@J@LV±kkJUIl'], |
| 'encodeOffsets': [[ |
| 120803, |
| 31247 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3412', |
| 'properties': { |
| 'name': '阜阳市', |
| 'cp': [ |
| 115.7629, |
| 32.9919 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Vn@ak°a±@¥@UUI@aUmlwUUxb@¥XU@mmI@a@Kn@@_W@@WI@mUVVXUl@XaV@K@I@aLX@aVI°K@KVLUUwyXkK@kKÆbXnlK@k@aJlU@w@U@»@aXKWn_JXkVKn@°LlKXW@¯U@aUK@kmJUwVIUJkmLK@kka@wUVm@@am@UkUbkK@nmVÒ¯VUWVVmIULk@ma@kkK@nUbUamU`UUVUkKVkkW@@bkmnmUXVKXVL@VbUmbVXJ@nmKÅI@KWKUXVJUL@VUKUX@KUKWL@LUJmaXXm@kVVV@L@VUL@VlK@L@V@LUK@VUb@UUU@°@nVxU`Lkn@`@XVJ@XVmk@UKmV¯LVVn±Wm@Ub@JlLUl@VLk@lmVVn@bnV@V°IVaVJXI°K°V@XXVlVVUnKVlUbWXnV@bV`U@@m@@@nxmn@bXVlL@¤nbUl¦VVUnJVUVl@@bÞL'], |
| 'encodeOffsets': [[ |
| 118418, |
| 34392 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3413', |
| 'properties': { |
| 'name': '宿州市', |
| 'cp': [ |
| 117.5208, |
| 33.6841 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@UWU@bkW@aWU@aUIkWVlLXblVIUVV@mn@V_n@VaUK@I@UaanJVU@lVUVnnKVVlaUaI@wnKLnll@nVlk@wVKXkl@@bbUJ@VU@UUUyVk@aVUXwlWXXWU¹@aU@WUI@mlUnJ@Il@aXbV@VKl@XxVL@WIJlb@al@IUUm@@aVK@¥¯@mUķ¯bWk£Vm@akm@VaÅ@UVWa@UJWkJUbWbU@UlXk@amV@K¯nk@lU@Uxmz@bU`ÇbUbÅVm£U@Wwx@akLUK@UlakwUJWVkLmaUal@n_mVUnKVUUmÅXWa@kJmx@XUJ@bVLXxl@VVUVVUbkLWbU@@lUVVVVXK@XkJ@nU@@bV@VxUVlbU@xXLWn@UxVbVĊV@b@XV`mnkJ@kUKmbaU@VbnbÆx@XU@@`k@@bl@@bkL@WakXWaU@Vmkx@XWW@@wUUUbJU¯V@¯ÞU@WxXlL@bkb@lVlnbJW@kkU@mbkaWJIVlmz¯`UnU@mb@@`@bkVlnV@b@V@aVxn@VxKXnl@nbVKbVK@a_V@Vw@WLlwnK@UmIU@VW@UÈ@lKnalw@@V°@aUmlUUw@V@@UXK'], |
| 'encodeOffsets': [[ |
| 119836, |
| 35061 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3410', |
| 'properties': { |
| 'name': '黄山市', |
| 'cp': [ |
| 118.0481, |
| 29.9542 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lXnlWX@VUJVnUJVzXJVxkVJlI²lU@K@IUÇLVxnLn@lmUaVU@UVKVknJ@an@@UVIVÇKUw@_lK@wnKVklW@I@mXa@UlaXblUJVUVL@UXWlIUUlKVmkU@kVKVL@ywXLVbJVz@Jln@nLXbVaônW@la@UVWUa@@a@mk@WIk@VwUa¯¥m@UUVK@ImK@aX£kKÅVa_@±akXWWLnU@@a@¯mK@LJUWwUVVmbXX@lWLn`mzUJUbLk@makVWmkXambkKkna@ab@U@Unm@WV@VbUbUJWIk@@lmL@°UVUVmn@@kmWkb@x_m@@aU@b@JlUzlWxXn@b²@l`IVlUlL@VKnVbUl@VlIn@@bbVWUk@@bX@Valb@bnb°Vn@xVKlbVnV@VxL@ln@UXVVL'], |
| 'encodeOffsets': [[ |
| 120747, |
| 31095 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3414', |
| 'properties': { |
| 'name': '巢湖市', |
| 'cp': [ |
| 117.7734, |
| 31.4978 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VV@blL@XlWnnn@VXXl@@WIX@VJ@LxŎxln@bXJVblX@VVbUVn@VbUVlb@LnJVbVLVXLÒVLÒVbVIVylUXk°Wknm°_lJ@aXL@lz°@lnLô¼VÈVUUaVKU@WW@@UUa@knmVLlaV@a@kak±@UmwkKmkljÝUUkL@mlIVmnÝWkkUÝ@KƑĉa@»mma@mX¤¯Uw@@UU@bU±±L@akmLUKmLUUUJVbbÇw@kUWaUJ@Xkxm@UJUUm@kakXUVl±ôU@kn'], |
| 'encodeOffsets': [[ |
| 119847, |
| 32007 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3416', |
| 'properties': { |
| 'name': '亳州市', |
| 'cp': [ |
| 116.1914, |
| 33.4698 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lU@Un@@anUlw@KVmUwlaX_lKna@KU@@kWKUU@ankWXK@@V²VVIÈU@al@VaÈamK@wU@klaUV@XVUU»WUUbkmUkVmk@aÈw@mWU@VkIkVWKUÑķXȭºU¯l@kkLWmÅaL@lLWlzVxVUK@L¯LUJ@bWK@b@JLU@Wbk@WVUUV@nJ@XX@@`m@@L@bnJ@nWV@¦awVVkxVn@bVJ@V¦@²¯blb@mUU@¼¦XbUV`@nnxUxWLkUkVWKkV@XV@@VVL@VX@lVV@L@blL@`L@xXKVL@VnU@lwnU@ml@XnV@@UVW°LnalUI@aUK@aa@UkXW@I@mWL@UXK@UVW@U@@kWn@@V@XblaVxL@bVKXbIlJ'], |
| 'encodeOffsets': [[ |
| 119183, |
| 34594 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3417', |
| 'properties': { |
| 'name': '池州市', |
| 'cp': [ |
| 117.3889, |
| 30.2014 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': [ |
| '@@V°°ĊŤ@xĖ@xXƤVôIÆmnLllXÔ@lÜn@@JbLÆaĢÞĸ°VVUUKVanK@UV@VLVVnln@xnklxXamk@WV@Xa@naVkKlk@mkUWwkJWwIWK@UaUwWIUyVIUmVI@UXWmkkWKUUVWm@@kKw@UUUmkaULwm@¯Uma@akaUbW@@a@VlUXa@am@kJ@UVkUamL@UkKVUkJk_±@a@WmXwÇkkaVaUa±wV@VkwnyUaW@UU¯amLk@m@kmmU¯K@L@lUX¯WlkXVbbVUL@J@LVKnlJXnlb@`nXlalV@bnL@Vnb¼@lXbWlkLK@zUJmIUxUVUVmX', |
| '@@llUL@VlxL@a@UwXa¯@' |
| ], |
| 'encodeOffsets': [ |
| [ |
| 119543, |
| 30781 |
| ], |
| [ |
| 120061, |
| 31152 |
| ] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3401', |
| 'properties': { |
| 'name': '合肥市', |
| 'cp': [ |
| 117.29, |
| 32.0581 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@LxVĊLÞkVlVVXaWaXwWnU@anVVUX@bXblWkk@wWmk@VUVKnb@Iy@_kWm£nmVa@UKwlVl@zn@°lIlmnVIVmnVaXÅWmU_VK@Unmmk@UIVakaaUÑUKÑWKUUKUamI@KkaVUUam@VUUa@UkWUaWI@akmōwwUL@`mn@KVIUVUUUKVk_VkbW@VkUULUJ±I¯alkxU¦@L@V@V@b@b@WJXbWVXn@LKVL@JkLV@Vbn@VV@XU@UlV@@VV@V@XXV@@VJ°°Xnb°@JUVVXV`@bkXWUbU@Wn@VLXlm°bVUbkK@bVJ@bVbkLV¦KķV@x@XbmVVVk¦'], |
| 'encodeOffsets': [[ |
| 119678, |
| 33323 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3403', |
| 'properties': { |
| 'name': '蚌埠市', |
| 'cp': [ |
| 117.4109, |
| 33.1073 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VÒXLlUlJ@UXV@nÇx@bnlUVllnVaXVV¼UVWU@V²wVV@Vl@VnwlI@XbÆWVnUVmLUVnm`k@VbnblKXUVIlxkb@VVLlK@bwXxV@n¤ÆUVaÈaV_@anyVwV@kl@°m@LnUbl@WVkV@XaaVIXlIV@XbVUÆ@XKWwUkmW@_UmnIlJXkWKXmV@w@_XV@Kl@kU@KlX@@UUUUKWLm@klJVUUmk@mXUWmXw`m@zUbÝakbW@m@UUéUIm@UbKǼ@kKWXmWUkaWUJWU¯L@WLwk@mm@_ÅlUVkmWUnV@VWLUbbƑĬ¯l'], |
| 'encodeOffsets': [[ |
| 119543, |
| 33722 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3402', |
| 'properties': { |
| 'name': '芜湖市', |
| 'cp': [ |
| 118.3557, |
| 31.0858 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@bVaV@XllLXU°lL@V@VUnVl¯IkVUVU@@b@lUXUWmbn@¼bƒĊLÞ@lVXlmÞUnkJ@nlKVVÞXklWVaVI@aUKn»lL@Kn@XXwlm@mn°@V@WywXlWVk@aUaVU¯£kKWVXVWLUkkWlkkwmJUam@@aULVa@UVaUaVI@m@UUJUIUmmV@bm@UXVVUlVmImakKUU@UU@VmU@@kma@KVIXUVK@UVmUkVm±£@JkU@nlkLUlmb@WbU@@XnlWb'], |
| 'encodeOffsets': [[ |
| 120814, |
| 31585 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3406', |
| 'properties': { |
| 'name': '淮北市', |
| 'cp': [ |
| 116.6968, |
| 33.6896 |
| ], |
| 'childNum': 3 |
| }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@lnnK@¦n@@VV@@VV@nIVV@VW²a@b@bVnUVVV@Vz@l@°UVIVaVV@x@XX@WlwUnV@XblWb@XlK@a@k@al@@_V@@WÅwmaUaV@bnaVL@llInmU_@W@aUUĉUaVwm@XWK@wVkaVUUwU@@aV@@mlI@WLWUUUVU@kV@XalKVaUVUUUk@WwUK@aVI@WUk@@UUU±xkb@lV@xnLÇbUbk@@bÇVUJ±U@U@WLXml@bVVXL@lV@@LmbkLW`kbVxUn@LkxmV@bm@@VkV'], |
| ['@@VVVkV@¥@UV@U@VUUJkWakKUlXVJ@bXV@blX@aXV@V'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| 119183, |
| 34594 |
| ]], |
| [[ |
| 119836, |
| 35061 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3404', |
| 'properties': { |
| 'name': '淮南市', |
| 'cp': [ |
| 116.7847, |
| 32.7722 |
| ], |
| 'childNum': 2 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@°kƒīaVaXK@UUVmnXUlVÆkVKUUUmmUÑkUUÝlĉKUwKbU@UxW@@lmVUUVmUUmwaWkL¯K@mULWlIm`XWL@b@¼@V@xkVI@b@l@lkV°Ȯ¹ĸW'], |
| 'encodeOffsets': [[ |
| 119543, |
| 33722 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3405', |
| 'properties': { |
| 'name': '马鞍山市', |
| 'cp': [ |
| 118.6304, |
| 31.5363 |
| ], |
| 'childNum': 2 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@NJnllLnxV@laXLVKmaaXbVIbVKVVVIVyn@n_W@@UnJlUVVXlLnaUWlV@VVIXW@_W@XK@K@UVUUwVamÑXmmwwKUnUKçU@JU¯@m@nknWxWm@@LkKm¼VL@bUJUbkXWl'], |
| 'encodeOffsets': [[ |
| 121219, |
| 32288 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3407', |
| 'properties': { |
| 'name': '铜陵市', |
| 'cp': [ |
| 117.9382, |
| 30.9375 |
| ], |
| 'childNum': 3 |
| }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@ÒV¤@¼V²@aVV@@x°V£nW@nbnaVXVW@k@aV@VUUl°JUkVm@U@UkK¯WVkKWkU@Ubakwmlwm@kUmUUKU@@VmLUbVLUV¯U'], |
| ['@@LllUL@VlxL@a@UwXamK'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| 120522, |
| 31529 |
| ]], |
| [[ |
| 120094, |
| 31146 |
| ]] |
| ] |
| } |
| } |
| ], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/util/mapData/geoJson/ao_men_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [{ |
| 'type': 'Feature', |
| 'id': '8200', |
| 'properties': { |
| 'name': '澳门', |
| 'cp': [ |
| 113.5715, |
| 22.1583 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@HQFMDIDGBI@E@EEKEGCEIGGEKEMGSEU@CBEDAJAP@F@LBT@JCHMPOdADCFADAB@LFLDFFP@DAB@@AF@D@B@@FBD@FADHBBHAD@FAJ@JEDCJI`gFIJW'], |
| 'encodeOffsets': [[ |
| 116325, |
| 22699 |
| ]] |
| } |
| }], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/util/mapData/geoJson/bei_jing_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [ |
| { |
| 'type': 'Feature', |
| 'id': '110228', |
| 'properties': { |
| 'name': '密云县', |
| 'cp': [ |
| 117.0923, |
| 40.5121 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@vIHZDZQtDLNMXIbHRCXXITbJ@H`LGPRDDJNCLHTOCWFGvGBUJMKGFO^IHWXITQCIY^AXGfRDXF`DJOLB~G\\DZIHHpErUVMhHb]\\MBVF@FTP`@zTbD\\@~M\\K`H^EVODWICAakAQXoIcCOCIgGYNWFWNGGKKGaJEGMEIKYJUT_J_Go@_SyQaSFMEGTcYOQLIIi@EKAUPCV[EEXQCW|aMUMAaYCYNIDGGACIMGGSKDQGaF_C[GaB@GOIiOKAYLmI@CN]F[SWWAcKKI@HMUimEKbeYQYISNUOcBKPIFBNgvDPGZYFSf]CMSIWGEUFgDIQ[MeDMJS@RR@LphFPCHaBAJKF@J]IBJO@HlO@@RKAMPJHCNDJTHFP@ZGNANBRFH@J_fM^ONJNF\\VTDJHDON@XRND\\XRCPVETCLBVKDFJINHRGPRV@\\CLJN@VbXbLVT'], |
| 'encodeOffsets': [[ |
| 119561, |
| 41684 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '110116', |
| 'properties': { |
| 'name': '怀柔区', |
| 'cp': [ |
| 116.6377, |
| 40.6219 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@JHTVHXCHPfnDJGHNDJSB[JSBGVSAOH@PMPuDEHHXZN@PHF@ZLJ@LHVYJA\\OFWP]BMtMBSRGV[JeVAPQVIFENMD¡@^NV\\JH@NNL@NM\\kTQ\\I^FNIpBHGTBFFAZQfKDIXQTLXFXNNVMVHRGpCFLlRLEVBBH`IVO\\G`RDPAXLXBXORHZEHTDLLN@VGTMrQNFPeASKG@GMOAKBYMK@GTUHUXSHMVDNMOUEOZMJML@^KRACMZEZMRQLUHE@OFENPR@DI\\ChMHIDG\\GJMDWHCKGMDCIQCHO_K@GaIJSWWQDaGWJMNCKRsCYGYuJUSaKaW@UIMDK@[QUHOGQJMEILCAUDKFSOUQD[WMCQ@WPMGCCIUSE[IMPMN]`e@IEGAQBMHM@YEOSGCIDMIGNOLB@QP@GkP@AI^J@ILEBIbADGEOog@KQQWSekWQQUOFKZLF@PUNmIaHIUeBCTSHENcJa@_IWSaGu`GLSBKJQFOXGDXVQVOBIHcDSJWBEFGTMH[^mLaXcHiKElTRKtFXZ`MHMPCNRDxZB\\ICIHK@KHbIVFZ@BPnGTGbDXRDJaZKRiGEFSFEJhjFNZFjn'], |
| 'encodeOffsets': [[ |
| 119314, |
| 41552 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '110111', |
| 'properties': { |
| 'name': '房山区', |
| 'cp': [ |
| 115.8453, |
| 39.7163 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@h@bl@HRJDZ``TA\\VVD^H`\\pF\\J`JGv@ZO\\GPSTEjPTR`FnEbDTDHEhLFMTK@ETSPULKEI@OVISKSJACEQNQbVIXGDIN@dMB[IIBcN]ZHNLP@XOWCFWCNRHTpATD@^NVNLED@Rh@jCEF}E[OOHUEW]W@QGGDIQSH_MmFmCUT_K]i@MHCMWFCFE{BMHMPOHKS]CFNGBELDH_@BcAKOACESAOBELaXAROB@FODMEDWJAG[aE@UM@DImEWJMC@OeCA{aE[@{L@MINUCQXKfUJORCHqJBF@TCXWNQX]M[EAJO@@KMBQJIC]EWMCCUBEBFHKDOTMBGNGF]MWDBRDdMDQVyE@LPVHDCP@JVVMTG~HNSH[CmRUvHPHBbA\\PTNRC\\YNJPRARPJDDR'], |
| 'encodeOffsets': [[ |
| 118343, |
| 40770 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '110229', |
| 'properties': { |
| 'name': '延庆县', |
| 'cp': [ |
| 116.1543, |
| 40.5286 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@^AXOPEB[ZIGU@KKI@YGE@OYMGWFGvCNO@OPGTBHUTA\\ITACIGMIHmCOeDGGWSUIGimYEEMgiFITEFEjHLQbYCIWQaCSHmHAOY@UEaJG@LGLDJ[JAwYQCDMNONGY_EWLsSQFkMO[NWAIGaIYL@HMBOKiOQDWEUDMQSF_QIUBWdg@[NaAKQ@M]OQ@WhgLUMMFYQDIRCEUZOOCIOJ[KIUMKL@HIDKVEBM`HJAJSJUdBLGNEdMBMO[BYEWJSNKNaD]PE\\SjOT_RQVEZPpNQXfNA~lNG`@PNLp¼RFLfbdKbATUh@FSNWjGFZVLFHVA~X¨PPROfFJbNJPLFbENJPrEFNPFRHDDJdENJLVEPBJTVTHGHFRFH@PXP\\ORQHW\\BjWFDERLPPBbB\\E`B\\D\\L`@F]FCnJ^AZL'], |
| 'encodeOffsets': [[ |
| 119262, |
| 41751 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '110109', |
| 'properties': { |
| 'name': '门头沟区', |
| 'cp': [ |
| 115.8, |
| 39.9957 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@V@XMnGPY²JQNEhH\\AZMPDVTTDZCPiJkHSHCjIdFtEHITCNITQEKUAMCEIKCECABYESKFWAKBEIIHABGDCKCAIHMHALKEI\\CFIBILIJQZS]BBEECS@E@@C]COKI@CABAAEEDMGCH]A[M@CJWHJaUMRFRBDTITLUJ@PFJKLOVST@FSLENgKGFSCaCmF_ESQiOSFOT[HYPu@IH_[IoE_[]GUC[USB__CYQI@Gakg@qZeHQNMNV\\FVLPgJAFJPRLCH[XcPELUT[JiV_EELFTADBXRTRLJC@fHXHHbPd`fR@NfT`@TLplHMpCEJHJBVLF@JTVnG^KXDXHNVGRLRXFJVdDHSNWLGfEzA'], |
| 'encodeOffsets': [[ |
| 118635, |
| 41113 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '110114', |
| 'properties': { |
| 'name': '昌平区', |
| 'cp': [ |
| 116.1777, |
| 40.2134 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VNLJI\\JPPDYPFVQDCJZRNEVNhKXgR@^P@NLRbB\\Mh@XcVARJE`RTCNFVXRCjPPLNA@GZKbJJHXB\\MNPjLdGbWnK\\]NGHSFEXATIdCJGPARUWUHCPWRELITAHKv_E@iYCaW_BQ\\Y@QIO@QDCIGZCEMWGFMFAFgHEDOCSqKCCFGAMKEAC@ODGCGs@WH@KQA@EE@CE@GEA@EH@GGUEEJEAYD@JM@@DAA@FHD@FTJEHUC@JUBKCKG@G[CIIQReAYhO@OXGDO@@FF@IHJFCPEBACBIAAKDOABXARHPNEHGbQAAKQFGIAM[C@WHKaGiCEGOAHUKCIokSCUSOCYN[BgGMFIR±OZmHWNU@ShbbXDHVXXGJ^lZ@PZ\\Nb@\\FHJAD'], |
| 'encodeOffsets': [[ |
| 118750, |
| 41232 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '110115', |
| 'properties': { |
| 'name': '大兴区', |
| 'cp': [ |
| 116.4716, |
| 39.6352 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@F\\E~DFN@BDFEpHFCHBBEGCDCJBHUDSBB@ELCPbF@B\\J@BJVAFJ\\ADKTCBGECFMT@BMN@@FH@DaNBEnvB@FPBATK@FHEFIAKFBFL@@PKBFJHC@FXBRAFCDMPDTOL@JIVFDHH@DDH@BGRFCDLD@N^@@CNA@KNOAEBCECFEGCFGMGFIPMOEJOLBADBBHGG@GCHIECY@INC@DMGS\\AIOZAAEYA@GT@KKMBEETCGMVINFxA@MJADB@FlA@HJA@NND@DFA@DVAZBBOFKH_JA@K^GBC@EFEG@gAENMXKJigC@IbSJMqGOP£RGSMGE@kbQFDPEFiBSGGSBK]I{CDWCIDOic[C_G@SuSO@EWKCO@MNY@\\uZOPENQD[LKESSKGBKEG@EJGAGHoH¥CqhifeJkX_XFFGHFNEDFPENKHM^IFIVL^S`DVEnNnG`RTCJHH@R^XFXGVPP'], |
| 'encodeOffsets': [[ |
| 119042, |
| 40704 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '110113', |
| 'properties': { |
| 'name': '顺义区', |
| 'cp': [ |
| 116.7242, |
| 40.1619 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': [ |
| '@@EhEBENXHFNYDJHCD@RJP@R[ZARX`DbjZF@bHXT`Jb@dIFMTGDSfAJVbGnJVM@OKELYPERVXRflXTT@NIfC\\NJRhCVEHFJXNT^DTeZEHYCOhuAMJELOdAVPTMOWBWNMNEJgl]@WGUFIC[T{EEDEHGCIGMI@SECUQI[D{A{GQESPUH]CsiMCmHUeoHENcAaDGCMDGMQCACCBaCGLMAHB@DIEQLOAAEEJ@CW@CDINGAAGKQOCgV@LG@BEGDKNeREFBNCFIDOPKD[@YRW@GFWDAFE@EHDDrLDTCPGF', |
| '@@KrJEH[\\B@FF@CHFBHUNAJKADGECBCMAG^E@EbI@BEGP' |
| ], |
| 'encodeOffsets': [ |
| [ |
| 119283, |
| 41084 |
| ], |
| [ |
| 119377, |
| 41046 |
| ] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '110117', |
| 'properties': { |
| 'name': '平谷区', |
| 'cp': [ |
| 117.1706, |
| 40.2052 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ZJZRafFLjnVGNJ@LLBdXX\\T^EDMJ@nZKLBjPPJ@HbA\\H`DbERHLCFK^BZaFWXQLAGMHa\\OLO@SBIpBdCLVQfElO@GSAKEDQTC@GEBKG@ORIJBDAPDFA@CaOq@GGQAAEJK@KMUGAAGEAa@MGMBGCGSIIW@WSUCMDOJeWOM@IUF{WMWaDIMgIoRoCOKeEOEAG_I[cg@wLIFENQFDVTFJ@HNDJGHCFFFS|D\\EJHV@Xk^IhMFMNAXPX'], |
| 'encodeOffsets': [[ |
| 119748, |
| 41190 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '110112', |
| 'properties': { |
| 'name': '通州区', |
| 'cp': [ |
| 116.7297, |
| 39.8131 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@FDAJTGDNDCTDDEDBBE@DT@@EHCDGJ@EIZ@@FDBR@ATFBBVFFE@@HNA\\VE@CLIFNJFNJBCP]A@LJFA@HJEDD\\C@DBCHLAEPF@@DH@APHAERDF\\GIxDTM@CFLBBFJ@CNUPMHECGDBF]BMFPDLRBHHBJMDCX@@DFIBFPBRKJF@CGANBHKbDDABDRDHNNCHDbCdBFMpGHiOYMefKJMC}HWAUNW\\NNBNAkNU|]HMTMN@MZBLFFF@RIRUTBMFIEGaAGGAOIIUGTSFcYKS@MSLYPKRUBU]EWDOI]CKGASgW@MTWKIMCS@uMAKKADMECGAKVUTSDy@IjWLMNBF@hHEF@FAD]H@LIBG`ELAPYAUB@CEB@CMC@MIB@GkB@ECAIB@NwBMEUJHNSDFFNALLS@@HZBBFYBJP[BHTCND@JMZ@FDGJHDH@GHAABCKAIPPFONEJNHEHHDEFFDADBFMP@L'], |
| 'encodeOffsets': [[ |
| 119329, |
| 40782 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '110105', |
| 'properties': { |
| 'name': '朝阳区', |
| 'cp': [ |
| 116.4977, |
| 39.949 |
| ], |
| 'childNum': 2 |
| }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@bFGHBHFBFIVFHHG@@FFB@HDFF@@FRB@LXGt@DHCH@PBDLFBNF@BEXCHEX@ZQ\\@LCPOJCDEAMFEfQLMHCAFH@@KhUNE^AAEHCFDNGVODMI@AEKADEN@CSJw[HCEFQGBBOG@@CE@FOKBDGCAD@C[FCGIB@IE@K^BDOIAEMMIJEDKF@[UMB@GF@EEAUEABSQ@CA@EY@FJI@CHGD@FS@@CAFCACFSCCDCMSHBIECMB@D]@@MKCDCQEAHG@CCG@CGUEIJK@SPOCCNEDQBDNDB@DJCDLFCBBALJB@BVGPBKVO@KHCCCD@FE@BNA@FNCTDDJA@FGB@NBDW@CL@hT@@ZHHQDDDAFSAANBC@HG@EFS@@DE@@PCB@Ue@CADNJB@FCBWA@LI^ix@FIHrH'], |
| ['@@HUNAJKADGECBCMAG^E@EbI@BEGPKrJEH[\\B@FF@CHFB'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| 119169, |
| 40992 |
| ]], |
| [[ |
| 119398, |
| 41063 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '110108', |
| 'properties': { |
| 'name': '海淀区', |
| 'cp': [ |
| 116.2202, |
| 40.0239 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@plDJVLGPBFHjDbHGL@X\\DBNHJREBLRBHaFGMGOBQAWPBLCBBAJBDFADOIEJGE@@EP@HCPWP@ZgfBRQJJ\\D@HLHLDVA@IVDFGSI@EGC@EBB@CN@@IZCAGHGaEqGJG@EjwJ]@K@GSA@e_I@NE@CA@Kg@KC@ENCFAKQAW@WIMK@V@I@@F@^EDFB@HcIaDYCBRRDCHD@EFLN@FE@CJUPEJOJMTBPEDIFCMIAKNOGMRFJNDVBFLSRMJSDGJsFcEiJGDGTIlOjYD'], |
| 'encodeOffsets': [[ |
| 118834, |
| 41050 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '110106', |
| 'properties': { |
| 'name': '丰台区', |
| 'cp': [ |
| 116.2683, |
| 39.8309 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@hMN@NFTQCFRCBJFA@HJ@@HJ@HJ\\FTACD@@UNLXJX@@MA@@IECAQlDFEHBDI~D@GXCFMVDFCH@@NF@ANJC@FnAB@AMF@@EDCDDLGP@LUOAUH@AIABKAAEDCKID@CCACMWA@EGDEILA@OK@AELEJBFEEGL@BSOA@EuAFmMACbG@@EM@ANS@ENFDAHSDCL[BEIUBAII@A[E@OaKD@FAACTGVIACDHDAFGAEDoGEFACM@ig@@QFCMKMU@]SCoBGSMQDEXXDWPO@MKYGM^AdJJA\\cNB\\G^DNHFCBFABDBJ@PL^D@DF@T@FDAF^A'], |
| 'encodeOffsets': [[ |
| 118958, |
| 40846 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '110107', |
| 'properties': { |
| 'name': '石景山区', |
| 'cp': [ |
| 116.1887, |
| 39.9346 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@NQPHLMJBDNJEFCAONSPIFIVODIF@@EKMFEC@DGQCAQZDbCdJ@GEAFC@]@EJ@DCSB[EGII@@GI@@GEBAIQDDESRMEM@gNYTIRKJAJEJ[DFJKLGBGNBJLDCDAHGBJJAFBLEXTLZFBAFDLD'], |
| 'encodeOffsets': [[ |
| 118940, |
| 40953 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '110102', |
| 'properties': { |
| 'name': '西城区', |
| 'cp': [ |
| 116.3631, |
| 39.9353 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@XBDA@EIACM@IJAD]BC@SFABISAD]H@@OAEDQEW@BLEMD@FLDh@@LDBF@@M`J@fTB@H'], |
| 'encodeOffsets': [[ |
| 119175, |
| 40932 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '110101', |
| 'properties': { |
| 'name': '东城区', |
| 'cp': [ |
| 116.418, |
| 39.9367 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@DBf@@VDA@OF@@CT@FEH@@GADBMTBBECCRCGG@YS@@gDK@AC@PG@C^TBAJEB@TADC^IB@J'], |
| 'encodeOffsets': [[ |
| 119182, |
| 40921 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '110104', |
| 'properties': { |
| 'name': '宣武区', |
| 'cp': [ |
| 116.3603, |
| 39.8852 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@RBX@RFFCBFU@aK@WA}CCJGAEFkCBRFD@JB@@N'], |
| 'encodeOffsets': [[ |
| 119118, |
| 40855 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '110103', |
| 'properties': { |
| 'name': '崇文区', |
| 'cp': [ |
| 116.4166, |
| 39.8811 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@XBL@@bEVD@BX@AC@MHA@EIBCCDSEMmB@EIDBME@@MG@EDUCENWD@H'], |
| 'encodeOffsets': [[ |
| 119175, |
| 40829 |
| ]] |
| } |
| } |
| ], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/util/mapData/geoJson/china_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [ |
| { |
| 'type': 'Feature', |
| 'id': 'xin_jiang', |
| 'properties': { |
| 'name': '新疆', |
| 'cp': [ |
| 84.9023, |
| 41.748 |
| ], |
| 'childNum': 18 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@ρȁôƧƦóəʵסʵóƪԫʵѵͩƧͩړυࡓɛʵ@ȃ@óᇑѵƨɝɚôóНѺͩɜ̏ԭʵôƧɞñ@υƩ݇ȂóƩƧ@ѵȂυƥŌਗ॥ɛóʵѵƧѹ݇̍ࢯəɞυρͩ̏óਙƨƧŋôōó̍ͩóʵןóŋړͪƧѶ@ɜԭԫƦɛȄ̍ɝȄöςƩȂ̏ñȀ̏ƩóóŎə@Ő̎@ɞȀɝŎôƨóנѵȄƧ@óŏɝóɜôŎ̍ͨςŎ@ƨóôƨɞ݈ʶóƨφó̎Ȁƨ̍ԮòѸԮמ@ѺȀ@ƪၬֆòȂñ̐òȂɜóƨ̒Ŏ̑@φρȀ@Ő๐ς̎Ƨφ@ɝφڔ೦Ԯǿࢰ@ƦŏԮƨƨȄƧ۬ɜʶڔŐɚɚóŐôƨôƧƧó̐ƥóŏѺǿƦȁφƧςƨƧ̒@ɜƥƦυ̐ɛƪͩƩəƪʷ̑ə@ȃƨʵנŋྸōਚԭԪ@ɝƨŋ̒օςʵôƧ'], |
| 'encodeOffsets': [[ |
| 98730, |
| 43786 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'xi_zang', |
| 'properties': { |
| 'name': '西藏', |
| 'cp': [ |
| 88.7695, |
| 31.6846 |
| ], |
| 'childNum': 7 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ôŌנôʶ̎ͪôóŎƨŌਚƧ̐ôςͪφɚɝࢰ݈̎ѺѶƨôʶ०ɜਘƦŋφѶȁ̍ôŏɚŋ@̑ə@ŏò̍ɜóƥôʷƧ̍φѹԪ̍ע@Ѹʷɜ@ôñנ@Ѷɛɞô̐ŏѶƨѸƧƥōƦôŏô@ƧôƩ̒ŋƨŌƦǿô̎ɜȁ̒óʶѶôôО̒ςƥɜНφσɛȁ̎υƨఱƧŏ@ʵƥ@ŌóóóͩƨƧóŋ̑õóɞóɝԩͪɝρôƧ̍ƧѹͨڑŎ̑ōóƧࢭͩ̏ѵɝóఱóóԪυô@̒ƥŌ̏Ƨ̑Ȅ݇ŎƧѵӏ@ɛõŏɛȄôӒƧŌѵǿɝƧŋԫ@̏ʴƥ@óǿ̑Ȁóǿ̍ςóóυô@ʶɛñρƦƩŐó̎óѵó̑ͪࢯОóɜןƧ̏ƥȄ̎̏̐ןŎɝɜöɞƩȀôöɛȀóͪ̐ƨƪ̍̎ȂƥԪυО@φɞôƪ'], |
| 'encodeOffsets': [[ |
| 80911, |
| 35146 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'nei_meng_gu', |
| 'properties': { |
| 'name': '内蒙古', |
| 'cp': [ |
| 117.5977, |
| 44.3408 |
| ], |
| 'childNum': 12 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ኊȁöƩɜɛנñԮɛѶóԮô@ȁѸóמ̎ගѺၬ@ʶԮӒ̎@ŐѹӒ̒Ԫƨöග̑ѶȄ̒ς।ѶɚöɞɜʴڔôôȂ̎ѺȀςƨƪóԪɜôɛОਕڔԭѵ̍ѹȂԫɛƥ̍Ȃóɜ̎ô@ʶ݊ੲࢮʵږͪנƨôȂƧ̐ͪ@ŐƦƨφԬѶɜôƦ@ŐƧôôƦəŐ̏@ŐڒѶԬô̐ʳԩНςōôŏɞ@ƨȂѶəóƧ̒ػ̎ó̐Őנóƨô̒@ƨɚɚ@עԫɛɛ@ȁυͩƥʳòևρ̑ࡗƧͪ༃ॣԮփ̎Ʀ@ôô@ôō@@ȁѵóƨ̍υȃóʵɛƨƥóυȂóəƪ̐ρƧͩɜԭڔȄ̎عƧȁ̐ŏó̍ɛƥƧ̑óρŐ@Ƨ̏ɝəɛͩ̍ͩɝО̍ƪƧóóӓƨóƧʳ݇@ɝςƪ@ʴƩƧƦôƨɛȄəƧŋυóͩѵ@ɝǿóŌן̍ɛóО̍̑̏ôȁ̍ŏòȁñóƦͩ@ǿə@ɛƧ̑ρȁυô̍օѹóȃə@ȂσʵѷƪòƩ̍ôóۯôʳƧóõʵѵóѹɜ̍ȂѹôɛŌφֈƩͨρóυӑóޟఱ̑݇ͪóƪƨŌóȄڔԬƩςםñ̑ȃѵŐԭŏƨȁɛǿρôõɚɛóƧОə@ѹ̐ѵöԪͨôͪɛ̒ןŏƧƥóôƥƧɛŌôóɝó@̒݇Ӓ̒Ō@Ŏԭࢰ'], |
| 'encodeOffsets': [[ |
| 99540, |
| 43830 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'qing_hai', |
| 'properties': { |
| 'name': '青海', |
| 'cp': [ |
| 96.2402, |
| 35.4199 |
| ], |
| 'childNum': 8 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ƨ@ôƪ݈ȁƪ@φɝòóƨԮʶɛ̐ѹͪôОəóƧɞᇒѶ@ôږô@ǿѶƪȁςɜͩφςŋɞôѶɛƨŌɞ@ɚςŐñԪॢͩƨȂɞóƨŐ̎ŏעӏ̎óƧƦô̒ȁɜςͩ̒ɚɛƨôƨɝφɛóȁƨŋóóɚͩƨóóƩ@ƧəŋƦƩ̍@ƧƧôǿυ̑@ȁɞǿõŏρƥסɚƧóτԫɞôƧƦ@ñȃòñƥóυôôѹѵ@ŏ̏Ȅɝó@ȂəŌóəѹƦ@Ő̍Ōυ݈ԩŐƧóôƧ̑ôʵɞƧ̑ѵôƩɞƧ̑óНѵóôʵ̑ɛȂó̍ƥȀƧŋ̑Ōóƪ@ƨóóŐƥƦŎѷƨѵƧ̏Őɝóѵɜן@óòɛ@ѷʸס@ԩ̎υѺƨ̎óʸôƦɛñ̎@Őɚ@̒əŌóŐ̎'], |
| 'encodeOffsets': [[ |
| 91890, |
| 36945 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'si_chuan', |
| 'properties': { |
| 'name': '四川', |
| 'cp': [ |
| 102.9199, |
| 30.1904 |
| ], |
| 'childNum': 21 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ôôŋó̑Ԯ̒ɛОמͪƨōöͫƥôȃƨóóñôƧóƧôōڔŏƨŐ@ŎôòƥѺŎ@ōɜóנôǿôƦôԮ̍ɜôɚƧñɛɚȁ̍Ƨɛևυ@óóôŋρԭɝ@Ƨʸ̍ŏυɜƧƧóƧƨȁρ̍ƨȃɚôʵφóô̑̏Ȃ̑ʵɜʵɞ@ƨʳסƩóŎəóɜƧôƩƧρóôôô@ŎƧƨƨƪѹó̍̍Ʃ@̏ѹНôޟ̍ƩóƪυɝɛəƨôŎɛȀ@Ȃ@ñɝʶ@Ōρנ̏õóɛͨƨȂѵОɛʵ@̏ƩŐóƧల̍φɜȂυτɛОρƦɝƨóƪ̒Ѷɝƨóʶ̒óƨƨôԪŏφ݇̎ŋ@ŏѺƥôɚɚŋ@ȁɞô̐ȃ@ŐѶóѺφóƦôñòòȄ'], |
| 'encodeOffsets': [[ |
| 104220, |
| 34336 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'hei_long_jiang', |
| 'properties': { |
| 'name': '黑龙江', |
| 'cp': [ |
| 128.1445, |
| 48.5156 |
| ], |
| 'childNum': 13 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ᇔȂਚНƨŐѶŏöƥςŏñƧƦóƨȁ@óƨóȁφӑóóƨóǿ̎̑ôНɞó̑ɜə̎ǿ̒ôڒӑφ@Ƨȁ̎̏ƥƩ̎ρశôȂςƨφ@נɞ݈̑ƥƧɛƨʵƧȃƥ@Ƨƥ@ŏ̑ԩôɝρρóɛƧƩͩƧóʸ̍ʷѹƥɞڕõ̍öɝυ̍ȂƧ̐̑ŏóƨñŋѹóóȁ̍̏Ԭõʸ̏ŏ@ǿ̍@ƧОυ@ñƨòȀƥŎ̑ŐѵóɛŌóȂԫōƧŎѹñ̍ʶóОן@Ƨ̎Ѷô@Ȃ@óŎó@@ó̍ƥԭք༄।ƨͩ̒ࡘςñֈƦʴφͪ@ȂɜɜסԬə@Ƨə̑@Ƨóןô̏ŏ̍ô̑ؼôƨѵɚƧȁɝ@óŐρŎԪО̏ʴ'], |
| 'encodeOffsets': [[ |
| 124380, |
| 54630 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'gan_su', |
| 'properties': { |
| 'name': '甘肃', |
| 'cp': [ |
| 95.7129, |
| 40.166 |
| ], |
| 'childNum': 14 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ڔôԮࢯ@ō̑ŋ݈ӑ@̑ɞôóôɜŋƦƨôóƨƦנŐɜ̑óͩԩͧѶõѺ̏ɚ@ƨНɜôöəςóɜȀƧȂԮŐѶŏ̒ȄמòƪρړԫôȃƧŋôƩ݈ͩɚ@@ǿɜ@φͩóŏɜӑƧōôǿ̎ôƥƪóõö@ôƨôƧƦôó̒ɜ@ɞŌõʶ̏Ő@ȀóôƨȂ@ʶע@@ƥӑó̑óŋôʵóɛړ@@ƩöóƩóρɛƨ̑@óʷƥƥ̎ɛƧôōƧǿôͩѵôɝȃɞȁõƧρóó@ōƧŏړŐóŎôƨóƨôòƧôóȄƦõͬƧŎםͩɜНԭ̑ô̒óŌóƥ@óƨɝσԬƨôעəςƦöŐɝȀ@Ȃφ̒óȀƨƨ̎@ƥƪɚŌ@ƨôƪƧôəͪôôƧŌôȂυɜƧɞƧóəɜ̑ρͪɛ̑Ȃóƨƥ̍ôסӐ̍ŐƧŏɝôƧȁॡͪòԩρŏ@əɝƧŋѵɜɝóρŌυɛͪρƩȂѵ@Ȁڕó@ȄɜʶφࡔڔƨͪѶͪԬʶôƩעʶɚʶƥôóƨςȂ'], |
| 'encodeOffsets': [[ |
| 98730, |
| 43740 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'yun_nan', |
| 'properties': { |
| 'name': '云南', |
| 'cp': [ |
| 101.8652, |
| 25.1807 |
| ], |
| 'childNum': 16 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ôɞôɝ̒öôŌƧƨôͪôô@ŋƦ@ʶƨŐôƪŏ@̐ɜʶѶНƧȁɜͧöô̐ςן@ŋɞʵ@ò@ȁɜǿóōɚƧɜφɞôƩ̎ƪóޠѺО@̐̎ƪô̎ѺƧƩƨƧ@ōóóôóςƪƨƨóôɛó̑ԭƥŌɛǿɝƨɛͩô@ǿƨȁѺŌɚɛ̍ןѶНɛƧôóƥȁƦͩôŎɞƨ̑ɜòôφ@ƨʵ@ɛѹōóȃəƨυǿóʵρƧƧŌƩɛ̏ȄñƧƧȀɝ̍ԩʶƧ̑υóŌƥʳɚӑóНƥô̑óӒѵʵѹƧӐןôƪφõŌƪ̒ԫŌƧؼƨƨסρȁƧƨȂóʶó@@ʴƨôôφ̎Ŏ@ȀƨƪɚƨóƨôôôςóޤƧŌƩŋƧԪ'], |
| 'encodeOffsets': [[ |
| 100530, |
| 28800 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'guang_xi', |
| 'properties': { |
| 'name': '广西', |
| 'cp': [ |
| 108.2813, |
| 23.6426 |
| ], |
| 'childNum': 14 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ƦŋѺ̎ڔʵƨŐ@ƦמȄƪôóȂɜŌɚͩɜ@öóɜôôȂƦôɜȁ@ɞφóȄ̎ƨʶɞŋƨʴɚǿ̐̎Ԭ@ôñ@̏ƨρ۫ôɚƨƨНƪŐ̎ƥóƦʵƥŋ@ȃóƥƧ@@ŏɝǿôυƧȁѵɛ@əóŏ̑@@ə̍óƧó@ȁƩρóòНƥô@Ӓ̑@óŎ̍ƥσŎυ@̍ƨ@Ō̑ôóͪƨ̒óŌړ̏Ŏ@ŌôȄѺŎ@ɜƧʶυ@ñóɛƧ̒ɝóōƥͪ'], |
| 'encodeOffsets': [[ |
| 107011, |
| 25335 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'hu_nan', |
| 'properties': { |
| 'name': '湖南', |
| 'cp': [ |
| 111.5332, |
| 27.3779 |
| ], |
| 'childNum': 14 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@քɜОƨ@öŐמóƪôƩɚ̒ŐȁςͩɜòƪɜȀòñɝòѺͪ@ŏƨŋóɝôǿƨɚȃóəƨȃѵͩó̍@ȃƨóóƥƨƧ@ʵƦóͩɜɛóñԭɛōυȂ̍ƧƦō@ɛƥɛȀ̑óʷóō̍ƩŏƧОəƧóς۬Ƨ@̐óòԫ@̏̍əȀƧʳɝŌóɞƧƨɜóŐƨò@ȄƧŌρŋóôԪОóʶ@̎óȄ'], |
| 'encodeOffsets': [[ |
| 111870, |
| 29161 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'shan_xi_1', |
| 'properties': { |
| 'name': '陕西', |
| 'cp': [ |
| 109.5996, |
| 35.6396 |
| ], |
| 'childNum': 10 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ςôöƨɝȂɞȄѶóóͪƨȀóŎƨ̍ɜƦƦôʸ̒@ɜƧςƪôõô@ƪڔ@ôɜóʶôŌô̒Ӓ@Ʀ@Ѻ̎ɜѺɛѶôöʶôƨóʴ۰óô̎ñƪѸƩτʶ@ȁòŋəѹóǿ̑ʵ@ȁ̒ʷυփô݉ôН̏ط@ȁƨóô̏ƪõ@ʳ̐ʵ@ɝɛŋƩŌɛóןôƧŋ̒ó@ŏ̐ƥ@ŏυ@ƧƧôן̏@ƥȂѹɜəɛóԭ̎ƥóóóȀןɛô@ŎѹōñƦ'], |
| 'encodeOffsets': [[ |
| 108001, |
| 33705 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'guang_dong', |
| 'properties': { |
| 'name': '广东', |
| 'cp': [ |
| 113.4668, |
| 22.8076 |
| ], |
| 'childNum': 21 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': [ |
| '@@@Ȃôôƨ̎@ɚ̒@ôŐ@ɚѶɜƨȂóφɞȀ@Őƨ@ôƦ@ȄƦŌƥʶƦôôŎôʸ̒ɜǿƦ@ɜƥŎ̎ƨφȁɜŎòƥԮŎƨōóŏɛƧɝəɞƧɜςȃñȄƦŎ̒ōôòƨəƨɚН@əƨ̏ƪʵυŌəɛóəԭŏəóŏѹρʵɝƦ̏ƥʳѶöō̑óóŋρȀυƧƥɛѹōƧôןɛŏѵ@óŋôʵɝƪԩõ@Ƨō̍@Ƨ@@ƦɝԮƪО@@', |
| '@@X¯aWĀ@l' |
| ], |
| 'encodeOffsets': [ |
| [ |
| 112411, |
| 21916 |
| ], |
| [ |
| 116325, |
| 22697 |
| ] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'ji_lin', |
| 'properties': { |
| 'name': '吉林', |
| 'cp': [ |
| 126.4746, |
| 43.5938 |
| ], |
| 'childNum': 9 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@נ@ôН̎ʵѺòƨōԬŎôȁɜŋѶô̒ŏƦōñǿòƧφ@ƨН̎@@Ȁ̐Őöʷ̐ԫ̎ôȂѺôòŌôƧ̒Őƨ̏̎ȁφ@ŋƩͩםȃƨ@ȁ̑ʶ@Ōóôɛƥѹ̑συ݇@ɜρƧȃࢯƨôəȂɛōƩɛ̏υρóõƪʴυφ@ʶôŌóρք@ɜƧ@ɝǿƧͪρȀƩó̏ŐƨȂ̍غړȃɛԮƨͪ̏ςƩôɚφȁƦôɜƧôʶφȄ'], |
| 'encodeOffsets': [[ |
| 126181, |
| 47341 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'he_bei', |
| 'properties': { |
| 'name': '河北', |
| 'cp': [ |
| 115.4004, |
| 37.9688 |
| ], |
| 'childNum': 11 |
| }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@Ʃ̒̏ŌѺ̒ƩóȄƧŌƥͪòôñȂ̎ŐóȂ̒̐̎ôНɜנ̎ôŋɞȀѶ@ôͪφƨŌɚɜȃóƧƨƥƪ@ʳƩɞρ݈@υНφʵɜƦρƨƧ̍ɝóɛѹ̍ρŏ̑ôóƨ@ƧƦôƨɛ@ƥƨ@ȂƦ@@ôəŐƧʶƨŌυ̍̎ɛŋôōɝ@óƧ̍ƦʵѵʳôʵɜŏςôƪŋƨŌɚ@ôНƥƧ@ōѸɛ̐ô̎ʵѵНԭ@̍̍Ƨò@ȁɝ@əρυͩƪ̏ƩõƧŎƧōóॡȄɛʶɜȀ@ɞςѶƧƥςɛŐ@ɚɜɜ@Ŏôôςƪς'], |
| ['@@õə@Ƨɛ@ŐóƦφô'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| 117271, |
| 40455 |
| ]], |
| [[ |
| 120061, |
| 41040 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'hu_bei', |
| 'properties': { |
| 'name': '湖北', |
| 'cp': [ |
| 112.2363, |
| 31.1572 |
| ], |
| 'childNum': 17 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ñȄυƦöŐƩóנƨƨφ@@Ő̏Ʀ@Ő̑ôƨŌנóɜôƪŋɜŌѶօڔə݈òɞōɜŎôӏƦóƨô̒óôȃƨó̎ŐôƧƪ@ƨȁςƧə̑̎Н@̍Ƨŏρôԭͩԫ̍ʵƧóȀôɞƧŌ@ŐѹͩñòɞñɛǿƩɛñρͪȂ̑ŏƪəƩóםôõŏƧ@ɛНƥȄó̑ѺƧôφóƨƨƦƪóɜŐôóòôƨóφ̐ƨóƦ̎'], |
| 'encodeOffsets': [[ |
| 112860, |
| 31905 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'gui_zhou', |
| 'properties': { |
| 'name': '贵州', |
| 'cp': [ |
| 106.6113, |
| 26.9385 |
| ], |
| 'childNum': 9 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ɜȀƦŋԮô̒ɚôōעƪƧʴɝ@ɛʶ̒ʶ̐ȁƦóȂô@ôŏ@ōôƨʶѸô@ʶƨɞó@ōτöòυƨ@@əƨô@ɛ̒@Ʀɜôȃ@̍ôʵԩНôóςŌƨŋ@ȃƧñôŏƧɛƨôɝƧʵ̍ôȃυ@ɝɛȂƥóóȁɛóõôɛ@əͪɛŋôȁƩóםȃ@ƥƧŏړʶѹ̍ƥŌƦȂóôɜƨѵО̎נəɜѹŋƧȂ@ȀóɜͪɞƧ'], |
| 'encodeOffsets': [[ |
| 106651, |
| 27901 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'shan_dong', |
| 'properties': { |
| 'name': '山东', |
| 'cp': [ |
| 118.7402, |
| 36.4307 |
| ], |
| 'childNum': 17 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Ʃ̐φͪɚςɞ@@Ȃƨñ̎̎Ԯ@ѶОƨƧڔ@φН̑ŋ@Ʃ̒ǿ̎@ƨɜԬςôʶ̐ʶöԫƨƧנƥɜŎôō̎@ôŏóρƧŏԫôóƧԩó@ƥɜƧԭóƨʵɛƨӑɜНԩóô̑óƧʳəóɛƧ@õȀƧ̍ȃɛŐóŏυО̍óɝƩԩ@ƧɚԫȄɚʶƨɞʶԪ̐ړɛƪ̒'], |
| 'encodeOffsets': [[ |
| 118261, |
| 37036 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'jiang_xi', |
| 'properties': { |
| 'name': '江西', |
| 'cp': [ |
| 116.0156, |
| 27.29 |
| ], |
| 'childNum': 11 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ƧȄôɚəȄ̎ʶԬԮͪςóƨŐƪτɞƦōƥƧ@ŏςôóŐôô̒ʷѶƪƩƩǿ@ō̒ɛôυ@Ƨȁѹɛəƨѹ̑ƨ̏óƥѵʷô̍ɛȁôŏɝǿƧԫƧôʳƥōòȃρȄɛɝƨɞɚɜƨôŐƧŎԭōñƦòԮɜôɛôͪƥ@ʶƧƨôƦƧô@Ȅô̎Ѷͪ'], |
| 'encodeOffsets': [[ |
| 117000, |
| 29025 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'he_nan', |
| 'properties': { |
| 'name': '河南', |
| 'cp': [ |
| 113.4668, |
| 33.8818 |
| ], |
| 'childNum': 17 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@φ̎ƪ̐ɞȄɚ@@Ȃעó̎ŌѺ̒ôֆॢȃôƨŎƨōƪöƩ̑ڔɜԩ̏ɝʵƧəʵԬȃƨəԪ@@Ƨ̒ŏô̍υȁƧɚ̍ôóŋ@ɝƧŋõ̑σ@ŏɜŋôɝ̒ƧɚôôطρóóɛƩ@óƨ̍ŏƧôóȄ̑ôƧóƥôóӐɛōɝŎ݇ñړɚѵֆ@ɞ̏ʶ@ʴƩöó̐'], |
| 'encodeOffsets': [[ |
| 113040, |
| 35416 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'liao_ning', |
| 'properties': { |
| 'name': '辽宁', |
| 'cp': [ |
| 122.3438, |
| 41.0889 |
| ], |
| 'childNum': 14 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ƨʴƧôôӔƨô̎ƩɞН̎ͪͪɜɞɚ̐@ƨςŏ̒ôƦƨɜô̎ƪôςǿƨͩɞȀƨ@@ɛςփôóŋ@ʵφυƩʳö॥փρѹס@əɛ@ͩࢯ@ѹʵρƩʶφȀƧ݈̒۬óʸɝŎѵ@ԭԫןɛƧƨƥςɛυʶφО'], |
| 'encodeOffsets': [[ |
| 122131, |
| 42301 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'shan_xi_2', |
| 'properties': { |
| 'name': '山西', |
| 'cp': [ |
| 112.4121, |
| 37.6611 |
| ], |
| 'childNum': 11 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ɚѺñŌɚôȄѺ̎ֆφóςȂ̒ɜƨɚ@@Ȁƨŋôȃƪѹ̑̐ŋƪ̑Ʃρρóó@ōɛɛ@əɜŏƦρƨρѵ@ɝɛǿɜʵóօѹ̑̍ŋסô@ȁə@ɝȃ̏̍ƩυƧô@Ȃ̐ظóОó݊φք̑ʸ@Ȃ̒ʶôȀ'], |
| 'encodeOffsets': [[ |
| 113581, |
| 39645 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'an_hui', |
| 'properties': { |
| 'name': '安徽', |
| 'cp': [ |
| 117.2461, |
| 32.0361 |
| ], |
| 'childNum': 17 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ó̎̑Ő@ƨƪѶǿɜ̑φƦʵ̐ƧѵôóƪôôυςƨȂɞŏ@̍ԫôò̑ƥóȃѶͩƧƥôŏѺôŏƦ@ƥͩƧôȁυó@̑ƧɛѵʵƩƪѵ̑ʸóóôŏρó@ŐƦƨƥŎσɝƩ@̎̍Оɚ̒ρƨƧȂôɜςôóظəó̑ƨóɞɛŌ@Őτö̒ƨŌ@ɞôŌ̎óƨəφȂ'], |
| 'encodeOffsets': [[ |
| 119431, |
| 34741 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'fu_jian', |
| 'properties': { |
| 'name': '福建', |
| 'cp': [ |
| 118.3008, |
| 25.9277 |
| ], |
| 'childNum': 9 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@̎óȁƨӑ̒̎ɚƨͩφŐƨɝ̎ŋóŏρ@ōƨòʳəóƨō̏õɛƧ@ƨѵƧōəŏóŋƧô̑ɝɛʳƥ@@óɛõ@Ƨ̑ƧóȁəƧ̑Ƨ̐@ɚəОƧƧɚóñ̑ŎóʴƨƨԬɞȀóŐɜȂó̎ѶʸôƦƧ̐Ѻ̒ɚƧѺɜƨȂ'], |
| 'encodeOffsets': [[ |
| 121321, |
| 28981 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'zhe_jiang', |
| 'properties': { |
| 'name': '浙江', |
| 'cp': [ |
| 120.498, |
| 29.0918 |
| ], |
| 'childNum': 11 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Ѷʶƨɜ@̒φôóȂƨƦͪ@̐Ѹ̍τȂ̒̑נŐמôƪƧôӑ̑@ƥρͩƨօ̏@@υɝó@ŋɛ@ôƩəóƧѵυó@ƩɜŋƧ@̍ŌƧɞυŏƧͪ̍ə̑ƧӒôȂ̍@óφ̑ɜ@ŎƪȀ'], |
| 'encodeOffsets': [[ |
| 121051, |
| 30105 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'jiang_su', |
| 'properties': { |
| 'name': '江苏', |
| 'cp': [ |
| 120.0586, |
| 32.915 |
| ], |
| 'childNum': 13 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ôɞ̎φНôŐɜŏ̎Ȅƨöǿƨ@ôɜɚƨʴ̒ôôó@Ƨ̎əԮȃԪૉöͩ̐ƧòʵφƧôʵ@óړɜóŏɜǿƧɝρσȁѷ̎̏ƥóŐѹóŐƨƦѵͪôȄƦñ̒Ԭó@̎ɝŐƧȁρóφƩóóôƨѶ̏ƥʶυɛ̒ѵȀ'], |
| 'encodeOffsets': [[ |
| 119161, |
| 35460 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'chong_qing', |
| 'properties': { |
| 'name': '重庆', |
| 'cp': [ |
| 107.7539, |
| 30.1904 |
| ], |
| 'childNum': 40 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@əȂòɜƨѺɛƦȁ̐@ƪõŏφƥòȃƥ̍Ƨôυ̏ƧôñóóôɛŏƩôƧƥôƧóυƨ̒ѹôƦȃ@փƥɛ̑@@ɜƧó@ɚƧ@ñφσõ@ŎɝôƧ@ʵѷóƧʵó@ŎóŐó@ôȁƥó̒υôóʶəƧȄς̎ƧȂôƨƨƨφɛ̎Őƨʷɞ@ςԮóŌôôφ@ɜֈ̎ƨ'], |
| 'encodeOffsets': [[ |
| 111150, |
| 32446 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'ning_xia', |
| 'properties': { |
| 'name': '宁夏', |
| 'cp': [ |
| 105.9961, |
| 37.3096 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ల̒ôޠφӒςôƪͧυևɜŋѺó̎ȁ̍ɛ@ѹס@@ʵƧȁôó@ǿ̐ŏöʵɝŋɛ@ô̑ƥóóƨƧóôó@ƩôóƦ̍óȀƨŎɛӒôŐυͪɛ@@Ȁə@'], |
| 'encodeOffsets': [[ |
| 106831, |
| 38340 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'hai_nan', |
| 'properties': { |
| 'name': '海南', |
| 'cp': [ |
| 109.9512, |
| 19.2041 |
| ], |
| 'childNum': 18 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@φɜƦʶ̐ôφô̎@ƨŎö@τʵƦԩ۫õН̏óƥȃƧ@Ʃəםƨ̑Ʀ@ޤ'], |
| 'encodeOffsets': [[ |
| 111240, |
| 19846 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'tai_wan', |
| 'properties': { |
| 'name': '台湾', |
| 'cp': [ |
| 121.0254, |
| 23.5986 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ôƩɝöƧɝѵəޣ̏ρƩԭóōóͪρɞƧОôԪ݈ଦѶɜ̒ɛ'], |
| 'encodeOffsets': [[ |
| 124831, |
| 25650 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'bei_jing', |
| 'properties': { |
| 'name': '北京', |
| 'cp': [ |
| 116.4551, |
| 40.2539 |
| ], |
| 'childNum': 19 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@óóóυóôƥ@ŏóóə@ƧŋƩŌρóɛŐóʶѶʴƥʶ̎ôƨɞ@óŎɜŌ̎̍φƧŋƨʵ'], |
| 'encodeOffsets': [[ |
| 120241, |
| 41176 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'tian_jin', |
| 'properties': { |
| 'name': '天津', |
| 'cp': [ |
| 117.4219, |
| 39.4189 |
| ], |
| 'childNum': 18 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ôôɜ@ƨöɚôôôɚŏ@óƥ@@ȁƦƧɜ@óƧƨƥ@ƧóəН̏óѷɜ@ŎƦƨóО'], |
| 'encodeOffsets': [[ |
| 119610, |
| 40545 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'shang_hai', |
| 'properties': { |
| 'name': '上海', |
| 'cp': [ |
| 121.4648, |
| 31.2891 |
| ], |
| 'childNum': 19 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ɞςƨɛȀôŐڔɛóυô̍ןŏ̑̒'], |
| 'encodeOffsets': [[ |
| 123840, |
| 31771 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'xiang_gang', |
| 'properties': { |
| 'name': '香港', |
| 'cp': [ |
| 114.2578, |
| 22.3242 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@óɛƩ@ρ@óôȀɚŎƨ@ö@@ōƨ@'], |
| 'encodeOffsets': [[ |
| 117361, |
| 22950 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'ao_men', |
| 'properties': { |
| 'name': '澳门', |
| 'cp': [ |
| 113.5547, |
| 22.1484 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@X¯aWĀ@l'], |
| 'encodeOffsets': [[ |
| 116325, |
| 22697 |
| ]] |
| } |
| } |
| ], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/util/mapData/geoJson/chong_qing_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [ |
| { |
| 'type': 'Feature', |
| 'id': '500242', |
| 'properties': { |
| 'name': '酉阳土家族苗族自治县', |
| 'cp': [ |
| 108.8196, |
| 28.8666 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@XJ°lJX@lbl@XbV@VLnJlxnbUU@IVK@lVIVwnJlU@n@J@L@Jn@l_nWVLVln@@blLmV@@xÔ`nxVÈLlxLVxVVV_U»VWn_m¥XwVmnX°lmUUVwÞaVk@a@mmIUa@mwk@m@@U¯a@UV@@K@ykkmwkV@kU@ÑVkKWLÅamaUm@kyU@WkU@UaIUaVaUUmUUa@aVLXKWa¯UUbmJXnWnX`l@@xkzWÆ@VLU¦x@b@JkIkJ@LmbUamJwm@óxnk@V@xVnUVmVUVUbVlUbkXW'], |
| 'encodeOffsets': [[ |
| 110914, |
| 29695 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500236', |
| 'properties': { |
| 'name': '奉节县', |
| 'cp': [ |
| 109.3909, |
| 30.9265 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@WVXbUnK@x@b²kxmKkl¯_VV°VU@bnKVVV@@nk@nbn@°@VLČU@°WV@VnU@InKVl@nUbKnXWlknLlKUwnalLaVlUXmWk@UU@UWWIUyķ¹XaWW@XKUIVmU@W@UVU@KV@n»VkUkÇmUmVIUmULUbm@wUaKkkm¯ÑUL@bWVnx@VmxUI@klmkkK@aK@IlJ@I¯k@mak@mnkJVL@bV@UbW`UUUVI@VU@VVbUJVLUVVbUXVVxk¦VJUnVxnVVUJV@Ubl@@bXV@L'], |
| 'encodeOffsets': [[ |
| 111781, |
| 31658 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500238', |
| 'properties': { |
| 'name': '巫溪县', |
| 'cp': [ |
| 109.3359, |
| 31.4813 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@nLWbXVLVUV@KIVl@b@lbUVnU@JÆU@V@n°KĢUl@VbÞKV@_VKXUU@KX@wlkkU@mWKUU@UôJ@XV@aVmÞIVaVL@»km@UkLU@aU@WWLUUUKkbwWa@KU@kaXmWLamVk@UmL@JmVUU@¯X@ċVUK¯@ÅnWKLkKULWK@UXK@wW@LkV@bVLlXn`¯xU°LnlV@n°Lnl'], |
| 'encodeOffsets': [[ |
| 111488, |
| 32361 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500234', |
| 'properties': { |
| 'name': '开县', |
| 'cp': [ |
| 108.4131, |
| 31.2561 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@n@naIw@@VVKLVbVxnVÆUnanKWXamKmk¯K@mkUm¯KV°w@Wm@UIUUlKUU@a¯KWanwmUXamKkUWUnU@KkUwWKXaWLUWkImaUUUKka±k@l¯wwmbUkXm@UJkIWXXbmUJXUV@°KllVXV@xmbnV@blV@VU`UL@Va@bULlb°VXbÜ@V@bL@JxnLVb@lVb@V@@zbXWXKVLV@@bUVVL@blVna@ll@zl@@J'], |
| 'encodeOffsets': [[ |
| 111150, |
| 32434 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500243', |
| 'properties': { |
| 'name': '彭水苗族土家族自治县', |
| 'cp': [ |
| 108.2043, |
| 29.3994 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Jlb@nVV@bXb@ÆlLUl`nVKU¼VxkbWnlUxlXX@°°WnnJ@VUn@Jk°L@VlV@nUJx@bVVVz@VnLlaKnalVlIU¼@nV@@anKUwVal@UlJlI@akU@UWXKVI¯Uak@@KmkXWÜkXWykIWwXw@laXamkVUUym_XmlkkmmakwmIUKU@Wak@kaW@kI¯WIk¦VUUmaUV@XkVUV±aUb¯b¯¥m@@ImJ@mmL@kUKUkkJbV¦'], |
| 'encodeOffsets': [[ |
| 110408, |
| 29729 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500235', |
| 'properties': { |
| 'name': '云阳县', |
| 'cp': [ |
| 108.8306, |
| 31.0089 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lbLVVVnblJVXXKWbXLVxl@LmVXVVlnLWbnVmxXb°L@bVVkLVVVJn@@X_WmkUK@alUKX@@xWL@VXLVKlLKXLÆm@ma@ml@mU@UUmL@aVUU¯U°`lknLlw±@a@wmLVWaXU@KWU@ak@VaU@IUVmUUwVmUIl¥UwUVWUaVUUKVIUa@UUUUJUUmknl@@VWV@L¯aUbUlx@@b@VULUx@VUxVVU@bU@mxUU@mUVklkk@WxknlxK@amLKUK'], |
| 'encodeOffsets': [[ |
| 111016, |
| 31742 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500101', |
| 'properties': { |
| 'name': '万州区', |
| 'cp': [ |
| 108.3911, |
| 30.6958 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ĸĊVInaWWXlJVIn@lWVnax°xkl@²LVLnK@bLkwlmXw@lllkUnVV@VnwV@@aVUUVw@UVwVK@U@a@kwVVa°b@KXU@U@mkÇÑamlkUVmn@VULUm@kUVkUawUWm@Uw¯mKUUmVUUULUKUW@XbWVkaWwkUUk@maUbmbVlk¦xUVUIWVUkJVVkL@UmJUUVU@lLUVUlx@@VbJUL¯¤@V'], |
| 'encodeOffsets': [[ |
| 110464, |
| 31551 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500229', |
| 'properties': { |
| 'name': '城口县', |
| 'cp': [ |
| 108.7756, |
| 31.9098 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VK@w¯L@m@UÅV@ImVUVka@@aUkJ@LUUVUKmLmbÅVmUUwUaKUL@U@xJmbm@nVJ@X@VkVnlLXx@b@bUVLU`UnbU@@mVVX@JX@VLVVklV`@bUL@VLVKn@U@UJkn@lmLmK@X@Jn@mbnÞWVXnJkKČÑÆ@VK@knaÜmXlUČW°kôÇÆ@a@yÞ_VmUnU@K'], |
| 'encodeOffsets': [[ |
| 111893, |
| 32513 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500116', |
| 'properties': { |
| 'name': '江津区', |
| 'cp': [ |
| 106.2158, |
| 28.9874 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@InWUUlU@LValX@°²lÒXxlK@Ul@@Un@UaVJ@I@W@UUUVUwVIUKUaUUVwn@Üx@XUlnnbJ@¥VklKUUlk@ynU@kVUUVWnI@¥V£VWVIUKU@UVa@n@Vm@@nlUaVkUwJ@blLkLW@XWmXkmmLn@m@U@UVm@UVUUlakUVaVkV@@wnaWUk@VwklmVIkUUxmJ@U@KIkx±V@IUm@K@IUKkbWKUbnm@bmVnbmb@xkxUJ@ULW`@bX@WVXL@V¯mk¯@UJ@VmLUaWnX@WJ@nkKkxW@UIV@@KkImmkK@UW@XaWIU@UIkbWbxXlLVbnV@bWlX@VxVLnl@nÆÞVÜ'], |
| 'encodeOffsets': [[ |
| 108585, |
| 30032 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500240', |
| 'properties': { |
| 'name': '石柱土家族自治县', |
| 'cp': [ |
| 108.2813, |
| 30.1025 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@kl@¼UbmVXJ@bV@nxVIVJULVVk@@LWbnJVU@bVbUJ@blLXnWV@mbnV@Vbn@VJVLnaVanbl@VlVXxlbXUWaX@VUUVwUUVm@I@WmI@amlLlK@alwnUV@kóVaÝk@UlbVK@VU»VUUVWU@U`ULkwm@@KmU@knK»VkJkUmbLkbmK@UUyUU@awm@@XXJ@VVLVVUbVnUJVX@Kk`WXXJWXUbmW@bkLUm`Xnb@JVL@LU@°VVXKVnUxVLUbmJ'], |
| 'encodeOffsets': [[ |
| 110588, |
| 30769 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500237', |
| 'properties': { |
| 'name': '巫山县', |
| 'cp': [ |
| 109.8853, |
| 31.1188 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@kVUbkKmbVxkLmKkllbV@@LXbxlaLVVVKXXV@@bVlKV@ln@¼°KXaU@Ulw°JXalIUaÝWXW@kVU@VUVWUUUamUw@aVamwn@VUUlLXWm£@wÇĉkKklmLUÒ¯Wn@ğ±kwmaWm¼U@@LUV@V@XVUnVJLW@XXWbĸºVzXJVXV@@VXlWn'], |
| 'encodeOffsets': [[ |
| 112399, |
| 31917 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500102', |
| 'properties': { |
| 'name': '涪陵区', |
| 'cp': [ |
| 107.3364, |
| 29.6796 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@nèVblĖVVnL@xVn@nJ@LUVVX@lbUJV@@nn@VVVK@zV@nzVJVUlmX@@_VVVbnaVal@@knW@wnaVK@aVIJ@£kUVW@wXUVJam@Ik_X¥@WwkKkwmkUxnÅmm¥WV@Um@UlVL@JU@@X@UVkKVkKVkKkb@bmJVXUVVUbU@@`W_UV¯b'], |
| 'encodeOffsets': [[ |
| 109508, |
| 30207 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500230', |
| 'properties': { |
| 'name': '丰都县', |
| 'cp': [ |
| 107.8418, |
| 29.9048 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Þè@XUK@LlV@blbUJ@V@bnV@VVVXU@lbXal@VXnKV@maXUÞ@amk@aVKXVanb£°mnIVaUKVwUmWLUU¯V@@KUK@IaWmn_VlK@anXVaXWWIXWl_@LUWVIUmVaUUUK@UWI@Wn@VI@mkU@U¯Kl@ImVÅLwU¤óbUU@wWXkmm@LU@@VUIWVUL@JUnax@JnbUIWVx@UXlV@¤IUJ@bULmb@xmX@lk@UbmbUaUU@`W@kn'], |
| 'encodeOffsets': [[ |
| 110048, |
| 30713 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500232', |
| 'properties': { |
| 'name': '武隆县', |
| 'cp': [ |
| 107.655, |
| 29.35 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lwbVm@IVKXUVJ@UV@@KnnWlX@xVVôaV£xÆKnUVm@UmIXm¯¯@WkWVwmkXlaUwV»ULmk_VkK@ÅWa@aUU@mkaIb@n¼nm_@mmK@ULUVVmI@aUJ@XWJ@U`UIkm±kk@@lULmUmKUnVnlUVmI@VkVlxbkIVmLUxkKUXn¦ÆnmVwlnlxlLXx@W¦`'], |
| 'encodeOffsets': [[ |
| 110262, |
| 30291 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500119', |
| 'properties': { |
| 'name': '南川区', |
| 'cp': [ |
| 107.1716, |
| 29.1302 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VUbVJVUn@VLX@WVXVVI@VUVWxU@m@ĊX@@¼V°aVUX`@_V@VaUUVUWnI@alaLUlLUllLVU@@WV@@IUKVkn@@VlLVwnKUlJakwlU@UnJVUmkUVmXa@wVK@UUw@VVI@ak@alInwlKXUmaUW@wWLkKVak_ÇaUV@XbLVxUlWIk@UK@V@kU@VbUVUlVnLUV@lVXmxkV@L@V@Vk@WbUwmL@JUI@xVxkx'], |
| 'encodeOffsets': [[ |
| 109463, |
| 29830 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500241', |
| 'properties': { |
| 'name': '秀山土家族苗族自治县', |
| 'cp': [ |
| 109.0173, |
| 28.5205 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@XlV@lzn@VnbÆbXKlLUÒV@@llUnxll@z@LU@@V°b@Vn@l@VÑUnK@UU@aUakVm@K¯wklmnnUl`nI@almkIUwmWVkUakkJmUUa@K@aU@@_m@@wUyVUUa@Um@awl@Wka±UkUykIWVb@bUVk@aU@UXUUIWakUWmUxUV@nUVWb@XXVVmXX@VbVLkVWx'], |
| 'encodeOffsets': [[ |
| 111330, |
| 29183 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500114', |
| 'properties': { |
| 'name': '黔江区', |
| 'cp': [ |
| 108.7207, |
| 29.4708 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VX@V@LV@VJUL@lVnnxlb@VXVXV@@W@UIVK@kUKna@£VWUaVUUalIVJVIUW_lm@bXKV@mn@JUUw@KnIVll@VanLVmUkVKXLVKUIVamw@UaU_lwKlwUWV_Ua@aUa@KUwm_Ó@wU@nkK@am@UkUKmXk`m@@I@K@I@mkVmIUxUJ@kUL@JVVlnklWnn`VzUVnlWbkb@WxXxlJXzWÛlWXnl@Ll@Vb°UJWLX@VlV@bkJ'], |
| 'encodeOffsets': [[ |
| 111106, |
| 30420 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500117', |
| 'properties': { |
| 'name': '合川区', |
| 'cp': [ |
| 106.3257, |
| 30.108 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@XKVXlKVL@UnV@aValXXKU@WVwUaVU@IV@@aVWL@U@anVV@@bVK@UVL@bnJWL@VnUnb@@JnIlVl@@bXIWbn@UKVLVKXLlaV@VVnK@bVLmIV@KmknUUWVI@aVJ@_WU_VmUwU@KVak@am¯mJU_UJUkU@WkIV`UI@JV@LmmU@@mbUzÅ@VK@nUKbakb@UWK@bkVVbVÛ@@`Xk@W@n@lXL@bmb@VVJUn@JnUlnUlmX@`XLlbkJW@kzlb@`@b@b'], |
| 'encodeOffsets': [[ |
| 108529, |
| 31101 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500222', |
| 'properties': { |
| 'name': '綦江县', |
| 'cp': [ |
| 106.6553, |
| 28.8171 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@¦@XlVX@@UVKlVUX@lanVlUVbXWVXVVVUnKVUlwUwU@UJ@nmVkUVlwXam@VaUUUw@W@kk»mV@UmKkwVKVUU@@LUKVI@mV@XVWxnXVKUUUK@wWU@UUWnUlLXamUIam@wI@K@amImUUkI@makUkKWUUan@wamLVxk@UVmUUL@Vm@kV@I@ak@@bWVXJlLVbVL@@bn@@`Un@WbUKULWVXb@UVmbXWVb@bVmxUKUV@Un@V@V@nmnKlnnWWXX@lKkK@aIVxUlVbk@mn@@U@mbVUV@VLUJUXU¤'], |
| 'encodeOffsets': [[ |
| 109137, |
| 29779 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500233', |
| 'properties': { |
| 'name': '忠县', |
| 'cp': [ |
| 107.8967, |
| 30.3223 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VLÞĊU@W@¼V@lk@w²mlVUllVnI@VlKUUlIVXUVJVUwl¥UkUKUIm@aU@mUna@XUWmkK@aVIUa@aUVmIXa@Kl@UUVKUIUJmwU@@aWInUVa»k@@l¯n¤mabWUUL@bnl@bÝWVnbU@mLUWk@Wbka@WVUU@UmUmVkUULVlVUxl@L@VbÈÒlb'], |
| 'encodeOffsets': [[ |
| 110239, |
| 31146 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500228', |
| 'properties': { |
| 'name': '梁平县', |
| 'cp': [ |
| 107.7429, |
| 30.6519 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@XLV@VV@b°°nnkb@bnJWVXblIUVxWnUJnVVLVUJlUnLVK@UnUVJ²nKVbVKla@aXlJkKlb@U°£KVIUa@@kwVVUkKV@VUkkUVk±n@xkl@U@»@XVÝĉUJnxWb@UXKkVUbUKWUkVmkkLU`b'], |
| 'encodeOffsets': [[ |
| 109980, |
| 31247 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500113', |
| 'properties': { |
| 'name': '巴南区', |
| 'cp': [ |
| 106.7322, |
| 29.4214 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@nxnVlJlUXL¦@x@Vl@nKVVX@V_V@@KlVXU@lKlxXIl@ÈĊ@Vl@n_VJlnVlnb²VVVJVVmUUkĕUamçU@»W@@ĉnV@XwVU@UUJWUXUW@UKm@UVUIVaUUVmLUVUUUWWXUakVmUkbW@UVkUL@VW@kUW@mJUXVVU@lmV@zklVVkLUl@¦I'], |
| 'encodeOffsets': [[ |
| 108990, |
| 30061 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500223', |
| 'properties': { |
| 'name': '潼南县', |
| 'cp': [ |
| 105.7764, |
| 30.1135 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@a@a@_kalyX@lIkaWK@_nWVkkmmV@IVmUI@Una@aWK@k@mkbWaknmJUk@mk@@kUal@Ua@Wa@aXLlwUKlkk@KmI@VUJ@Lk@@VUUmL@amJU£kKUaWakLmU@bVVUbnbWV@xkL@bUbxUxVbXJVbUVWIUVU@kLWxkKWV@n¯VUbU@@VVX@VmaUL@VUK@VVbn@lVnI@@lnLULm@Ub@l@na@lK@XVVkJ@b@zl@@VnV@bVb@J@bnXV`lXXmVI@W@InbV@@aVKUblKVLUanLlmnLlK'], |
| 'encodeOffsets': [[ |
| 108529, |
| 31101 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500118', |
| 'properties': { |
| 'name': '永川区', |
| 'cp': [ |
| 105.8643, |
| 29.2566 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@bÜnWVLXlxVVxXxlVn@@bVblK@a@UnLVJV@@UnLVU@VXaVKVX@n`WUÿ@IUKlaUUUkWyUÛÅÝ@mmkUKUwW@Xk@amUUakKWwXaK@VVLklXVlkxVUL@bm@Vxn`IVxUVkLVUl@@lkXmmVUn@VV@Xb'], |
| 'encodeOffsets': [[ |
| 108192, |
| 30038 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500231', |
| 'properties': { |
| 'name': '垫江县', |
| 'cp': [ |
| 107.4573, |
| 30.2454 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Ċ°¤nÒ¼aV_lKnllUXVVLValULVW@XamwVIUKkaÇÑa@U@KkVwkUUVKlVnU@aU@VIka@akU@KVL@WÝçUV@Vmbů@LKnnJWVkxlL@VX@VxmnXVWxUb@bkn'], |
| 'encodeOffsets': [[ |
| 109812, |
| 30961 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500112', |
| 'properties': { |
| 'name': '渝北区', |
| 'cp': [ |
| 106.7212, |
| 29.8499 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@bVVXLa@lnbWn@L@XVlK@VVLUVlbkLUKVVVL@VnXVL@VV@UbVb@x@¦UxVb@bUJL@LVVxlK@nk@U@WUVLlKXV@VblU@UUKVU@wn@VJVanLlkX@VaVK¯@a@U@U@VaUKkUU±maUkm@UUkbm@@Vk@@JwU@Ub@I@JmwUL@a@@KkVÇLkWk@kUU@@xUVmKUnllUb'], |
| 'encodeOffsets': [[ |
| 109013, |
| 30381 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500115', |
| 'properties': { |
| 'name': '长寿区', |
| 'cp': [ |
| 107.1606, |
| 29.9762 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VVUbXlX¥l@XnVmlxUx@@blVnnôĀlm@aVaXwWUnmUwW@@UkKlwUXmImL@KÆ°na@UUImyU@@yULUUm@@mU@VIkaW@UUV@KI@mmUw@mKUnUUIlVLUb@@V@V@b°ULUbW@klmKUbUIm@@xUVVL'], |
| 'encodeOffsets': [[ |
| 109429, |
| 30747 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500225', |
| 'properties': { |
| 'name': '大足县', |
| 'cp': [ |
| 105.7544, |
| 29.6136 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@XUmaVaUU@anVlKXbValU@aV@@IXK@@bV@VxVK@UXLlUJXa@_@@aVKÅWVkwWawUa@am@kUWLU@kWmX@ykI@W@UV@na@LlLV@UkwWUKmXX`mIVl@bXLWVkbkkx@`VXm@@J@U@UUKUxk@WbUIVl@VXLWJUkUlUImxXlmb@X@VUJUnVbW@UV@@VVX@bnW@LVxUnlJUV@n@VxVIn@l`UVVVL'], |
| 'encodeOffsets': [[ |
| 108270, |
| 30578 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500224', |
| 'properties': { |
| 'name': '铜梁县', |
| 'cp': [ |
| 106.0291, |
| 29.8059 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VblLV¤nI@bnKVV@Ul@@KVI@UnJ@LlklVLkxWK@bXb@Vbk@Vb@ll@@nVlnIlmXblaXl@W@_Ü@UUalU@aXL@VlabaVL@mUL@UUÇXUWX_WaU»m_@UWULWb@UUVmK@VU@UImK@V@bkLxXblxXUÆUL@b@@`WbIkVWK@VULUwU@@a@WL@JU@@bkVUb'], |
| 'encodeOffsets': [[ |
| 108316, |
| 30527 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500226', |
| 'properties': { |
| 'name': '荣昌县', |
| 'cp': [ |
| 105.5127, |
| 29.4708 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VI@U@WnaWknwVJVkVlIXWK@UUkVJXal@VwVL@V@V@In@UW@_wlllaXUWK@aUknJW_Û@aWaU@@UVmUUaUImJVnÅUmVUm`kUUVWLnVU@VVmXK@nxmULkxImJ@nU`@X@Vkn@`@nlV@nVJVaXVLnK@bVV@nV@lbXW@'], |
| 'encodeOffsets': [[ |
| 108012, |
| 30392 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500227', |
| 'properties': { |
| 'name': '璧山县', |
| 'cp': [ |
| 106.2048, |
| 29.5807 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@XzVlVVkbVL@JVĀX¼VXbW`XWVÈVVVkV@@UXa@alK@IU@UKWUyUI@wVUUWVak@VUkW¹@WXI@yVIUK@kWwkѯ±W@kUb@KkVVVmXJ'], |
| 'encodeOffsets': [[ |
| 108585, |
| 30032 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500109', |
| 'properties': { |
| 'name': '北碚区', |
| 'cp': [ |
| 106.5674, |
| 29.8883 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@XVLV@@JkL@bWb@VU@UlÆVya@nV@nn@KU@IVJU_lJXV@VlVIV`nIn°@blUbKVI@aUaVw@¥@wUaVaU@@UUKWm@UUKUUVLlKkaVUUK@UkLWU@@KXmma@kbWKUU@aUamLnÞ@VWLk@@Wm@ULU@@UKUVWI'], |
| 'encodeOffsets': [[ |
| 108855, |
| 30449 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500110', |
| 'properties': { |
| 'name': '万盛区', |
| 'cp': [ |
| 106.908, |
| 28.9325 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VIV@@wVJ@InKVxXal@@U@U@KlUnwUW@kVUKUmVkUa@I@KW@@bk@@mU@m@k@a@aIUxmJk@wULwkKmVVX@VXV@xVLVVULmWXwWUU@@nUJVL@KV@UVULlxnL@VnUl¼@l@XVxVVUbn@WbkxUlVnU@m'], |
| 'encodeOffsets': [[ |
| 109452, |
| 29779 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500107', |
| 'properties': { |
| 'name': '九龙坡区', |
| 'cp': [ |
| 106.3586, |
| 29.4049 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@XKL@V@XbV@lW@UV@@VXIV@UVKlL@KnnJ@VV@VU@I@@mVUVWUUmL@V¯LUK@UV@UU@a@U@yU@WLUK@X@KUVmL@@aXI@w@ammVk@WÛwm@UxVVVbVLUJVxVUV@V@X@JUIVbm@@Vk@@VkL@lVLUJ@zWJ@X'], |
| 'encodeOffsets': [[ |
| 108799, |
| 30241 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500106', |
| 'properties': { |
| 'name': '沙坪坝区', |
| 'cp': [ |
| 106.3696, |
| 29.6191 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@XºlUVl@UbVXUV@xVJVzXJVUL@VV@VKn@@Xl@XK@UmÝnKVbVakkVm@kUK@UmIm@LkKULVU@WJ@UU@@VkXU@Wa@@UKWL'], |
| 'encodeOffsets': [[ |
| 108799, |
| 30241 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500108', |
| 'properties': { |
| 'name': '南岸区', |
| 'cp': [ |
| 106.6663, |
| 29.5367 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VVJVL@bUVVnl`XIlwXJlw°nnlIXW@UÇĉk@WJkwkL@WVkU@LU@U`W@UXUV@n'], |
| 'encodeOffsets': [[ |
| 109092, |
| 30241 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500105', |
| 'properties': { |
| 'name': '江北区', |
| 'cp': [ |
| 106.8311, |
| 29.6191 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@nLVU@wV@lV@XllÈKlU@L@@bVKnx@I@JVaV@x@Il@@Un@laVVn@mkUIm`k@WXJmk¯mkxWIkxWJk_UmVUUK@UU@@l'], |
| 'encodeOffsets': [[ |
| 109013, |
| 30319 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500104', |
| 'properties': { |
| 'name': '大渡口区', |
| 'cp': [ |
| 106.4905, |
| 29.4214 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@k@@U@w¥WKkVkImUmwa@b@xWJ@b@nKVU@L@WVLXKV@@z@V@bVVU@@VVL°K@U'], |
| 'encodeOffsets': [[ |
| 109080, |
| 30190 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500111', |
| 'properties': { |
| 'name': '双桥区', |
| 'cp': [ |
| 105.7874, |
| 29.4928 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@WwUwU@kK@KmbU@@V@XlJ@znWlXV@XK'], |
| 'encodeOffsets': [[ |
| 108372, |
| 30235 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '500103', |
| 'properties': { |
| 'name': '渝中区', |
| 'cp': [ |
| 106.5344, |
| 29.5477 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VL@VV@VL@aUKIUU@@JUVU@'], |
| 'encodeOffsets': [[ |
| 109036, |
| 30257 |
| ]] |
| } |
| } |
| ], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/util/mapData/geoJson/fu_jian_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [ |
| { |
| 'type': 'Feature', |
| 'id': '3507', |
| 'properties': { |
| 'name': '南平市', |
| 'cp': [ |
| 118.136, |
| 27.2845 |
| ], |
| 'childNum': 10 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@knyk@KU¥wV@nkWzUmk@@lKUa@aVI@UKUamKUUVaUI@X@UV@K±IUVVlUbUbUL@KWUXmWk@KkXmmkÅKUa@amUbkUkKWUnwUÇwVUUÝUKV£U@nKWwXLVKm¥@wUXkmWk@@wX@lU@yVImaXwV@knU@mbk@mlUXmU@mV@n@bnW@bUIWJImVUKWbUK@nkKaU@W_VUUmWmL@UU@bUWUL@V@bmVUz@`mUUVVbXL@VL@lmLUxmVamXkW@xWbUVbUxkU±@ÅUmmkLUbW@@`kLknVlV@lbXxlVUXVVUU@UbWkIWVUUUJkI@llbUxVL@VVUU°ULUmWXUV@VULWb@xm@UaVLVKUa@w@VbkmVambUUm@@VkK@@bxlxX@n¤@X@@lkLWV@nVkb@bWJXLWx@nkxmmbXn@VWVUn@VnJ@bVXl@VJXnWbX`lLUlJVI@@VXV@Vl@bn@@Æmn@VxXU@mVIlxVnIl@nVJaXI@mlU@aXkVm°klmnVV_na°@V@xܦXKVnnUlVXbVKLXKV@naV@@VVl@@lXblXWnLlbVK²n@@VLUnlV@lXxô°V@UnaUUlKXLVUVVUbVVlUnJVX@VW@an@lb@nl@VU@anUVW@kaUm@InVVKVU@kUW@Uam@km@kVa@a@nwU@WlI@mVI@WXaW_n@nlkkW@U¥@kV@Uw@wU@@IXK¥VIn@nU@`@Xl@VVLnaWbVaUwnU@VIKlV'], |
| 'encodeOffsets': [[ |
| 122119, |
| 28086 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3504', |
| 'properties': { |
| 'name': '三明市', |
| 'cp': [ |
| 117.5317, |
| 26.3013 |
| ], |
| 'childNum': 11 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lL@Un@VVnabnUla@Ux@VbULUKVbn@w@XaVK@UVUXWVnVKV¯VU@UUKVwka@klJVIVVXUlJXVaV@VUUVWkUWwkaU@UklmlK@_X@ValKnnÆV²@lVVwUaVXa@wlXnWbnUVwnK@kK@UWKUaVUnV@_VynU@a@UVKVXaV@@VnKnXVVUX`V@blL@mVLXaVLnUJXIVJ@amX@a@mnUV@nVWnkl@naV@ml@@KmKUam@UU@@UlKUVkUK@aVaUwVU¥UIkJ@wmI@mbkwkVW@UXKULU`IVKUa@LkkVmUU@WlULUWÅU@I@WWnU@@w@a@Uam_XyVIVWkk@mwVKXUV@nwVXkWÅU@aU¯KUnK@¯mULXVLnWVbVbUVm@Ub¯¼W@am`kbamLUUUaUXV`@x@XmJ@n@L@xkJUU@kU@mWm@kUUwUUVWl@VUkIy@kkaVUUmIWVXbWxU@kmVkK@nWVX¦WxU@@bkx@VU@Wk@kUbmJUUmkUW@_kKWK@knV¤kIUKWLUbV@Wbk@@VWL@VkI@lUXVxUVU@@mWIV@a¯nUaaUV@Jb@bÞ°VbU@XaUVmL@VXblnV°n@Vnx@VUUUlK@InJVb@Vlnn@VL@VWJUx@XlJUVVVl@LUUUJ@L@lUL°¦kVVnV@xVl@blLnlLVaXll@nVUn@xn@nml°X@lb'], |
| 'encodeOffsets': [[ |
| 119858, |
| 27754 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3508', |
| 'properties': { |
| 'name': '龙岩市', |
| 'cp': [ |
| 116.8066, |
| 25.2026 |
| ], |
| 'childNum': 7 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@aI@VUbVb°m@bUXJ@nV@VUUwVW@klJ@UXK@Ul@Xa@UVaXKVLlJU£lm@XLlL@`VXnlVVnIVall@XV@@Ulw@aV@XwW¥XU@mlLnUlV@XwWaXUJVnUVlb@lzlJUVk@UXVVVxlVn@nXV@@lVVlI@w@K@mnI@W@wU_VWbVVVnKbla_nbX@°»Van@VUUaUamXUKWK@a@Uk@wWkXWW@wUUKw@_lywUkU@@U@kamVmXaUVUka@Wk@»UUUVKkbWUVUbk@mkxkKnIVUmW@kUKmXUmVaU@kU@m@KUWVkIWJ@U@UI@wUUUa@KW»nU@mVkUmm@XwWU@UUmL@w@mnVUU@aWak@@amxU@UxULWVXbVLU`mbUImVUbnV@@bVn@bnVWxLmyUbIUK@aVmakbVUXWUlKWbkV@WLUlk@@nbb@lkKmU@UIWJkw¯UUVVxm@@XkbWxXKlUzWJkUUL@bmKkV@@VUIUlWV@XK@VkbWx°xUb@LUbk@@VWb@LXJ@VWXU@@bUVVVVn@VVlLn@l@xk¦Vx@bVJXbn@JlnXxV@@nJ@X@V@lmxbUn@xVL@VVKlL@lnLVaVL@xkl@LxVl°XWVXVlJWnxlJ'], |
| 'encodeOffsets': [[ |
| 119194, |
| 26657 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3509', |
| 'properties': { |
| 'name': '宁德市', |
| 'cp': [ |
| 119.6521, |
| 26.9824 |
| ], |
| 'childNum': 9 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@LVKVaVaUkVU²J@LVU@@WVJUbVVnLVbL@VUJ@bVbkL@l@VnyXmlU@xV¦L@lmz@lnL@bVVbVb@lnKVkVl¤@zXV@l@XJVLVKnXVKVnU@wUm@KU@UlVlw@U@U@UaUKlU@kXKlmXIWKXaVIVUVK@KU@@kJVUnLVJUL@VIVa@VnLKUnl`VbVV@Vbn@Vzn@lKnVlIVVKUalkXJl@XXVWVLVUUmVU@Unm£lK@Uk@WUXK@U@WVwVkĠkĢÇ°aUÅUwmaţɱUÇaw±V¹XalKôx@UVaÜʓͿVóbÅLJm¯Vk¦k@mamXkKUULakbk@mV@LkJWb@VkmXk@UVmaUV@amLUKUamI@KUaU@WbU@UUUUIWJUkm@wKkVJm@kxÇVUK@mUVUkmlkkVm@amwLVWU@UbVLkUb@VmK@XaVWU_VJnwV@@kUmWakx@kwWakIWxnbUJz@kVW@@x@XllnVW@xn¦ULWKXxmL@VU¤VLÞVVUÈxVmxXVlLlVanV@bbVLlÆnnlW@LXlWnXV'], |
| 'encodeOffsets': [[ |
| 121816, |
| 27816 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3501', |
| 'properties': { |
| 'name': '福州市', |
| 'cp': [ |
| 119.4543, |
| 25.9222 |
| ], |
| 'childNum': 9 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lxna@nJ@xlIVJV¦UVxUb@bLVUlVkL@V@VVn@VbLn@LUlJXblx@lwXbVn@lU@mxUIV`UXWb@nLU@ValUKVaV@UXKnxbn@lUkllnUVnV@VLUÈlwn@UIlLxn@VlXIVJVVVV@XaV@Vb@LnJVbVLnK@bVUnbVUl@nWl@UXalI@KnUl@labVKVlLnWnbl@l¥°UnIÆKôaUa@UUwÇWǓIUWUÅVkƨm@@£@KmLU¤ULˣJkUVǟUUķ@ĉVKUk@Ñ°wôÇç@īé@Åţ¥mīÛkm¼Å@VķVó°ō¦U°n@bVJXVVL@bUakLmx@xmxXzW`XbWnXV@bWLÛ@a@aXbWVkaÝwU@mlWKkLWWkLUKULW@kVmVUUÝUamV¤n@xUVUzkJV¦lJU'], |
| 'encodeOffsets': [[ |
| 121253, |
| 26511 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3506', |
| 'properties': { |
| 'name': '漳州市', |
| 'cp': [ |
| 117.5757, |
| 24.3732 |
| ], |
| 'childNum': 10 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@bl@Xb@bVVUm@nx@nKVV@XVWxn@VnUl@nmVX¼@LVbVV@xVJV@@XIlJXUV@Ln@lVV@UbVnnWVL@lnXUVmJLlwnll@VaUXVlaLVUVV@¼Xl@lbUVVWbnnUlb@@VV@aVUmlUaUny@kU@Wkk@WaUVk@@ammk@@U@UlU@aUa@wl@mXLllnLU@anVnU@L@VVV@KlXnWVnVanUw@w@wmnÅ@waUam@UkmUl@@aa@U@¥kôKwȯ°w@ŻkwǕaKÑÛk@ĕōřċ£ĵUKW»kÅŻLU@Ulġw@¤VzVUbkKUbmLmlULU¼UxmbXl@bWVb@bUnVUVbULU@@VkbVL@`U@WX@XV@b°@b¯@¤@Xm@@b@`UVVUL'], |
| 'encodeOffsets': [[ |
| 119712, |
| 24953 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3505', |
| 'properties': { |
| 'name': '泉州市', |
| 'cp': [ |
| 118.3228, |
| 25.1147 |
| ], |
| 'childNum': 9 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Vlxkz@`xLVV@xXXWXl@xl@V@bnV°@LVm°LVbV@ÆXWlUmxU@WVULnx@llUXUJWzn`Vb@@b@xV@mXX@@JÆVVXVKXkV@nVlUl@KVbULJV_VKLVWX@lUVkIU¥lIVyVU@wm£nUVWU@am@UmWw@UX@@amVUn@@aUUlUVanaWUXWmUnkK@VUlVVUUw@XLWWXma@knmbVbVXbVL@XJlInlLwmXów@çV»ÇçŋaķƧóƅóKġ°nÅUķƑUÇW@¯xÇ°öÆlVn@lla@Lb`@VXVVx@V@bULVJUkÇ@¼XUKk@mmULkaWbk@x@UkL@a@K@U@UmKmbU@kV@UmVUbUmmXkW@LUU@U@KmVmU@bVmKkkWKnk@@xVb@bkV@V@Vl@nn@bl@VUXbl@XlV@@lmzVVbknUVb'], |
| 'encodeOffsets': [[ |
| 120398, |
| 25797 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3503', |
| 'properties': { |
| 'name': '莆田市', |
| 'cp': [ |
| 119.0918, |
| 25.3455 |
| ], |
| 'childNum': 2 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VbÞVVnUlUX@VKVLlKXXlKXLnkV@ÞxlbXUWab@bÜ@XK@aWUXmWaX_Wynw@wnwlKbV@aUKWUUI@amV¯Ŏ¥ô¯ĸUUÆ@n»¯aƿé@ţ¯nĉĬÝKóó@ÑU¼@èxWônxKmkkJWI@UKWaUUaamn@lnbWXXWK@VxUVkUV@ULmlnVWXXVmbUbkVVV@bm@UVn@bW@@VXxn@Vn@bVUX'], |
| 'encodeOffsets': [[ |
| 121388, |
| 26264 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3502', |
| 'properties': { |
| 'name': '厦门市', |
| 'cp': [ |
| 118.1689, |
| 24.6478 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@VlUV@nanL@V@V@L@blK@Vwl@XalbVKnnl@VLW»È@lVUIVK@a@UUwWUU@_aK@bkkm@UkõÅxóLl@¦@Vb@bk@VnVln@Vbb@xmÆn@x@xx'], |
| 'encodeOffsets': [[ |
| 120747, |
| 25465 |
| ]] |
| } |
| } |
| ], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/util/mapData/geoJson/gan_su_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [ |
| { |
| 'type': 'Feature', |
| 'id': '6209', |
| 'properties': { |
| 'name': '酒泉市', |
| 'cp': [ |
| 96.2622, |
| 40.4517 |
| ], |
| 'childNum': 8 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ÇnÅaĉ@U¯¥UŹ£WUýUU±JkkUwyÞIČxĊĕĊ¯¥ÆUkţUÅÓ±¼IUx¯UÒƑÝÅ°KÝnğ°ÅU@@Vn@þ¼¯WnŎ°XLWlnVnbWnVXxmbabóUlǕUUaIUmlU¥k¥ĉwkkÝɛa@¯U¯°mVkVnKlōÑÇÑU@klUġkUŻnUW@¯k»mWV£UKnUmUww@UIVaXwm»Èmmwn¯ċ¯LĉUJUalka±Va@Uk@ÛѯWmnUaɝ¤Ûmn¯m±x@wóxÛLġÒUx¯VÈJUbózÝÇKĉ¯ōlÝUÅWl¯nťbÝ@¯ǩLġmV@ƯĢkÆmĊkVťLɃmÝXó°@ĢbVóVݦɱ@ƧaġUVĠÇÈV¼UVţwmbJÇwˋaXmǯKkkmbXm¼V¼ǬŚ²¤ôŰÆƴô̐ŤǪnɆӨ¼ɆLÆłUĊxŎƞȘǔˎǬǪnƨŮǬö°»ġÞÜÆĸÒĊǀbƾèôÈ@¼¯þŤĸƧ°VĀ¯b@lÈĊʠń̐ȘKǀֲॗţÿǕý@ʊǓƨóÆÑǖŃôw@ʈƆÅÈVVĊVóĊÅ@ÞƒĬV@Þī@°V@ĸĢ°XτƜĠ@ÈaÜ¥ŐƅnğóĕVġUůƿŋĕa±VUťÇğÑ'], |
| 'encodeOffsets': [[ |
| 101892, |
| 40821 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6207', |
| 'properties': { |
| 'name': '张掖市', |
| 'cp': [ |
| 99.7998, |
| 38.7433 |
| ], |
| 'childNum': 9 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ÈÒŎÒkmLUlU¯nV°@°ɜbÞĠaÈ»ĸlLVUÈ@Ċ@ýUm@@ÆVĠ¯ÞmLƯރѰVVwJ²»ÆÔVlŤÅV¦ĉ°ĉĖċwÝJzVxll²IVVVþX¤źV°¦VĊ@ÆbÈmǔLĸĠ¯Ģaô¯ĸmÆÛUlÇĸk°XyĊUǔVǩnmV»a@ýnK°n@l¥@»żĊ¤mç@£ČU@mmVkÞUƐ±²¹°ĠwÅƑŃU¯V¯aÈŁÇ»ġn_°xŎKlxklx@Þw@Æm²bDzLlkWXať¯ĊaÑK±w@wUÅçV±Uk@@¯¯xU±±UU°ōxVxÅÔō°ó¯UݦóbÝþ@ĉÈóUVUx@VUVÝwÅÈÇóVkk¯JÇkmmL@KÇx@bk@U°ķ²ó`mn¯°UwlÅkU`¦ɛôķz@ÅnÇ°U¼¯KmVk²J¼ƏÞķô¤UL@mnğ`ÇnUxÇ@ÛÿU@kŻ@x@móJkÅ¥VŹĉóÒĉlċ°ķUƽÜ@x'], |
| 'encodeOffsets': [[ |
| 99720, |
| 40090 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6230', |
| 'properties': { |
| 'name': '甘南藏族自治州', |
| 'cp': [ |
| 102.9199, |
| 34.6893 |
| ], |
| 'childNum': 9 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ÞnKlnwX¥WÝXkxÞUn°aĊVnUUKlÞĶWXnĠ¥ô»@nmVL@¤°VzJanU@aÆwna@kU¯yX_aĉbwéXkWwÅa¯V¥m¯UI@@mb°aÈçU¥@»knwɜƇ°I°ÑÈmVU¯Xa@wW@wV¯Č¥l¯Uwnm@kaUaóKkk@Çab@ÒWa¯IÇxÛam¼VUxÒl@zÝÒ¯bÝaĉVĉwÇWzJmJn²mܯU¯ĉ@ġ¤Åb@²nml@@ULVxVU¼Ålmab@°l@WIU¯@m@ó@UzţyXÇUÇVUUVLkbWakVWmUbkkKUÆ»n°Knk@aUVmnk»l¯Ģlw@_kKVU@na@lUk@¯¥mV@kmbWb¯Åõa@mkU@kÇkU@`@óóbl¼Uxn¼lVÈx@blVkVVn`XÈġÈ@ÇK£ÝJmUUnUĖmlUmKUnVÅaUwUĉ`¯n¯wW¼nxV@bĉnkIċŘkXU±ÒxÈ@X°`lVIȯĊVVVan@VaUVażVmblkÈWWIXaalL@wVbV¦lL@lĠnÒUnkL@ÆÞkÞKbñþW¦ÛċVULUºkÈlŎUxÆxÞUUxÒx@XbL@lÆ@ÒlXVln@bm¼J@Ånx@bnĠmxVXmbÈè@Ċ£ČWw'], |
| 'encodeOffsets': [[ |
| 105210, |
| 36349 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6206', |
| 'properties': { |
| 'name': '武威市', |
| 'cp': [ |
| 103.0188, |
| 38.1061 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@±¯¥@klwU»ÞÝmwKm¯ç@kVÇUL¯lVUKġġm@a@U@X£°l°LŎÇ@aōVÝwÔKUÅWJ¯lm@ÛVWa@klĉUmaLUanak¯J±KkXóÜÅx²Ç@nUÒĊb°@ÆkLXÇÆ@xÝnxWxţ¯¤I@ÆnVVVlU²ÆèV@x²xLÒĉbŦ°WbXklÞ@l¤XĊ`wl@ĢÈŎm@bnVUb@ÈÆÛLèÇUÒŦlĸ`°ĮʟÆǓbĉôϚĊÆĢnŤéÑĸĀĊ¦@@l°l¦Ȯ¦ɆÞĊKŤĵĸů»mŁyġķŭ@Çɱȭ¯mƧUĊķnŁŻ»UaUƛɞÝƨů'], |
| 'encodeOffsets': [[ |
| 106336, |
| 38543 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6212', |
| 'properties': { |
| 'name': '陇南市', |
| 'cp': [ |
| 105.304, |
| 33.5632 |
| ], |
| 'childNum': 9 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ÈÞ@l`UmV¼@nnÆwVlnVVaLVÈ_ÿÞ@naxÆ@l_@VxnK@llLnxmÈŎJnbUxI°l@n¦lÈIlmX¥k°@kJk²é@klaUaVaU@@ÝnIWnmnxkºÞaV°V@nwKxôbÞ£VUbþLn»mVwIJ°@nb@°°IġUkÇKV@ů»lLnm£@anK@ÑÜn@»mL@£ykUUmbUÞÝ@kyÇbó»XUxWVzb±mÝbXawUamL¯»@wUKVwm¯ĵJ°ÅUWVkKVk°wÈVVÑlU¥kmVamknUw¯¯bċ¥ÅKkKkVċVk£kKVwÑa@kóyÛ¯ÇVkówXō¥Ç¼ów¯U±k@xIĉÒÅVmÈnÜ@n°bUbÝVUnnJ¯Į@m¦nVÜ@L°JXbÑ@aÈb@llôLVbb@lmnVxk°ċ¦U°@xX@xWb°UVÇn¯Ò¯Jɛƈmxl@¼'], |
| 'encodeOffsets': [[ |
| 106527, |
| 34943 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6210', |
| 'properties': { |
| 'name': '庆阳市', |
| 'cp': [ |
| 107.5342, |
| 36.2 |
| ], |
| 'childNum': 8 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@kwĉ»VamV¯wIóVkl¯KmVō¯ÝWkL@bÝKō¦@@Lx@b@la@km@@l¯nm@UaÅ@óWUXm¥nw`@UUxķôÇ°ğ¦@VJ_nIVnalxkXJWn¯nVLxl¤nnVbklVX@xnxmV@bUK@nm@@xV°±aÅnkUWnUax@mn@¯LmUĀlU@lV@blLUblxklkIÇx¯°UXbaVUnV@°LUlnbX@`°nVmbnÆmVkLmK¦U@Xy@kl@U°K@¼XbW@bWnLVaVVz@xlVČ¥lbUxÞlVU@nÆWôn²VJlUƧLnmÜLXan@mw@wlUlV²mblwVÈlLÞ±@lVnUlxnkma@mkJ@kXVU@mn@¼VXUVlLnmVbôaVnWV»ÈUl°È¯ÆInÆU@kk»mKkÆġk¯@»mk¯@óÇlÇ@VykklUml¯Þ@w'], |
| 'encodeOffsets': [[ |
| 111229, |
| 36383 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6204', |
| 'properties': { |
| 'name': '白银市', |
| 'cp': [ |
| 104.8645, |
| 36.5076 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VKUÈl@è°nLnxÝÞV¼kx@l¦²°ĊóĠĊ»@ÈxaĊxlwÈVŤa@¯²aÇ£Jk£lnUÞ@°ô@ywl»lIX¥Ǫnw@ÑÞWlaÅlL@Uwĉakl@¯mwna°JV¯nUVÓÞÑm£²óWaUÇ@óÝUçV»ÈkkW@¯xV@XlK@wX@Vmm_@wÈÝKU¯ÇwVwÅK¯VkJXkWVaIm¯UkÇlVĀV°mxók@¼óWxĉÜU@UbzÛJÇk@ÆnVlÔ@kxô@ĬWL¯K@aÛImm@IUa@UÇêU¤VÒÇx¯ÒVlk@Wbĉ¦UbkWV_y¯Laók@b@nmbkx°'], |
| 'encodeOffsets': [[ |
| 106077, |
| 37885 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6211', |
| 'properties': { |
| 'name': '定西市', |
| 'cp': [ |
| 104.5569, |
| 35.0848 |
| ], |
| 'childNum': 7 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@aV²wVJV_@LlanÅllŦçÜÓ_lnWaôkxUbmV@È°lènk°l¦`@nnL@ÈlÜIyVaV@ĊÛXwô@»lônwU¯ÿUÈkl°VnJUblXWIl°UV@aVVVmnL@lUUwmk£bV¥VUVwÛlaÇÝÞmk£LUy¯L@WlkKW_XaWmġU@akakXkmVwmŹVUbWónmwnWW£KÈnV¥¥Æ_klWbU¯V°aôbnaVwmaōInÇmwkK@kmLUw@`kÅ@wb@mÝĀÇ`UKUbmUUkÅxmm@»nUVk_Ý@ǦVÇè¯ban@@JV°nU¦°ÆbXxWlêxĊabW`zV°@lmbÅx@bmVbI`¦@ÒUVUI@ÆL@b¼@@lmxnL°ULÞğÞ°kLUL°xVnKVl@zX@'], |
| 'encodeOffsets': [[ |
| 106122, |
| 36794 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6205', |
| 'properties': { |
| 'name': '天水市', |
| 'cp': [ |
| 105.6445, |
| 34.6289 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@UyÈVVUnn@VU`UblzJnk@VbKU°lwW°nkVUÈl£°V@n¥VklkU±Unlw¯UkwmKUlmkUmnkym@Å@UmWÈU°l°anlJkUKlU¯Èm@kmWV»kkÝLUWUx±b@¯ma@¯IJUxnm¼KýaVUݤóawLmxU@¯UbݹlmwmnXmJ@ÞV@UbVbkbl@±êlIl¯@lW¦knÇJkm¥k@¯Jmbóa¯bUV°akXlÅ`¦U¦ÇmLX¤mXnxmôXaVźUnUxlnlWbl@bĢVnXWbX`lLXk@°KVzKl¤nÞÝÈkbÜ'], |
| 'encodeOffsets': [[ |
| 108180, |
| 35984 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6201', |
| 'properties': { |
| 'name': '兰州市', |
| 'cp': [ |
| 103.5901, |
| 36.3043 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@lW²L°IlmbVbKnbĊVlk@XbÜU@kn°XIÆVLÓÞxŎUlôb°KzU`lXVaĊ¥Xal@kU°ÑÈwUÑV£ÈéV@VbJ@nnÜJ@bL°XK@īówl@kÓmUÅmK@m_k¥l¯mkçǯ@nUaVwólXbmk`ÛÔťèkkmÆkbK@U`UI±xUbWlXmbVbÅÒólkIWJk@zKŻ¼@xUxó¯LWb@ÅÒ±¦U`nbťĀUVbLU'], |
| ['@@¯lwna@mōȯK¯kW¤@@V@bĢnĢVLU°k'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| 105188, |
| 37649 |
| ]], |
| [[ |
| 106077, |
| 37885 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6208', |
| 'properties': { |
| 'name': '平凉市', |
| 'cp': [ |
| 107.0728, |
| 35.321 |
| ], |
| 'childNum': 7 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': [ |
| '@@ÆLUxÈxV°LÇÞ@xn`Ü@X@nĊÆwnJmwUxaUkw@V@waVmlLXÝl@XVĢmV°@nl@UUUWK@wÿVI²Òlm@nÝĊýVV@nJ°Ułm@kV¼nKĢȤôKblnKllVk²aĠ¥È¯ĸóVw@V_xmn¦VWôXÆ@Vbn@°m@kn@@lb@ka@wK@@UlKVaWXW²¹lÓw@_°n@@_lKÅķW@mLUWn»Û@l_Ç`Ûmm°ÅbWb@VWbUUKÇÅaġlmkUġl»LlUm¦@¯U¤ÇkVUml¯Xx¯kVLUa@mlIkyVa_UV@mmUVUÇVzUxUVU¦a¤lnVxVk@mKUnUU@bU', |
| '@@@ż@mlkġk' |
| ], |
| 'encodeOffsets': [ |
| [ |
| 107877, |
| 36338 |
| ], |
| [ |
| 108439, |
| 36265 |
| ] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6229', |
| 'properties': { |
| 'name': '临夏回族自治州', |
| 'cp': [ |
| 103.2715, |
| 35.5737 |
| ], |
| 'childNum': 8 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@ż»Ly@lXIJlôkÆÑUanaWXkW@yk@ULmUw¯KVlK¯ĠÝÝVK¯mKnwk@@»@aK@ÅVJVU@Ñ¥_Uy¯@£UKmn@ó¼ğ¦WmĵXÝkVLmVĉU¯bmÝVwWlXÞW¦xkmmLݱU@VÞ@ÅÈW°XܼƨyUĮnWnXÝxUx°lVXJlôV'], |
| 'encodeOffsets': [[ |
| 105548, |
| 37075 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6203', |
| 'properties': { |
| 'name': '金昌市', |
| 'cp': [ |
| 102.074, |
| 38.5126 |
| ], |
| 'childNum': 2 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ĢÈ¼Çł°bU°VƒńÆǖŰnÆōĬǔaʠůĭ_kķÆ¥VÑÈçÜKÅ@ÇVaUm@aōnġÇk@xĉ_Wk£@ݱKȱaÅn@Ýx@kwlkwōL¯wm`'], |
| 'encodeOffsets': [[ |
| 103849, |
| 38970 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6202', |
| 'properties': { |
| 'name': '嘉峪关市', |
| 'cp': [ |
| 98.1738, |
| 39.8035 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@llĊx¦l¦kVVnJVbǖVkôVabnaWwUXmmamUXkWKō¯Xm°»ĉÇ@UVKķkǼğb'], |
| 'encodeOffsets': [[ |
| 100182, |
| 40664 |
| ]] |
| } |
| } |
| ], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/util/mapData/geoJson/guang_dong_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [ |
| { |
| 'type': 'Feature', |
| 'id': '4418', |
| 'properties': { |
| 'name': '清远市', |
| 'cp': [ |
| 112.9175, |
| 24.3292 |
| ], |
| 'childNum': 8 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lǯkÿaV¯VaÈU¥ÆÇIlxmnbUxlUôl°kWl@ôVwUanUl@xVkaX¥kU»a¯±@kka@UwmUkwJk±k@L@ÝWUwVÝxÇU¯ÇX@mÅ@@yĉ£VmUwȗ»ÇUnlUnWU¯`Uk@@x@bÇxX¼VV¯LĀkÝL¯@VĀ¯lnĊW¦kVÇôkUÇUK@ţU@aóÜUU»@¦k@VxKVbn@Æl@xbWnlUlxÈlVÈ°Æ@¼@xWxŎVK°¥nÆkŎ@ÈÑmK@¥k@ô@nôV'], |
| 'encodeOffsets': [[ |
| 115707, |
| 25527 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4402', |
| 'properties': { |
| 'name': '韶关市', |
| 'cp': [ |
| 113.7964, |
| 24.7028 |
| ], |
| 'childNum': 8 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@WXk±Ñ@UwmUwĉwlmn@Æwn£mkI¥ÇÅ@¥aón£nWWw£V`Þ@nVml@xô¼IV¥kUmkamUkVWwÛ»mó£UVÅKmn@x@kbmm¯aXkaVĉaUbݲlIlxnVVx@lb@l²°bV¼lW¦bUlwk@mVVbUxó@kX¯lókVkwVmankwJÅȦÇVUbU°blĀ°kÈ@x¦ÆÜ°@°¦óaVUôlUlbXl@nÜVnKlnIVÞ°W°U@bnm@¥IV²Ul°VnalzXyl_Vyƒ¦lLlx@ÞbKmknVWanwÑVwČº@n_ÞVaVÜIl@KÈVJ@a£È@@kmaV¯W@_a¯KmbkÇkLmw@Å¥'], |
| 'encodeOffsets': [[ |
| 117147, |
| 25549 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4408', |
| 'properties': { |
| 'name': '湛江市', |
| 'cp': [ |
| 110.3577, |
| 20.9894 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@kX@aUUċlkJk@wVJXUWk°W@nKnwlUl²blU@lIl@XbWxnm@lW@wwUJX¯VU°`ŎóˋkÝÝkÅ@ÇmğÈřmwaĵVxUÛ»°ĠǷnýmóX¥ɅĵҏÇ@°²ĊUĖ±ĮU¤Ç°Ā¯ɐnżUĊĊĬV@è@ÔÒU¼l¤nĠbêVĠ°ÈyzVaVnUÆLabVlwÆ@'], |
| 'encodeOffsets': [[ |
| 113040, |
| 22416 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4414', |
| 'properties': { |
| 'name': '梅州市', |
| 'cp': [ |
| 116.1255, |
| 24.1534 |
| ], |
| 'childNum': 8 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@nÔlW¼x¦@lVllLkèa@z¤Ė¼UxlnUKUbÝlU¼lb@VxVklJÈwV¯@ĠlÛĖnbkÆźÞUÈôklmL¥LWnKUkVa°Vx@IVV@x°bUkaa@mV@@ywLÑUwVUVUbÞVVann@XwÇÿ¯²aVamkXaÆ»@»nw@¥UXakbWa¯KUw@¥m@kwmLU»UUJ@kmU@UUWU@yanwmçÛl¯¯UmKUmwVkmÝXbW@XWÝbk¯@±w@»U@W¯Å@Ç¥UU@IUakJĀê°þXkam@_J°m@X'], |
| 'encodeOffsets': [[ |
| 118125, |
| 24419 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4416', |
| 'properties': { |
| 'name': '河源市', |
| 'cp': [ |
| 114.917, |
| 23.9722 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@°VlmX¹laĢÒlm@V£@¦Ģklynn¼lW°zW°VbÈV@lÆbnnJkXVÆaÅW@UUw@kaV»ÞkVaVLkmVw»ĕ£@yblçkKkU@k¥wX»kmÓ@Wn¯I`@nlbWý¯éÿlI@XUmWUw@@UJUÇmKUV@xţk¯¯LWnUxK@ű»Vwa¯@¤WX@Û¦@¤ÇIȼWxX@WxwUnVbÅèmVa±²UWl@klȤnôܼXxlUnVlbVnlU¦Jó»@wnkmUÝ@U_¤XxmXm¤ôb@¦ÈƦlJn'], |
| 'encodeOffsets': [[ |
| 117057, |
| 25167 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4412', |
| 'properties': { |
| 'name': '肇庆市', |
| 'cp': [ |
| 112.1265, |
| 23.5822 |
| ], |
| 'childNum': 7 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@l@¥@V¼VôÛ@bV@ŤVLÈlVÈólUX¥mĉ°kÿU°@ÞKlÿ°KUUW»Èw@aw@@nm@w£kÓVUVnKk¥£Vam@nkKkbÆǫmakmLU¥UmÛwmVUmUJÇaUxÇIn`mb@Þ¯b@nJ@nlUVlVULW¯Û`Ç_¯`m¯IbĉWċzx±Jx¯ÆU_k@J@UmbXôlLn¦@¼ĊxlUXxUbLĠUnVĊwlUb@lWXm²@ÞWxXUnb'], |
| 'encodeOffsets': [[ |
| 114627, |
| 24818 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4413', |
| 'properties': { |
| 'name': '惠州市', |
| 'cp': [ |
| 114.6204, |
| 23.1647 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lbW°bnnla@@wnmÆLVUkÇl@XkV²±bnUÆçUaVmxXw@WXwÇ»ÈJ@£Ü¥@XW@£°bUx²¼@ÆLVwmX°K°Ťl@wVUnLÈVVIky±wkKU¯ÅkXġÑÛlwUwlm@mnKWaÅm¯óÇmğb¯alĉUwķbmb@lÞÒVnmĀŹ@VbVUnmakLm`@xĉkklVÔVJVnlVUnmJmaLUblzmkLaō@@zV¦UV²kJnÜU@VXUL@lJL@bݤUnVb@xVnlK²Vx°VxlIlkVl²k¤@n'], |
| 'encodeOffsets': [[ |
| 116776, |
| 24492 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4409', |
| 'properties': { |
| 'name': '茂名市', |
| 'cp': [ |
| 111.0059, |
| 22.0221 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@LnÇlkKnkÆLUmÈxlUJló°n@ana@@X_@mÝóóU@aaU¯mL¯kV¯ÇVwkw@V±Ŏ£@@alw±Vk@mÅm¯ÿÅƧIÇ`ōô¯_UVW°IVx@xkX@mnwXWa@kkJ@kVa±kkVmxmL@¯XXlWVUI@xlIklVČV@blW@@nUxVblVxkôlxnynIƻưaXwlKbVnXbL¤kLèVV¼²IlĠVXynz°KVx°@VlLlblK'], |
| 'encodeOffsets': [[ |
| 113761, |
| 23237 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4407', |
| 'properties': { |
| 'name': '江门市', |
| 'cp': [ |
| 112.6318, |
| 22.1484 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lUXx°JWnnÆXVWX@ºVLV¯nUVnbôxaXmWXIUb°xlKl¯KxXÞ°XÈ¥Ü@ĉÞUç»nóVmax¯UÅU¥Ý¯@ç@ș@çĉÅUmUç±ĉKÝxÝ_ÅJk¯»ó¯nmèkǀWx¼mnUÜġ°@¦@xLkÇaVnUxVVlnIlbnÆÆKX¦'], |
| 'encodeOffsets': [[ |
| 114852, |
| 22928 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4417', |
| 'properties': { |
| 'name': '阳江市', |
| 'cp': [ |
| 111.8298, |
| 22.0715 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@°nKV°b@bôVÞô@nVlÒôÆUnlnn@lmkmVkaÈkÆÆk¥ÅÞ»ÆKXkW¥ÅLmÅkamJUkUVwUmÈblKw@@¥Ģ¯VÛnm»Xwlƿ@kbWaʵ@óLl¯ƽ@Ln°Æ@nUl²kxb@@ō¤U²@lxUxÈU°l'], |
| 'encodeOffsets': [[ |
| 114053, |
| 22782 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4453', |
| 'properties': { |
| 'name': '云浮市', |
| 'cp': [ |
| 111.7859, |
| 22.8516 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@VIl@`V°Åw²IwČyĊXa°Jn°_È`Ü_°XKVkUUVk@mmI@°a@Ýnam_ÈJVwlĉX@lUómaUmVU°UK¹@WXUWmÅXm¯IWwkVWlÅLݼÆl¦ÅÅÇlbUllnknm@kmVmóÅkÑUW`@@bmb@¯mkôIkVÇwnVÅKmlLklmÈKVĊK°²`n¤nUbWlxVxLUx@°nXm`VklVxmnnx'], |
| 'encodeOffsets': [[ |
| 114053, |
| 23873 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4401', |
| 'properties': { |
| 'name': '广州市', |
| 'cp': [ |
| 113.5107, |
| 23.2196 |
| ], |
| 'childNum': 13 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Ș¼VxUnĊ¤@z@Æ@nÈW°ÈVwUÞVxÞX@Kl@ÞVaĊbU@ml£k±lUkkJw¯UUw±kLUm@waUVmÞ£@aKkI@KVUW@ÛVmlIU±VU¥@yğzƧÇƽĠřÅnī±m@²¯l°@nÝÆóUll@XnÝVU¦mVV°V¼Jnb@°mbn@²¯¯wVw@@nmxX¤¯L@VLUm@@l'], |
| 'encodeOffsets': [[ |
| 115673, |
| 24019 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4415', |
| 'properties': { |
| 'name': '汕尾市', |
| 'cp': [ |
| 115.5762, |
| 23.0438 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@@VxnXWV@bVJV@ÞÅU¥Ċx£UWUwÅUU¥WVUkĊÇnkV`°LVwnU@lbĊ¯Vnal@@çkUÝ¥ġaó¯ÅaÅLŻÆUýmy¯ó@ĉÆóȯwÆXbmL@nknVxkxÜĢÒWÆlV°Ll²xlz'], |
| 'encodeOffsets': [[ |
| 118193, |
| 23806 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4452', |
| 'properties': { |
| 'name': '揭阳市', |
| 'cp': [ |
| 116.1255, |
| 23.313 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VȦÆ@X°V@@¼x²°@lÞaWXX@aÞWlnUxVnnL°V@kmĢl@ak@mlk°aX±nwm±²¯JV²@wW_maV»U@m¯ĉUÑJlabVnlĸLlƅÛDZwÝ@ĉxó@è@kmbUĉ°ka@mVxU¯KU_mlĉÈVlXUV¦ÆVxVVX¤ĉwV¦ÝÆ'], |
| 'encodeOffsets': [[ |
| 118384, |
| 24036 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4404', |
| 'properties': { |
| 'name': '珠海市', |
| 'cp': [ |
| 113.7305, |
| 22.1155 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': [ |
| '@@è@Þ°V¦VÆ°wnbUÆ»nçÆ@nxܤ²llU°VnÈJÞ°UôéķUklô£VVˌKÞV°£n¥£ȗÝy¯¯mÅkw¯bÇĔğ@Ýn¯ĊVğōŁŻķJ@Ț', |
| '@@X¯kmèVbnJ' |
| ], |
| 'encodeOffsets': [ |
| [ |
| 115774, |
| 22602 |
| ], |
| [ |
| 116325, |
| 22697 |
| ] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4406', |
| 'properties': { |
| 'name': '佛山市', |
| 'cp': [ |
| 112.8955, |
| 23.1097 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ÈbInVVnUÜxnVV¦nKlnbÅǬlalL@mnUb¤l¦LUmUVlÔ¤@xmnVl°_XVVmkVmÈ@kn@VUK@°KW£nw@m@Ux°x°@±mna@¯amIU»U¯nUV¥ÞUWmk@Vk¯UknÑWÝĊÛ@ǦW¯WÝwLk°kL¯wVaWJXWnbwkVW@kĊ'], |
| 'encodeOffsets': [[ |
| 115088, |
| 23316 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4451', |
| 'properties': { |
| 'name': '潮州市', |
| 'cp': [ |
| 116.7847, |
| 23.8293 |
| ], |
| 'childNum': 3 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@°Üknèmxbz@VVX@VnV@lIVVV¼nKlxn@@¦Vx°LXblaWbV°£¯W@nW@aUñVwW»@¥ŤÅUÝǓÝóV@ńÇkUVmIUwÅVWÇX¹@W¯bkl@nlb@kġn@l'], |
| 'encodeOffsets': [[ |
| 119161, |
| 24306 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4405', |
| 'properties': { |
| 'name': '汕头市', |
| 'cp': [ |
| 117.1692, |
| 23.3405 |
| ], |
| 'childNum': 2 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@U±°I±n²mx²@WºXÈÆUVxJUnlVÈ@ŃôUǔÞVçn»VyĢÛVm@»kaÝUǼóÛÈķKċ¥X¥Wwğk¯@wķKkUmabkIVÒ°Ċ@nVU¼bn`Xx'], |
| 'encodeOffsets': [[ |
| 119251, |
| 24059 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4403', |
| 'properties': { |
| 'name': '深圳市', |
| 'cp': [ |
| 114.5435, |
| 22.5439 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ÞL@xbVVK°X°Kô¥Vw@anUèlkĊl@wn_lKnbVmUaUź@nÿUmÝѯUbk@ÆkxŻ@aÇXwJ¯LķÝUĕóĸóêWº@b²nmĬÆ'], |
| 'encodeOffsets': [[ |
| 116404, |
| 23265 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4419', |
| 'properties': { |
| 'name': '东莞市', |
| 'cp': [ |
| 113.8953, |
| 22.901 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Ŏ@blKnykVaKnbnIVmUkUmUIUÓçmV@bUxó¦¯LW¯LUUa@wÝKğŚƾƨÈĠy'], |
| 'encodeOffsets': [[ |
| 116573, |
| 23670 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4420', |
| 'properties': { |
| 'name': '中山市', |
| 'cp': [ |
| 113.4229, |
| 22.478 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@XÒlmV°ôÞÅ@m¯°k±@@aX¹¯VÝÇIUmV¯kk±Û£mw@Åmèżmô¼èV'], |
| 'encodeOffsets': [[ |
| 115887, |
| 23209 |
| ]] |
| } |
| } |
| ], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/util/mapData/geoJson/guang_xi_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [ |
| { |
| 'type': 'Feature', |
| 'id': '4510', |
| 'properties': { |
| 'name': '百色市', |
| 'cp': [ |
| 106.6003, |
| 23.9227 |
| ], |
| 'childNum': 12 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lklWXL@VIl@XnJn@VUUalk@mK@kny@UlU@a°UU@VmaU@Ua@UWw@n@KmLm@alkmnIm@an@VIUamWÅImwU@@a@KX@JVLUVmUaVkUa@m@@Ulmkk°UaVUlKXbVwVIkaVmUk@KVk@aaW¯m@w¥laX@KmakVmnUl@nxVKInU@yVaVIV@na°KlxX@@_lmXUV`VIVV@n@lbn@@WUkValK@²yl@VUV@@K°L@KU@@UVaXIVVV@naVkVa@K@UUK@UUaLWaw@m@K@UVV@mVUUVKnLmVLKbVK@UUIkmI@mUIVK@IUK@VkL@WU@mU@WmUk@I@VJk@WwX_@amK@UUWkIK@LVb@mVmakL@J@bU@Ux@xbmI@`Iwm@UbmKUaUWa¯UkJWV@XJUU¯LUmV@ma@kkamKwLUUmWVkkm@aVUUkVKnVVUmXK@UW@km@Ukkm@@W@UkUy@I@aUUmb¤U@kUmL@bmJU@Ua@wkLWWkL@U@VaU@LUakKWbkUWVkKkLVLUV@JVbz@V@VmUU@kVmK¯@VU_VWakVmIUKUaU@@bml@XU@@V@LmKUVmVUKKbkaUXKUL@x@V@l@mxU¦V@lL@V@Ln@@VV@nlKUaV@nLUbmJnL@VWLkbmV@@LWXLlxVVIVV@x@V²blUVmLVUK@kWWXUlV@Xl`LXl@@Vn@VnbV@lVUVUÈVb@@`UXU`l@@XUVm@k@xmVknUJVXUbmKULmbx@VlJ@LVbkKUbVLÇUUVUVmU@VaUkUKVUwmLkUUVVlbkaXmwKUVVU@@V±Uk@VWUUm»XamUbKk`U@UnWW_kKmbUVUVmnUV@nJVUlUbU@UV@n@JmI@VmbnVUXlx¯kKmnVV@L@VbkVUmm@Ub¯LmlUL@VWLkmkLmmn£WmnKU_mWbnbmx@U¦UJU@Xmlk¦@mnUUm@@Jn@lVÔVJnIVWI@aÆK@I@aVKIlÞnnl@nl`nbÆX²l@xV@llbVn²VVl@nnV@IlW@Un@@kVa°KnÈmVaVXUlaVÈUVlwôUlynIVaan@lVXbI@n¥la@K_n@bÆx@XnJVnKVz@`VXVU`@b¦UV@VIlxUnVKXÈbVllbVbnVn@'], |
| 'encodeOffsets': [[ |
| 109126, |
| 25684 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4512', |
| 'properties': { |
| 'name': '河池市', |
| 'cp': [ |
| 107.8638, |
| 24.5819 |
| ], |
| 'childNum': 11 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lLVlbVV@nXVlI@JVXmnW°bIVV@ln@nalVUbnW@kVkÒlbVKn²°bUlV²@X@`nbaUI@°wlU@aXJVI@aVK@wUamIXm@XUV@@bV@VmImnUUwVaVKXUnVK@akVwV@nL@UV`n@@XlnIUJl@X¦V@aUIVm@anV@UwnL@VlbVL@KVVXUWwUUVUka@UVJnUlbnalbVVn@°LV`Þ@XVxV@@bVlUVVbXnWlXnml@XXWVXJmbUI@VllUVkn@@VWV@Vnb@VXUJVnn`lLVka»lVLnw@WV@lInw@WnU@U@mknUVóKwUmUXUU@@wVJVIl@XKVVVbVIJ@Un@lVLnmb@U@Ul@nU°VUVJnnVJV@@mVU@@wkUVwkKWkyUUkU@alkÈ@lJ@xIl@UUWVkUw@Kn@@kmaVUlUULÇUUKl@UUmL@aXU@mlUUwmKkUUVKVUaKUnK@U@Vl@XUWUKlwX@b@K@XkV@UwWJka@aUwmV@U@@U@wUm@»kLWVkIWXnmV@VkbmKLUbkVa@aa@@aVU@aVak£@±UkVU¯VUUJVUI@kxmUmWUbLw@K@aU@@aVU@Kma@aka@_VWkk@UWVUKULWKULU@KUnwVaUKxU@UmaLm@kVmVa@UkmI@@KmIkxU@@KU@mmakI@VLkmWkkJ_U@V@L@nxXbKVb@VVL@V@LUbUlmbU@UUWJUb@VV@@L¯K@LU@UVk@±z@kLUbVl@Xm@akm@U@UUJU_VWkn@`W@kw¯LmbU@UJUb@zmVJULmwk@mVUnlnb@LWkb¦@x°nXb@bUl@LVlUnlbUJUxWakLUVVb¯llkn@V@@nVbUlVbUnVUK@IW@L@bV@nxÆJnXVbUJm@@bnmJnkl@bnnK@Lm@Xx@VVbV@nb@UVV¯@bkV@Vmz@lnLl@kVbUVm@mI@WkJ@UWKkXkl'], |
| 'encodeOffsets': [[ |
| 109126, |
| 25684 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4503', |
| 'properties': { |
| 'name': '桂林市', |
| 'cp': [ |
| 110.5554, |
| 25.318 |
| ], |
| 'childNum': 13 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@nU@JX@`XLm¦Vb`lVXXW@VblČnVlanLnmVLK@_Va¥@kUa@VmVbaV@XVVzlVVK@knKVmX£VKLlbn@b@llL@xĊôXaV@°È@¤bnV@@Wl_VU@WnVamwwVbn@KVLX@VmVUxlV@nVV_nK@mI@Wn@@IUĊ@@wVWX@@I°VVm@wmU@m@IUVklkUmmkÅV@@aV@@Wn_UKla@kaVlVanb@k@@KlVn@@aV@nIWWUUaVU@kKmwU@UImKk@UU@w@W@k@UkW@mk_W@Ua@a@¯mV£@mUUam@kWakVama@UUm@nw@alaUmnUlVlIVLVyk£Vm@k@UUJkK@kmKUwKkWK@UXImyVwnI@mkUlkUKkUVmw@kkJWUÈm@_k@@aaW@UUJUwU@@IWKkmUUV@nVl@bVb@bUUXakw@WUkbkKbm@xUlkLm@@wmKUX@UaVWXVmU@@UUUxkmWXkKkUWaUaUbL@`UL@LV`UXmK@VmakLVbkLxUJUIVbUVVb¯KV@Xnl@lVXbmÒnV@L@VWKkVUIWJkIUamUUbm@UkU@JUbW@XWxUam@kbVVUnUJmUUV@bU@UUV@Vk@bmULV¦U@VU`VLUL@xVbn@UJ@nWJXXVVV@bkxVbUxL@x¦@UlXUVVlULV@@nUb@xlnJVnlVknUlVUbmU@bVx'], |
| 'encodeOffsets': [[ |
| 112399, |
| 26500 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4501', |
| 'properties': { |
| 'name': '南宁市', |
| 'cp': [ |
| 108.479, |
| 23.1152 |
| ], |
| 'childNum': 7 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lKnbnU@Ua@KLlJVX@VnL@bW`Xxl@I@UJl@nV@XV@nXV@lK@UVL@JULVJ@nnJlVJ@VULaLUKnmKULVVU@nU`lIXllnK@UlJnb@nV@LV@lwnJ@L@nJl@VUbUn@lnKnbVV@wVLUbxVm@LVVKXLVKVLXU@VllUX@`lb@bnbL@UV@bV@@b@LxKVanXVUUmVUUUaVUkyUUaImK@mUUVUkKU_@W@UVVVIUWUVaVU@UUKn@k@al@ll@bnL@bVUVX@V@@bKnblmn@V_@aUalL@a@akK@kVKUKlwUUnV¥VmU_VWVIVaX@VaalÅK@LVJnalL@LnKwlVUwmX@VXlLUVnblaUmVUVwXU@Wm¯Va@ÞKnw@wmk»UVW²a@_mW@U@IyLVUUKW@@LX@VUV@@yVU@UV@nwUUmJka@IU@mVkaW@UwUX@`@kLWUk@mkUUm@kUUWkUkWxk@@VK@nV@UVaUUJmIkV@UamLUbkVmamLka@kmL¯WI@wJmwx@akU@aUKmbkaW_nW@_U@Wm@a@wkwUKmk@bkbw@mKUkkU@J@bW@kVWz@bVUaVUx@ULkJWbXVVX`@mJUVU@@Lk@WbU@UJlnXlmVx@Ln@b@KLXWJUUW@kaUVUbmV@nnV@n@lVLVmLXmXkV±@kxÅLUbJWIÅJ@ImXalkUamKkkL±aVwKUU@mÞnbWJXm@lbmKULWUUVkabnn@Vl@VVV@VbVbnLWLXJWxXLV@@VV'], |
| 'encodeOffsets': [[ |
| 109958, |
| 23806 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4502', |
| 'properties': { |
| 'name': '柳州市', |
| 'cp': [ |
| 109.3799, |
| 24.9774 |
| ], |
| 'childNum': 7 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@wUaV@nVaUVklmkUUmmIk@waVm@U@VKUkVUkWV@¥@wKVwUalw@aUUUWWXI@mVIm@Ua@wVKUKV_UV@U¥VKnal@U@VU@VV@aVUnVVIVmUUlan@VbXwWX@Va@IlVVn@VanVVblJXIVJlUXL@U@KmUnÑWakU@mkJUI@mk@wUmmUV@JXaWIXWmaUIJkk@WnJ@aUak@kkJ@kUKU_@myUóWUkm¥kUmL@KUKm@k_UmVa@k@@UmU@mm_JWIUVUWLUlbVUJÇVUIVwKUVk@mU@n@lUL@Km@@l@LVzJmUU¤m@UbV²U`U@@¼Vn@x@V@@VnUVx@blbXIVxU@Wl@@LaW@kxLXVWVk@@U@VmLVLbUVULVVlnLVxkV@nWV@bnKVVk@VLVÈVKVVkUnb@lm@@LVxUlVX@VkJ@wkIÇ@kl@blVVVzXllLUxlV@x@UV@nU@UImmUIUV¯mVk@@V@VamnUKkm@@VIUJUaUUWLk@UJUI@xV@VVWVnxLUômVV@VkVVVUnV@UVkL@VVV@bVxla@bkXVJVn`nU@bb@bVL@VnJ@l@VaU@@_lW@UUU@Unlll@XLl@@UX@°bVWVanLlknVV@VVX@VVnUVLmbXJ@nllXX@`VXlmaXVWk@WkwJ@VL@JbnU@bn@@bVKUnVJVIVVVL²a@bV@@Vl@nUVakalmUL@VUL@Va@mXl@nK@UlKL@Vl@@nkllb@Vnn@nVV°lVInwlKXxlU°n@@I@UnVlakUJWkUK@anUWK@_ÞJ@U'], |
| 'encodeOffsets': [[ |
| 112399, |
| 26500 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4514', |
| 'properties': { |
| 'name': '崇左市', |
| 'cp': [ |
| 107.3364, |
| 22.4725 |
| ], |
| 'childNum': 7 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@JVzl@V@Xn@ll@VlnX@@VWLnUVmUULVlUV@blnUlnXVVKxnLlb@lnbU@Vn°KVVI@WXUlI°VXbVVbnLVan@xJ@_nJa@wVwV@@a@IU@UU@WKXwWIXKmKUaa@UUUUk@@UmmalbVUXVVKnLa@knWXImanÝV@VLUx²blKlnLVbklWbn@JÆIXJIVaÆKlw²@lUnWWnKUUK@k@mmU@mnUVaVUb@lVXVXIWK@Lam@@KUwnWkkmVIV@Xal@@KV@VUnI@_UWWUkam@kkm@ka@mk@wkJWIUU@WXkWXkWWLUU@UakLWXV±VIVWUU@anUWaUK@IU@Vak@@UUKWa@m@ak@@wUkla@mUaUklakwV¯¯@WWUkLkKmakLUnV`UxWX@Jkn@bmlakkk@b@l¯bmbJb@VXnbVV@bJUkkKWVU@mÛVUUW@UVUJWXkVkKmUL@WW@UVl@XXKWXJ@XVlmbUxnnm@UlVnV@XVm¦VJb@mLkKÇbXblVkn@l@bWnX`V@@IVV@VV°n@@_naÆVVbUVVbUJnzlVUlXkV@Vlx@XVnxbKUK@b¯VVUVL'], |
| 'encodeOffsets': [[ |
| 109227, |
| 23440 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4513', |
| 'properties': { |
| 'name': '来宾市', |
| 'cp': [ |
| 109.7095, |
| 23.8403 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@nVlw@VJUIVVUV°lU²V@l¤Ub@bUV@b@b@bUblVaKnLla@UnUWmXlJXUlKV@V_U±Van@V£nVIyU@K@kn@@LVK@k@mnVl@VULUxVJÈUVIUaVkXKVVUXJIn`@nnV@Vl@@UbVnl`n@VL@LnKlVn¦VlôXVnz@V`VL@llIll@Vbb@mIXl@lIVJnbWXXJWb@IUnVVn@xl@nVJI@WU°LUaVUUaVJVIwlKUalKnb@UnLVWU_@KVK@_KVa@VKU¯VLVKn@laaUkU@maVUJ@k@Um@XmbkyVaUIUU@KV@laVn@KXKWUkUk@aWUUVw@aXKmVaUUkmIlUU@wUaxUmmU¯U@WLUmVIUym@UVmUa@wmw@çm@aWLUJUIUamKmL@ax¯¥kU¥U@±kUVmKU_mJUbkKmLÅÇ_@WWUXUmaVUkKUWW@nVxkUxmL@KkKmbUI@KLkÆbUbW@UbUJUXV`UnU¦mVVkxVLUL@llL@b@bkKVb@bU`m@knmaL@a@@UWVUU@amK@akkk@@b@lmVL@VUVUbVVXUJUU@V@XV`lLUVVV@nnLJVbVlzUVVbVVnUVVU'], |
| 'encodeOffsets': [[ |
| 111083, |
| 24599 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4509', |
| 'properties': { |
| 'name': '玉林市', |
| 'cp': [ |
| 110.2148, |
| 22.3792 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VJUXVVXlWX@VxVnX@@`ULWUXÅbWK@mULUUmJ@n¯b@l@VULVxxXU`VXXJVIV@nm`@nUVXn@lWVn@b@Jn@nU@Lm`@Xn@WJ¦U@@VnLlV@@Xl`nIlJnkVLw@KVK@UaVL@bVKXlUUKVK@IVLa@U@WLUlVL@bU@@blb@VlbUxVbXUVJ@xVLUlV@VUbVLnKlXJ@Lb@an@VanL@`VLKV_UWl@U_a@WVInlVUUUVm@I@W@wVakIWm@U@XwlaVbnI@m»Va@aXaVLU»@aVa@kKkL@KmU@WzUK@wU@VWUUVUUKUa@mKmbUK@_nWVaUkVaUaVUVLXKVVUVmVI@UkKkLm`UkW@UwWW_UaU@WakXmK@xUXJkUUWUk@WlmJ@km@@aUKzmyVka@kkWVUU¯lmU@@wkkmV@Vk@mÅIUka@Ub@m@UUU`mUbWaWmbXXKWIXUWm@Å@y@UkIUJUUWLUWL@UkVUxW@kaWbKWnXxW¦nm`XLVlUbVbUxI@JmLUKUb@VW@@bkL@b@VlU@xk@L@lxXxWXX°V@VVVbUVV@UVVbULVnVJUb²baUb@VVVVInlV@VnXaVUlIVUb'], |
| 'encodeOffsets': [[ |
| 112478, |
| 22872 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4504', |
| 'properties': { |
| 'name': '梧州市', |
| 'cp': [ |
| 110.9949, |
| 23.5052 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VbXblVlLXWlnwVV@VV@UnWUXVb@VWXa@kVKUaVaVkUlyX@VaVmUwUaVU@UÈymI@aU°@nWV@VaVaw@IV@VmnLVK@kmmna@VbVI@aV@XbW`ULUVVx@VbUV@bl@VLXblJn¦lL°°@n@K@UlLnKa°LWbnJ¦UÒVUllLlVnKnbWnnV`w@@Xa±nl@XKV_WVkVa@kVyUa@wU£UW@UIVW@@awWaX_WKkVmUULmak@UJUI@±m»k@m»VyUImnmmwnkUmVaVIUn_mW@»Vk@VwkmmUXa@IaVmm@Wm_U@mIUWóLmUk@laXmmkUK@UmKULUUmWUL@VakU@Ub@b¼VUKWb@bUbn¼@mJUakbWx@@VXnlJUb@x@X@JUnVVUVmkUJ@XbV`k@VXU`LUK@_mKUbm@@b@U`@nlV@bUnbVbn@@`VbUbVV¯bm@@mJXb@bVnUllVXUlbUl@LU¦VVmkLVb@bl@V@XlK@V@nUJUz°mwmLmlXbWVU@UUUlIU@VVmV@@¦bXbWxXWlXVWL@LUmkbU@@LVVVJUblzna@WVn@@lIUVnbV@Vlbkbm@ULUKV°UL@'], |
| 'encodeOffsets': [[ |
| 112973, |
| 24863 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4511', |
| 'properties': { |
| 'name': '贺州市', |
| 'cp': [ |
| 111.3135, |
| 24.4006 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@nL@xn@lKVkwn@alLlaXV@lxbVWV@aUa@aUk@mVUnVlXL@JV@VxVIVX@b@bl@@`ÇnXVlI@lxUnlVVLkllV@nmJUxnzWJ@VXLlLVxnL@lLlVI@V@lUnl¤UzK@Vl@LlLnb@VnVVU@kaKnxn@VkVJ@ÅUlakmWIUaVanm@_UK@UVWUa@klXamU@VmVIXW@lUVknVlKVLXVXW@b@VlnnVL@KXLKn@lb@UnW°@VaXWVb°aVa@I¯aUkUaVKVwaXk@aa@wkm@alanUVw@alK@Umkw@UaUmU@WXUaUK@UW@UaVWI@¥Xa@w@WWVXwU@mKUXUWVU@a¯kl@akU@UULmK¯VUVW@U_m`U@@xVbUz@lUbUlXU`WLk@m²Wb@@xU_mXmmamLkUkKVkUVÑ¥mIXa¯KbmLkK@V@Lm¯@¯kKm¥kIWaUKk@@aVUUa@UwVUKVX_WaU@@bUJUa@mbnn@lULmKUnU@@JxUbUbU@mX¯@V@bnJÇz@VUVVbVxUnUbW@kzVUlUbVbUL@lWb'], |
| 'encodeOffsets': [[ |
| 113220, |
| 24947 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4507', |
| 'properties': { |
| 'name': '钦州市', |
| 'cp': [ |
| 109.0283, |
| 22.0935 |
| ], |
| 'childNum': 3 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@IlVVlnL@xlaal@nVLlx@x@bXnV@@`mXX`lbnaVL@blV@bwnxI@xXJ°nKl@lbnKnblUVanKVb@lUnJVIVUb@VU@mL@Ul@XwllVVXV@lVnlVnl@XVlK@@_VWVxX@lbUnV@@JlbnIlmnVV@UwVK@U@k°a@mnIVVVK@nXLÆaVWXVK@_W@Umw@UXWWkUUVWUIVaUkJUVWbUmU@mkUJUU@UVab±aVaUIUmVKUaVUU@VUUaUUU@W¯XWWww@k@Kl@wkV@U@alK@aX@@UmIUWUI@mmkXU`U_WJUnUJmUk@@amLU@UVW@UkU@@VbUWVUk@@wmKkUWLUWX@JmIlUkkKWKkLWU@UKWa@bU@@a@_UKWUUUmJmw@nV_@ġğKóLmbU¼VÆ@xUX@Um@wklVnUnlkaUV@lV²WVklWXXbWlkVkIm`UULUU@UWx@XU@@lWLU@kbUbV`UXllUV@bmb@LnKVbULmnVVIV`X@'], |
| 'encodeOffsets': [[ |
| 110881, |
| 22742 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4508', |
| 'properties': { |
| 'name': '贵港市', |
| 'cp': [ |
| 109.9402, |
| 23.3459 |
| ], |
| 'childNum': 3 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@n@VzUJnVK@XV°nVVnwVb@xVVknJlVVUbnWL@bUxVVXbl@lVXkWXwWaa@¥@nUUUV@JVkVVV@XUWanknKxn¯VyVI@m@UkL@W@Uk@aUalKnUUV¥@KVkkaWVkUVkUm@aWanI@n@°aUUVaUa@_m@UamaV@akU@mV_@a@KWIkmLUKaUVU@kVUK@wUIWVUaVwka@Uka@aV@@aUKVkK@X@VbKU@JULVLkVWUL@aUKb@VUL@LxUKmlkImJk_@WU@kmK@UV@¥XIm@@Wn_@KmVm@@I@aUmkXm@UWV@mn_@mUUJWIUWV_WwU@mUknVVmxU@@VUV@zU@UVW@K@X@VLUVKz@J@VnX@`±bUXV¼ln@xmxÝL@Ubn°@XWVUxUVVnkbWVXV@X`ÆÈKnlLVanIV`nLVUl²V@V¦l°¦wb@nKnLVbVJIVXK@bn@ènx@xVbUnV'], |
| 'encodeOffsets': [[ |
| 112568, |
| 24255 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4506', |
| 'properties': { |
| 'name': '防城港市', |
| 'cp': [ |
| 108.0505, |
| 21.9287 |
| ], |
| 'childNum': 3 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@XV@X°°UlxkbVlVb@nkbVl@xl@@b@nXbVL@Vl@UbV@@JVLXbmV@bVVUXUJU²WXlKVb@VVXKlXWlXXWV@VXJlI@xl@nlbn@lln@lbXalIVK@VwUVbU@aXylUX@@aW@U_UJmUnVKUamL@Kna@aVUkkVWU_ValaV@XK@kV@@WwVXV@VKVVn_lJlUXkWaXWlkXU±kU@VUlbkVmUmlk¯ÝW@mb@¦VxULmkJUU@ma¯wmkX@VóJ±bUVUXÝWklWXXlxUabIğÇ@U@mVUKkkm@UJm@XnWV@x'], |
| 'encodeOffsets': [[ |
| 110070, |
| 22174 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4505', |
| 'properties': { |
| 'name': '北海市', |
| 'cp': [ |
| 109.314, |
| 21.6211 |
| ], |
| 'childNum': 2 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VaVLnK@IJVwUaVaUkWKn_mX¥WwXmLXalbU£UyVÅ@Ýwm@°lLÅUmkmwÛaƑLÝUUm@ȣÆV_Ó@£UUV¼U°W̄ÞVbXbôx@b@bmV@ÇUÝ@@ĢU`m@nxnIVVVXVL@`@bV@@aXbVL@XVlKXLlLVlknJ@IWVXXKlVnL@xl@UVVXa@UV@VlX@VUV@nK@bl@nVVIVmXIV`V_lWnn@VJVXnJ'], |
| 'encodeOffsets': [[ |
| 112242, |
| 22444 |
| ]] |
| } |
| } |
| ], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/util/mapData/geoJson/gui_zhou_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [ |
| { |
| 'type': 'Feature', |
| 'id': '5203', |
| 'properties': { |
| 'name': '遵义市', |
| 'cp': [ |
| 106.908, |
| 28.1744 |
| ], |
| 'childNum': 14 |
| }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@@UnUlJnwJU°VL@bnVUwlJ@XXVlU@klVUJknlUllL@bUJ@xULUlUblVkblbnwUXmla@wV@VK@L@UXaVKVLXWUVa@U@Im@@W@£UKUakKWIXU@al@@llUnL@W@Un@@VlUV@VIUanKl@Xb@lmxVb@b°bb@nlJVVnnJ@b@LV@ln@LmV@Vx@blnVKnlJXIlwJ@Òb@nlK@Un@UL@VVVVUUUVKl@VUVLJ@UVUUw@Wm@UVÈVlbUb@JLlX@@xLmk@@nlx@bUJUzVJ@@LVxUV@bWxnLnVVK@_K²xVbV@n¥@aVI@b@l@VaKnb@n`nmmýW@U_wV@VlVV@Vn@n@nI@Jn@°¦VaUU@mVVWVaUÅU@aVKnVbVUmmU@a@kUwm@aUUmUUJ¯lakUaXaWUUaVkkamkmUnVlULVlJ@XU@UJWUUwk@aU@WbkWL@U@WU@@XUKmV@aUVwUĕUJUamUUVUÑmnIVJ@kl@XalJVn@KVL¥@UWIXWmU@mVUKnUWLUKUaWUUKVU@U@anUny@UlUkK@w@a@aVU»UkVw@WmkJÅmUUVmwXalLXWWUnam@XkJ@UVU@U@W@@U@I@Wl@Ènlw@KXLWblVUkalKUUVVaV@@wnIlaUmkUKWU@KkUkLWaKUUWUn@VK@LnnWJUIVkUWVnV@V@@XK@VUIUJ@IWJkX@VVJIVkK@I@UVaUWk@m@wnUWKk@mxk@@lV@bxmb@x@VUmLkUJ@nVV@b@VkLVbU`¯Il@U_UW@UU@K¯wm@xL¯¥kI@bkb@Ua@m@kkW@XVbmV@kV@bWbUbV@¦xXlmVk@¦bkaWL@KUImK@wUK@VUIb@bmK@LÅy@akXW@kbWlXblL@ULUb`@UkUymX¯@mUJUUJL@Lm@@WX@lUVlXll@l@Èk°V°X@VU@UVll@XUJVXUVm@@VXLWlnV@Xk@mVULnxV@@bmkL@VWLUbU@UVm@b@ķ¥UnmJ@UUVkkJUlÔU`UIW@°kLUlUI@WVIU@mWKkXk@WU@bXW@J@xX@l@LVl@xLVxXX@xKnxVknbKVV@ULWlXU`@nUlX@llVXVUKlkUKlI@anKVLXKVaUIVWV_VK@VnLlU»VKVLm'], |
| ['@@@KlKkUUVVX'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| 108799, |
| 29239 |
| ]], |
| [[ |
| 110532, |
| 27822 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5226', |
| 'properties': { |
| 'name': '黔东南苗族侗族自治州', |
| 'cp': [ |
| 108.4241, |
| 26.4166 |
| ], |
| 'childNum': 17 |
| }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| [ |
| '@@VV@XkV@bUbWJU¼Vb@Vnb@b@J@bL@LV@UVlUI@aKULVb@bkJmxlLVxknVJkxnKmnnL@bn`WIXlWLU@UxVbUVmKVXI@JVIVJ@UL@W@@UmUXUlVUVJXImm@KL@UVmVXVLXblKlV@LXVLlVVnkbmJ@xnXl@bXa@VanaÒLmVnIlÞ¦°k@b@@lVnJlUnVX_@lVlKVUUxVLVWVIXJUlnnWlI@KUaUUVKn@VaVXV@na@mw¯@mUkJUamI@lk@@am@@IUmVImUUw@anUVaUU@LU@WaWUXWWwV@VwnU@L@ynbl@@X@aJ@nW@@Vn@lVLlxnIl@@UWKUnIlJXIVllIVV¼XK@aVIV@@bn@VKXLVKVVVInwJ@UWI@mX@WKnI@KmUUVJUL@VKW@@k@aU@@W@InJWUXwWI@W@¯wkaVaUIl@nValIXWWI@UUm@anwWkXWWIUbk@UJmIUamKVUUUVVama¯VkIVVUlKnXVwX@@WVaUUVa@IlaVmknawkUU@U@mUVUVwl°LVbnJVU¯la@mX@@UWKXU@aV_V@@JlkU¯@VnK@km¯kU@WUW@mmU@kmlU@wkL@WUkL@VmLJ@b@V@bknUUVK@UVKUK@Uk@Wa@LUVVnUbmVk@@UU@@aV¯K@U@UU@WmUL@aU@WVw@IxXll@UXK@KXXVJna@wWa£naUKVm@UU@mUmalm@@XkVm@U@VLmWU@kkWxU@@bVV@VkXVlV@UUk@@mI@KUwm@UmVUUwU@lwkV@IUa@mUaVIVKVa@w@U@UJkb@n@bmJ@XmlVUxWXkJmUkUUVWxUlU@aULUmbU@@WXkmL@xUV@nUxÇm@XLWbnlnVnnUVUnVVz@lbUVVlULVb@V@nUJkwm@Ux@bWbUK@UULkaJbUU@U@lUK@XUJmnJ@bU@UwWax@zkJWnUJUUVVV@bXn@xVb@JLm@Xw@`@bkb@VmXUV¯L@mW@@n@V@L@KIW@@aaUx¯@Um@XbW@@LV@bnVWVkKUzlV@bÆa@lnI@VV@@LnVVKUaV_VJVbnU@bn@nX@yVIVxXKVLlUVaXU°J', |
| '@@@KlKkUUVVX' |
| ], |
| ['@@UUVUkUmV@ln@VXVK@K'] |
| ], |
| 'encodeOffsets': [ |
| [ |
| [ |
| 110318, |
| 27214 |
| ], |
| [ |
| 110532, |
| 27822 |
| ] |
| ], |
| [[ |
| 112219, |
| 27394 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5224', |
| 'properties': { |
| 'name': '毕节地区', |
| 'cp': [ |
| 105.1611, |
| 27.0648 |
| ], |
| 'childNum': 8 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': [ |
| '@@UkV@kW@Xn@@KKVIVVIn°@nWVzl@V_VaVK@kKWaXklaX@lW@bÆz@KnL@aaVJ@UVL@xnLVJ@LXKlba¥l@nUWkw¥U@VaXa@amLkUKm¯kmkIUaKUIWkKm@anw@mlwXImUk¯@a@amU`kkKWVkxmUUak_mJmw@wmXUW¯X_@WnI@aVwkWWýÅU@WLkUaUbVV@lUVVnm@kUmV¯kKLwmVUUaWVaaWw¯wÈ@VULUVUUK@nWJkIl@Umxnbm@kbUJa¯bUbVxmLUVaU@VUUWxkVVV@bUV@XWbnlUbbUJlbUV¯b@z`WbXnmbawUwVWUbUxmbU@Uam@VkVawVaUWI@mUKóz@lUlÅ@WIb@xXxml@XklULWKUmwUa¯KUXWJkaULmKkLWbkKUVImWa@kUaULW¯LK¯@kbL@bx@J@bmnnlUlzU`U@@Ub@mn¦°bUVx@bkVm¼mx@mkmVV@bkxVnaVV@bU@mL@b²`lIVV@lXLlbVxn@@bl@XllIVnbVn°°wlbXw@mVa°lVnU@mVLVbn@@b@@WVnUV@Xlxn`VznJVb@L@bV`V@UnwU@WUXKV@UUlmUUlaXalLmbIVbnJVIlVVaUUnWVXnVLk@nWnblnlb²xxVKVXlVXLVWLlUVJna@wVL¼@JVX@`@nnx@nWJU@Vx@XXKUblxU°LVKVVlL@KnbVUnJIlUnKl£VWxIlJ@nVÞUVVnbVX@V_°lnK', |
| '@@@UmWUwkU@Um@@VkL@V@VVkV@nbVa@' |
| ], |
| 'encodeOffsets': [ |
| [ |
| 108552, |
| 28412 |
| ], |
| [ |
| 107213, |
| 27445 |
| ] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5227', |
| 'properties': { |
| 'name': '黔南布依族苗族自治州', |
| 'cp': [ |
| 107.2485, |
| 25.8398 |
| ], |
| 'childNum': 12 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@V@IöalK@UV@@KUaVIVVLlaVbVWnX@@LnUlxl@naVLXVVaVUJ@lUUanWWI@VlV@Xbb@Vn@VmVVbk@kU@VV@XJ@zn`ULW@kK@_WVUK@LUb@Jlxn@nnWlU@@bx@XVVU@UbVb@n`VI@VVLUlUIUV@KmL@VV@XIV@@lVLVmXV@WLXLW@U`nkb@Vl@UL@VVVLllX@`lIXbJIXWLaVL@XXWĢb@bmK@L@°@VnxmxnK@xVn@VkL@VLakbl`VnnxVnUlV@@VVXV`@k°JV_UalK@U@aUU@mIlVnKV@U@wnaw@akU@l@nwl@XLmV@xnl@VXUb@V@JlLUJUI@UlWUnLVUUaVwV@XKWkXJm_@amKnmmLwlUIlmUwkKnwlI@aUaVKL@bVJkVUU@@KK@a@I@ama@UUaV»XIVa@alU@WUU¯IWVUbkVUKWLUwUJ@zmWm@@amVUaUIU`VbULmU@KU@@UmJ@kÅb@akUVylLXUmU@aU@KX@Wan@V°@Vwb@bX@J@LK@@U@mX@@n°KVUnW@Ula@a@_x@WnK@IUa@wWm@aUUUVVVIXmlI@ywXbVxV@@aInmVI@WVL@k@VVVaIlbVK@VVLXa@aVwn@lxVI@m@UUaVKUkVUka@UymUVVUmmUmmkXaWK@ÈnVw@mVU@wKlnXW@V@naVVKUk@KVIUW@mk@KXU@Um@@lVk@UVJna@UWaL@a@Xa@kmmVUUk@mkkamJImJUUmIm±aUUkambkamVUU@VlbUbVVxXWVUU@VUakU@UmUVU@mnUVVnUbVJ@bUW¥kLVamVkUaWJU_UVWKk@@nlUVVJUXm@Vm@UnVlmbnmJUbULU@@UUKWVIWxnJVb@xUL@bUJWIkxbkb@xVJbmU@kW±LkKUkVa@a¯am¥ULkalÑlKXUWXaVakImV@ka@UUJ¯aXmmbKWU@wUUaUaKmU@UXlWb¼WLUKUb°UlVbkbVL@VJ@nVlUbUXmJ@VX@lbUbU@@bWb@VnLVJ@bVVUzVL@lnL@bVVVULmKUkJkbm@xVb@VkKVnnV@b@WXUnVlVVXVJUXlVXbWV@VU@Ubk@@KWbUUmL@JnXV°XJ@_`UbkXVVlÆkb@VLXVV@V@kKXX@`V@@n'], |
| 'encodeOffsets': [[ |
| 108912, |
| 26905 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5222', |
| 'properties': { |
| 'name': '铜仁地区', |
| 'cp': [ |
| 108.6218, |
| 28.0096 |
| ], |
| 'childNum': 10 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@°a@aÈbVUlU@aVKnVVVUlyX¹lWVa@UVnUVU@m@mUl@mÞw@xnIVbna@KVIJ@kwV¥UXÇVkVW@kkKWU@aXUWmnIVa°VXbmL@VVbnVVVUbVbJVbVKXkVKVanU@aWnWUWa@Unk@mVIVK@wXxlLXbVJVlKbl@VI@maXalVVVbX@@aalnkx@b@Vb@Vnx@bVVUXn¤WXn@Vl@Vlzn@`@I@KUU@V£namVkXa@aVKnnU@anVlKa@UUU@amk@»kU¯@aVWnkWmkImU@akaVm@»VUV@UKnkW¯XWlkUKnIWa@nmlIXmWUnwUwWm@wULmaUJkIUaaWaklwkwmJmU@bkJ@XUJ¯W@XbWbUKUkWJUUVKnn@UmmXUWa@mU@@UI@WmXVykwm@kaULWwU@¯lKUUVU@mU@UkmaUbmV@bxVnVUJVn@Jn@@bl@@knJVblInV°@nx@mbU@UWUbm@ULVVVb@LkJmXkmVWIUJUXUKVwVUkLkU@W`UmkVmIU@k@@a¯lÝ¥kmJUnKÑmbUb@Wbak@mWU@UbUVVkLlbUVkXaWK@LkxÇmk@@X@J@V@@X@VUV@VIWln@mbXVWXkKWbnxVUnVÆInl@XUxVl¼UV@b@b@xlLkV@VmzmV@b@VUVVLXVVbVLXKmVVLU@nnVWXXJ@V¦UK@LUmkIWbk@@lUImJnVÒVUnVVbVIVĖUxV@bnUVL@WV@@X@VKlXXaV@@blVxXVVIV@@WkIUVKUkVmlnnbllUVbXVWbblVkb°VInVVV@bnVx@l@bnVVnUUamUL@bVVÆUbUXUn@VVUb'], |
| 'encodeOffsets': [[ |
| 110667, |
| 29785 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5223', |
| 'properties': { |
| 'name': '黔西南布依族苗族自治州', |
| 'cp': [ |
| 105.5347, |
| 25.3949 |
| ], |
| 'childNum': 8 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VL@Vl@@IXW@kVUVbnW@XlKVVnUVlL@baVbb@xX°ÔUxV@kbm@VxkxWJV¦@ÈnVKxWXJmV@nÒ@xVbn@@blLk`VX@bla²JVUlnn@U±lw@wnw@mlwVIX@@m@klKnkaKnwmmXkÆVmU¥l@nb°n@aVwVmVIVnI@a¯@mU°l@@VnI@JV@UV@b@IUbVJmXöºzllUbVa@aXUl@U@llLnKVaUa@UmK@UwVbnKV@VwVK@UXV@Vbn@w@UWnX@a@mI@UUKlaUaVk¯VaVLXK»XaWk¯mkğwmW@mIVkwJUIÇVwUUkVKkm@UkmU@WÅwm£Vm¤¯IkJWa_lUbmJzÝJkUÇVU@bUÝnm¯LUb@`mL@VkL@VUmmk@UU±Umka@kU@ķymUkk@mmkÝmUaUakImV@V@VÅL¦JUXmJXWb@n°Æx¼nV@LlbUUbmL¯@ÞbV¤nbVx@bUVlblI@KVVUnVJUn@VlLUlmLUUUxmK@I@@VW@@bU@UJmUkLVVUl@b@V'], |
| 'encodeOffsets': [[ |
| 107157, |
| 25965 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5202', |
| 'properties': { |
| 'name': '六盘水市', |
| 'cp': [ |
| 104.7546, |
| 26.0925 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@ôyVL@nXJVUbxbUlU@nVbV@naVwaVUXVxxbnaWmXa_@y°aVUkaVIaVamkXa@WVU@aUUlUXwVV@UVbVUnKUwVa°abVIlan@manw@VklJXI@mLVVVUVK@UÇk@KUa@UkaVU@UVWV_XWVXVWlLXKlLXaÆKwVL@akKm@Uw@@XUVk@VUI@wWK@aUVI@UkK@mLW@kImJUÅVmkXUW@UJkx@nmx@xkxV²m@kmUV±Ikb@aUWl_kK@am@Ua@wÑ@mnUWIXwULm@ÇU¥XIlwUwn@laU@Vw¯ÓW@waUab@akKUmVUUkL@WmXUaUV@lWX@Jk@@UUKULmLUJmzkKmVX°VUnWKULL@mU@UnVJ@b@UV@X`m_@l@@bmbXJmnn@°wnn@VLX@V@nVl@nk@@bl@nn°WlXzW`XXVKnUlxVbUb@VXb@VxÈbVlnbmn@kVUL@mLUVVL'], |
| ['@@@@UmWUwkU@Um@@VkL@V@@V@VkV@nbVa'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| 107089, |
| 27181 |
| ]], |
| [[ |
| 107213, |
| 27479 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5204', |
| 'properties': { |
| 'name': '安顺市', |
| 'cp': [ |
| 105.9082, |
| 25.9882 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lL@bUKxÅLWbkKWLkKUXUWWXU`UX@VUVlb@VVb@Ll°xXxbbXUVbVnUxKlL°nUlVn@UmVU@kUUVablVXKV@ÆXþlXUxnU@mVK@_@ml@UU@blU@KnLVyUw@@UmkWVw@UVK@VXzVK@nVVUUW@kVJnla@nKWkaWL@Uõb@JU@mU@@_WWL@lUU@WUUK@lakÅUUlWVa_@`WIU¯mW@InKVVXa@Ll@VaV@@UXUWakUVWUIUWUkUmVXW@@amUUmLl@UUawn@laIVlnLVKUUU@amK@kUKVyUU@aUImK@UXa@aV@VakaW@@UnIVWVaUkb@mWX@Vxm@UaU@W@VULUxU@mLaUx@VnL@VVbUbmLkK@kVk@WV@bUbVakkyõ¹nWUIVa@J@aVUU@@ImJ@Uk@¯V@n°@bmJUUJUnUxbm@¯mak@¦VUnÅWlnnmxLbmlkL@l@nWVnlÆUVnIlJ@XnK@lL@VJVU@bXL@xVJUl@VU@W@Vxn@'], |
| 'encodeOffsets': [[ |
| 108237, |
| 26792 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5201', |
| 'properties': { |
| 'name': '贵阳市', |
| 'cp': [ |
| 106.6992, |
| 26.7682 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@nlLXVJLVblJn°lnLlVnKlU@nUUa@WlX@ln@Vb@la@alJ°¦Kwn@°xLVkUmmwUmk_labK@UlK@UUm@wLmnwmw@U@¯@KnL@aaġXWW@UKbKWXJIWakJ@_kWkKUU@UVKk@@UlamV_X@WKXK@WUUnUK@kU@WJU@@UnK@LVUVJVkUK@UUJm_@UaVaV@UU@Ww@aV@Xkmmm@kw@IVa@KVLXU@`lLX@VKm_@yI@WU@UlVl@UanU@Um@UaWaU@Uk@XJmXVbkV@IUVUbWUUKmbk@kwmV@K@mWUXUakbKUUUJVb@LU@@VkL@VXKlbXmL@kbmUI@lVXUVU@mULWy@UUL@VUxXnl@V@VxUzmK@LkVa@VVk@@n@`UL@nmV@bmJ@X`WX°WVn@xnxnIl`VbnVlwXUlLl_nV@b@bl°VnWJkx@nmx@b'], |
| 'encodeOffsets': [[ |
| 108945, |
| 27760 |
| ]] |
| } |
| } |
| ], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/util/mapData/geoJson/hai_nan_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [ |
| { |
| 'type': 'Feature', |
| 'id': '469003', |
| 'properties': { |
| 'name': '儋州市', |
| 'cp': [ |
| 109.3291, |
| 19.5653 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@஼jpnr``pRVHÊ̤Zt^JÖA[CâlTébQhRPOhMBcRSQiROE[FYdGNOEIH]MgEAMLLIAG_WMCSL@ED]PCLYC[ZIHgjSxJTMbHNEFCMEE_HSDFHSLECRNSFDRICHNADGPI\\RZGIJTIAHLDQOHG`GTNCOIC@eIGDWHIS[kiE[FMbECZS@KKS[FDWsCeRuU_DUQNOE[LKGUBM¨EDQP@HWHGDImXCog_~I_fGDG|QDUWKBC\\ore|}[KLsISBHVXHCN`lNdQLOnFJSXcUEJMCKSHOUMDIm_DI`kNDIGEYFM\\YPEEIPMSGLIKOVAU_EBGQ@CIk`WGGDUM_XcIOLCJphHT_NCISG_R@V]\\OjSGAQSAKF]@q^mGFKSW^cQUC[]T}SGD@^_aRUTO@OHAT'], |
| 'encodeOffsets': [[ |
| 111506, |
| 20018 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '469005', |
| 'properties': { |
| 'name': '文昌市', |
| 'cp': [ |
| 110.8905, |
| 19.7823 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@hIJ¤Ī¯LQDaFßL[VQìwGF~Z^Ab[¹ZYöpFº lN®D´INQQk]U[GSU©S_c}aoSiA£cÅ¡©EiQeUqWoESKSSOmwćõWkàmJMAAMMCWHGoM]gA[FGZLZCTURFNBncVOXCdGB@TSbk\\gDOKMNKWQHIvXDJ\\VDTXPERHJMFNj@OwX@LOTGzL^GHN^@RPHPE^KTDhhtBjZL[Pg@MNGLEdHV[HbRb@JHEV_NKLBRTPZhERHJcH^HDRlZJOPGdDJPOpXTETaV[GOZXTARQTRLBLWDa^QAF`ENUPBP
\\Eji`yºEvåà'], |
| 'encodeOffsets': [[ |
| 113115, |
| 20665 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '469033', |
| 'properties': { |
| 'name': '乐东黎族自治县', |
| 'cp': [ |
| 109.0283, |
| 18.6301 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ªVLP`@PEdNRAHOPEAKHEVL`GZBJfvdTAXNNTZJFPrHHNpKTD\\ILHbEVd^JOHLh@NNBnHP`\\xH@NBRLJTlNv_^CTLd@bNDVFbxdFVUPBTKOGEOUO@OEBXQP[H_EI\\EbeYa@UO_JMEJ_IEDKJUGMDcNUd_FMTEJSGoZ]EIYGO[YWgEQ]a@WHEDQKUSDUGAbYBUpSCYNiWqOSQEoF[UcQISWWNMSDe_cLQ_UBiKQOOASQAWgSā]ZaSPÝZ]XMXS[^oVËNgNKlE RôEø'], |
| 'encodeOffsets': [[ |
| 111263, |
| 19164 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4602', |
| 'properties': { |
| 'name': '三亚市', |
| 'cp': [ |
| 109.3716, |
| 18.3698 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@®ĂhTBXTRPBRPjLVAR`dKf`TCNXMTXRJVdE\\FpTRrPjXZMTDVoZABaVHTCLVCRGF@X^bFRhZXP\\ZHHMA[^wBWXJlW¤EJ[bCTOFWWMm@ILMGWQ@DQ^QNWFSHEbF`OXNbOVNKTEPDTLTCCVTREfvfEHNbRAENH^RJXCFHNFRpVGHWISDOTMVCZeGamaLoLÛD¹¹ėgsia{OųETtlÉwr}jR±E{L}j]HąKÃT[P'], |
| 'encodeOffsets': [[ |
| 111547, |
| 18737 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '469036', |
| 'properties': { |
| 'name': '琼中黎族苗族自治县', |
| 'cp': [ |
| 109.8413, |
| 19.0736 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@bRFnHNbHgN@NPEnbXP@bND`NT\\@\\QZb@`@J]V@XhDpWnCJGHGXO@CR§FANHVKLF\\MPVR`CvVfQtDPKpGHG@S`WJP~^dSTHWX\\RHTFACQTIAUPOU@MG__IaYSFQKNSbORHXCZeTFJgB`YBMNMFi~IVDV[tGJWXGDQRGF]JrALgESLSAYDGIaFeXQLS\\MKSLSQYJY}eKO[EHiGSaK[Yw[bmdURgEK^_kcSGEOHKIAS]aFSU@Y]IWFUTYlkP_CUOUEkmYbSQK@EMWUuAU\\M@EpK^_ZMDQ^OXwC_ZODBrERURGVVZ\\DTXcFWNIAWJWAYUUFYEWLQQaCIZeDM`cLKRGpanJZQd'], |
| 'encodeOffsets': [[ |
| 112153, |
| 19488 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '469007', |
| 'properties': { |
| 'name': '东方市', |
| 'cp': [ |
| 108.8498, |
| 19.0414 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ºxJYZQIYXLl@dR\\WZEn]bA\\S~F`KXaDeTiNO^EEKWEDQXITBXaWaDQMUJOIaTWf@NJV@dSxGZFu_@WMKAU}AQ@MwG_[GOAmMMg@GKP]IUcaFKG[JSCoLGMqGEOYIMSWMSBucIeYA_HUKGFBLOFGPQBcMOF_@KO©UAtERadwZQ\\@ÊJÒgòUĪRlR°KĮVLJ'], |
| 'encodeOffsets': [[ |
| 111208, |
| 19833 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4601', |
| 'properties': { |
| 'name': '海口市', |
| 'cp': [ |
| 110.3893, |
| 19.8516 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ńZƂtĢ¬æßFuz¹j_Fi[AOVOFME_RBb]XCAKQKRSBQWSPY\\HbUFSWSPoIOcCOHIPkYCQ]GdGGIFQYgSOAQLK`MFUIGa@aQ\\GGUFcHKNMh@\\OYKAigsCgLSF]GOQO]@GM]HyKSHKPW@Pxi@EMINYREXWRQ@MQcFGWIAwXGRH\\yDI`KJIdOCGRNPNtd\\UTMbQYi@]JeYOWaL[EcICMUJqWGDNZEXGJWFEXNbZRELFV]XQbAZFrYVUBCLNFCHmJaMIDDHXHEhQNXZ_TARFHVB@DTQIRR@YHAJVnAbKFUEMLd\\c^ÍÞ'], |
| 'encodeOffsets': [[ |
| 112711, |
| 20572 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '469006', |
| 'properties': { |
| 'name': '万宁市', |
| 'cp': [ |
| 110.3137, |
| 18.8388 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@^J@ZTVbET^JBGLFPTHld]`FLQhcVanx\\\\ZbLHTGj\\FLP~fIZRZPVTQFSVAFJE^NDLEE[~LjsxVTG\\NZZNGlLRRGLJTV@hPZANN^@T\\NEPPbDZXO`d^HSvcJDIV\\XZAJUFCLNP@PQ¤@[ïKLÑIÏ]ÇE±I{uYśUćFcYUmsVeBSVgB[RO@aYYPO^]@UVaNeDShMLG\\EfFVE\\F`'], |
| 'encodeOffsets': [[ |
| 112657, |
| 19182 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '469027', |
| 'properties': { |
| 'name': '澄迈县', |
| 'cp': [ |
| 109.9937, |
| 19.7314 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@T\\GJCXJH@fJDDPNCNJENN^NLHBNSx@DDYbBLLDRbjZTj@`XXTlG^Xr@PJLW\\WLTlWR@HDJTD@X_PO@STMDNTMVV@NLDM`M\\XM\\JNBH[PYZúYzŸ`Ċ\\ÎÝd]c[NKVFLEBaUmBIZGQ@JQSR@CUAEGBQ`SWYRMFgWGCGJCbNnIDGMEDKVAZUEqBYRa^WEUFKYQMaFWXEHIFWMYHCrXVIIiaK@aMCUYNSIISTwXALKH@XWXIEIJQCG[IEQDE_XSBaa[AIPW@]RS[FWS[CD]PEBYNGFSaSyJG]@ugEUDQlGHiBKHUIoNSKqHFaPMICK]UUHIPDJMuCA[SCPIDIOILGAEmU[POPBVSJDREBGS[QXWSGcT}]IO_X@TGHoHOLCX\\ELT@LYTDaFENF\\lj'], |
| 'encodeOffsets': [[ |
| 112385, |
| 19987 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '469030', |
| 'properties': { |
| 'name': '白沙黎族自治县', |
| 'cp': [ |
| 109.3703, |
| 19.211 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@D\\RV]dTXELnHr]^@LETBBRTHPi^[@U`QTHDJ`MGSogDIPKdJ`WVNHCXHl_DJR@AH`FBVPUJLHKNTJOFFZON[ZEHFCJlMJ_Cn`CJVNGPLTNDFIdVTWEIPmRKMc_kDMWGGUTAtJLK~\\f{pqD[LAVXRCH{HC`eJ`}@W^U@I@_Ya[R[@MSC_aMO@aWFmMOM@haGGMEmaQ[@MESHaIQJQ
MckBIw[AOSKKAMPSDSLOAV_@@`KJRbKRDfMdHZERgAWVsDMTUHqOUr@VQXTT@TfgL^NH\\@heTCZaESNObHPHeZF\\X^ElM^F^'], |
| 'encodeOffsets': [[ |
| 111665, |
| 19890 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '469002', |
| 'properties': { |
| 'name': '琼海市', |
| 'cp': [ |
| 110.4208, |
| 19.224 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@TP\\pATHTGlZDJGAQjE\\Rb@jVBDCN`JZ[NCNHNXbULPrP\\KNbMTLjJJRFP`pNLZz^FLRHjVPZ@hxVKbHBHMNNJFRlLzGPnNHhIrHHADcPWdUAmEMVQDSKYHY\\EhBN^HpXGNDBNNBnIßÅ_g{³So]ã@ORO@KMEDIVYB[WJUICudGTc]P_YWaCOOMFS[]@MMYBgOU@ISHKQQkKMHYY[MSHwUit}KF\\KFMCF]EIUBETSROUKTLT[NKTWREfJbCHBZKTFTKh'], |
| 'encodeOffsets': [[ |
| 112763, |
| 19595 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '469031', |
| 'properties': { |
| 'name': '昌江黎族自治县', |
| 'cp': [ |
| 109.0407, |
| 19.2137 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@`ZĤd`òü BSPGP@VSbQ`@]HC~T^SE]N]FkW]E[fYGGOPaTMbFDYfS@g[MGK]he@SSSRW@UVqrPVGNStCXUhBFQGYNcCeLQQaLI@_`@EUwcEaCUaMc@SK]Du`MSkKI~BVNL@X`EvYwHcTU@MIe@SXJbIPNVCRXbWbSAWJCRXFFL]FMPSjCfWb_L}E[TaBm^YF[XcQk@WKZJYRIZw¹ '], |
| 'encodeOffsets': [[ |
| 111208, |
| 19833 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '469028', |
| 'properties': { |
| 'name': '临高县', |
| 'cp': [ |
| 109.6957, |
| 19.8063 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@jD`hNd\\^dZädĒH´Op@ùZY\\OAGIMN[[W_NCNMKU@NUMSNCTSP@`O@WSCCI@GXQSkXKX[IK@OWqH]SkWW@_SiiYQaKCAKZaCCw@MTGAMKM]FMMIMDSM_HGHRPKCBGSJJIYH[QOJCHMBDGQJECMTDQKFGTCEGTF`NFEDMFaGSNwIiTGhYJD\\KZODC^@FTKND`XBHKJNKFBNhG^FJMPcHEZF\\QPRjQTAdgNOPgQaRSê'], |
| 'encodeOffsets': [[ |
| 112122, |
| 20431 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '469034', |
| 'properties': { |
| 'name': '陵水黎族自治县', |
| 'cp': [ |
| 109.9924, |
| 18.5415 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@R]NC`YL]FoN@V[vBXVFNL@TRZalnVFVP`DlOZkVSXEE_F[EUFeH[NKTgfCbMVU^@P]ZObZP@\\QhATUfAtUasñiāEoI]eYǯ@aKmaeWuCºKÜKpnbHbYfUDSNCPJTRAHJTDJSfDNLHXC``VBNGTYCQDIXMDSP@xLNEFRNXBIpVNLXah@RgF@`qOML@LJNSPLbaHAh@Jdj'], |
| 'encodeOffsets': [[ |
| 112409, |
| 19261 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '469026', |
| 'properties': { |
| 'name': '屯昌县', |
| 'cp': [ |
| 110.0377, |
| 19.362 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@\\OnVBFKHPJCJOJTDB\\vDINOCGJVVL^JDONEbrGTLpMVJLGjAHGRkVChF@vH^zIbTETMHAZOFC^\\DXT\\EffAP\\PdAV@UIYfS|S@YPICMeM@sC[_A]VQEwyHSMuNcAUlQJMVGMS@mVBZPFO\\CSFQK[LqDMACiUa@[QiFBRIHYCHkGSBS[oSOqBIE^QHCRWHIXsHU\\UC}JEjMNAN_ZAIhSEYfWDQGaPMTLERZTJb``NHV@'], |
| 'encodeOffsets': [[ |
| 112513, |
| 19852 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '469025', |
| 'properties': { |
| 'name': '定安县', |
| 'cp': [ |
| 110.3384, |
| 19.4698 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@JjDNdJ\\FbKPXfZ^Ij@RZNaVSc[MsMOHQPDJcLIJ_zCG[HQxWJBHXdENRR@XQFWZQQGOFSWUCI[WCJuRGLXNMPLhCl[Ta@SqGgJMGOmyHkKEQMINMAGaGULgwY@UOGiKQ]EYyMKoO_QEIIKiNSMa[LqOKOaVMWMGMDY\\_IKrL\\ERT[DEPYOUA@nNTUHINkRBVMdNvGTxzRF^U`BD\\@tfNDNOJ@Z{TeTJZ@VUcB[OBOeeQT@^OXBJb\\AbWTF`RCJFH\\RDJIJFXW@WLGBKxWTSJJMTVZND@bbL'], |
| 'encodeOffsets': [[ |
| 112903, |
| 20139 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '469035', |
| 'properties': { |
| 'name': '保亭黎族苗族自治县', |
| 'cp': [ |
| 109.6284, |
| 18.6108 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@FJp@fxpQ\\ApN\\GNPNBM`HLMrXLXj\\PEHnI@WUCEM\\GTc\\GZYHTPBHRCPTdH\\K\\@HXiBJILJJAVNTOZJNtFPC`YxDPWci@IBgbGKaTOIM@KNKrP@_hE@QbgKWUMJoWAQMFEKM@wTONCJWRCZDHSAM_UD_GWMKeCITSCGIQBGXUHQoMEEGWDQIG]FMQBMaFGueFeSQDUSDSKOCSFMLUaPWM_PaEGFETMX]RCRR@HXKN@JNnXXESPaDI\\£FkXWIAX]xB\\GN'], |
| 'encodeOffsets': [[ |
| 112031, |
| 19071 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '469001', |
| 'properties': { |
| 'name': '五指山市', |
| 'cp': [ |
| 109.5282, |
| 18.8299 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@TCNOLBTLBPx\\AJdlNRRIbJTGNF\\@RcIYbmHoLQdKN_fCJYbDRRXKZFVEZVXBXIJBXMdESW[CUYHUVQFQAqsEIMPYMSBUIIJKAIjGW[@[LGScDOGQOAGSYZ[HSd[HFNVD@XmJFG[OWiWKNqGKN_MAMO[HoM[BoRewo@Y^HpITSFENc`MVCdHNIVCLJFI`NFIP`@VZbaf[FFJG`O\\WRFA@PVPFPPH'], |
| 'encodeOffsets': [[ |
| 111973, |
| 19401 |
| ]] |
| } |
| } |
| ], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/util/mapData/geoJson/hei_long_jiang_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [ |
| { |
| 'type': 'Feature', |
| 'id': '2311', |
| 'properties': { |
| 'name': '黑河市', |
| 'cp': [ |
| 127.1448, |
| 49.2957 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VÈÞ@kxnX°VÈa°V@kôwbJVkXlVUx@lL@xkVV°VbxlVUnVxk@KkVbIl@°kVl@lÆnkll@@VVX@V²bUlVlVUVÇn@nkJlkVb@x²V@n°VUnlKUn`@n°bWLnVUblVUVVbknV`°kkl@@V°@nzJ@XxlWXb°n@bĠlbXbbVbJ@Vba@@lbUbVmn@lVmnIW@WbÞ@n@x°@ĢaƐéϚnlČ¯ĠŻÈwm@ôçUmm£Xy°UV@wÈ£Ǫ¯kõÝçUÑUķĢkVÑÆÞU°nŎ¥ČUĊx°m°¦żVƐx°Ç£@yUônÞÆ@Èĉ°Kô¦WkWUbÇ»@ÈĕWÇÈ£ŤU@n£ÆUUKVamanwÅmÝJ¯k@JIkaVaUUÇbkaÆÑkWmÝUÛÝ@wnU±@kkV¯KUkJ¼U¦Å@ówķaķůV¥Uaó@Åwm_kVwĉĉmmn_V»a@UVwķóU¦LǫéóXÇmōLǓÇķxÝkĉkmakbUĶ°@W¼@bÈÆ@ĖLl@°J¯mkl¯LݱLamJ@¼VƧUóUXċb¯ńVbkÆÝI@llxk°V²V@UxÞL@b@b`Çzkókݤ@ğ¯WLĉÇLmmnċVkbUaL@¯bU°ğLÝÝ@'], |
| 'encodeOffsets': [[ |
| 127744, |
| 50102 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '2327', |
| 'properties': { |
| 'name': '大兴安岭地区', |
| 'cp': [ |
| 124.1016, |
| 52.2345 |
| ], |
| 'childNum': 3 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@kϙmƏêġb¯@@wmÝ@XV@Ill@bUxl¯VlVbV@ULVlUV_kxVVVÈÝJ@¯Ulm¯x@xóÒĉ¼m¯Wxţ@Uz¯WwnUwť@knW£óVUUwğyó¦WIVmmI@±kwÇ@@b@ĉ¼ó@¯wó@¯aó¼KÅaUwmWUwÅI@aKó@UaLaVÅwō¼UUÝl±I¤VxÇx@zkJmnnmbnzxll¯ČkJl°@kbmx@x@kêmVnWxôXxU°bWLóJnÇWĵV¦UUbbÆġKk¯VU±aXmċÑUwĉKġkVxkÇKkbIÛXWl¯bX¯KbĊÞVÆnĸ²lxU°n°òÈb¦xVb@¯Vx@¯VķÞČlĊ°KĸȘI°¤ČIôò»ƨnȰKǬ¦ôWŎÈƨwlnKVXmbX`lbwkVWXXL°aƾaĊ£n°@°¥ŎzÞ¥»alwôkƒJa@ĶK£bU°ĊxźVÈUĠ¥ƨVI@XU°x°Ln¥w°UmwXmÝV¥Ģ°@nU@mÆ£¯lKÜw@aÅU¥UaÝIkmV²nn@Ķ»@Uk¥VKÞ@ÞÛ@kVmĢa@_Jómǖ¯ÆwóÇa@alUwwĢřk@wÆWXUWXWam@_ƒ»ÇéXaĸwVa@ÝKkUWkXkKXxn@lĊV@¯m¯nřÆw¥'], |
| 'encodeOffsets': [[ |
| 130084, |
| 52206 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '2301', |
| 'properties': { |
| 'name': '哈尔滨市', |
| 'cp': [ |
| 127.9688, |
| 45.368 |
| ], |
| 'childNum': 11 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@°`_JlU@@V¦°JUnLôlnŤ@@ÈaUÒVbkbl¤zk°ÇVÛô°IlVUVôUxÆU@bźĀº@¦b@l²UVl@°ÒĠxnXxÆVô¼Þ@Üx²KÞlVÑ°UȰôlwô@²ĸ°lanV@VŎUll@bÈnÜmwĢ@la@ÝÞb°UXblŎ²ÆkVI@nJnĠ°knÜbĢwna@akÞKƒĀaIVbU¥wĠwkôxnLċVçkaU±IUmnġW°WôĉalÞÅĵ¯@W¹XÝab¯a±X¯ºLaVmkLóbkaVUKVkkKV_@aÝykk±L@ÅU@yV_aU¥ówÇx@UkVn@lkÅlwWVwUkĉmkklW@abVwnWWwWL@UUÇLÇm@wJĉL¥@Ý_@a¯yUWw¯¯Uġx¯aÝXVmaU£ó±¯nwa¯óÅVXmanUlUXkWa@mkIğamIklÇUkĊzkKlUōĬl@nX°@llUxŹ²mKĉVWwk@UbUK@bmVmIVmwaWxXlWČmºÞÆbUxV@ĵńWÆĉLkWUbaWzkbĉ`U±LklōwUVÝ£UW`Uwk@mk¯VkaõVX@WbLK@XƧºWzxK@lmX@bkVVÆk¼Vbk@Vn'], |
| 'encodeOffsets': [[ |
| 128712, |
| 46604 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '2302', |
| 'properties': { |
| 'name': '齐齐哈尔市', |
| 'cp': [ |
| 124.541, |
| 47.5818 |
| ], |
| 'childNum': 11 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Þ@ÞĠKV¯a°@KVblaČUmnnKĊÈKX°Ġ@Þ£ôllÈy_@a@aKÝVwU@±¯Ulkw@kÞJlÅUa°ŃČaWVôƨVU@»nIb²KÞ°Klkn°¯I@kK@ĕÇÅ@aX»¯@VĵlaÿVamI@aÅÝउýĊȗJôȁÅkmƑÛ@kxġ@@laVk¯»īŹak¥Å¯JUaWU@@wa»KUkÆkUmUmwÛ±±UUbUUXwWwÆÝklkUanaWwnKlkal¯kaƽakÅxa¯@amb¯VlÇwÛĀV@xmêVÆVVaôVwÈx@ˌx¦VÞ¯VlmX@L@¯Ua¯LmV@°XċKV@UÈ@¥@wġIUkm¥Źw¦¯lmn@°kxVV@¦óamn¦l@nxlĉVómxnÒĉĀĊ¼þǔêÞ°ˌĠÞÒ°ĀɲĀƨźˤȤƨĊ°w@£nymwnkUUV¥ôÑVmkÆmUUVamVIkmôlxkXÞþbll@kVƆVxV@¼VÒ@UnnÞJ'], |
| 'encodeOffsets': [[ |
| 127744, |
| 50102 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '2310', |
| 'properties': { |
| 'name': '牡丹江市', |
| 'cp': [ |
| 129.7815, |
| 44.7089 |
| ], |
| 'childNum': 7 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@U`lLUlVLUlbaôlKnUbK°¹²W°baÞbknyUlUkamř²L@m°@lm²n`ôÅlKxÜKnxV@l@ÅXyW_k@wmŹĕmX»Ûl°ôÈ»ôô_WW@Ual»wU@@wUV@VXI@wĢ͑ÞȻaU_@mUkly@¯óV»XmWUXUWmnm¥nUUaWLk»Æ²IÇawÅaÝ°¯nUa±a@¦õÆğ@@ÅbxUÜnÇłlb¯¦ôó»m@±Uk@Wwa¯xUV°xXbÇÅUVK@¹KUaȯ@ōÝXallÛkalÇUǫÇÅÇakbÝƆ¯nl¯@¼VUx@x¯W¼Æ¯mĖĬ¯ČVkķÅmx°ô²V¤bUnÞW°bĢw°V°XxV°z@bÞ`@¦KĊI@xnÈÈKV@VXKxXmXUxab@kXllĊnVlUxXkxlÆkm@UVl@ÈwôxV¦bU`@zÆV@²KllÞz@b'], |
| 'encodeOffsets': [[ |
| 132672, |
| 46936 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '2312', |
| 'properties': { |
| 'name': '绥化市', |
| 'cp': [ |
| 126.7163, |
| 46.8018 |
| ], |
| 'childNum': 10 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ऊþÆÞ@bnJUbĀnblĊÞlĸwǔÈŎKÈnôWǬêKV¥ĸôUx@VbU¼m`nnĊĊxlUmkaVÿLw@°»UmbKmÝUwUmVknKUUl¯KUUÈnK@ĠkX±lX°L@¯¥@wV_mĵ¯WwL¯UkōÇVUlwVó±¯aVka°wVk°mÞ¯ŦřÆl²ŎkU@mUkb¯ķ±ó@kxȯó¯VUÒkݱLÛwÝ@ó»ÅUWwmğw¯Ñ@UkV±@ka@¥¹Źÿ@aÅVwóVVUkU¯JÜóÈUl¯yk£laUaVÑÇb@ţ@kmómKV¯IU¥@@kVI`@ô¼blUlbÈb@xÇKkĢɳaÅɆō@VK@z@@¥ÆKnÜ@@aÛUwwnUķ@_V°@klVnULVVÞbVl@°@nxn°LÅÆlVÈmU²@VmĠLxn¯xkWzJwnLmbXbW°Æ²@x@JVxLĀ²Æ°I¯ºÈ@ÒnÈ'], |
| 'encodeOffsets': [[ |
| 128352, |
| 48421 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '2307', |
| 'properties': { |
| 'name': '伊春市', |
| 'cp': [ |
| 129.1992, |
| 47.9608 |
| ], |
| 'childNum': 3 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@K¯kWW²ğl@mLÇVVLk°VVmLUlVnxVnÞLnaV¯¼@xKUĀlbn`nÆxô@VbU¦ĸŰĸbôxÆ@V¥»IVl°LUll@²mVx@ÞÜÞVnlXÅÒlbÈaVVUblbJ@I°lÞInÆmxnbUbVLÅVm¤@ţVǤXÈÇĖ@ȼaXVÜaXbWnzŎařKôbUlw@¯naÆKnUU¯Üa@mkkVUĊmżÝǖK°L²lÆI@¯¥ĉƛVaÞk@ÝVaĠlnUVwóma@wĉ@aVxamX@a@UaÅLaVW_nWm£nWm_ÅV¯m@mó¤Ý¦¯ÅalmX£VWUÅwmÇ@@IVWUw@aI@k@wŎ»WÅVaKIka@¥lUkUlwÅwVyÈwWU@a¯U°mÇ@UçaVa¯mV»ÅwÝUlUkV@kmUkX£w°@@ÇaÝIamÛam¯lğmmI@JUl±ÅōkWa¯VÝa@Þkbġ@xÛnÇm@akkōVōl±kÅťŚÝ°¯nUl¯xlbU°b²ôUxkVÈUŎVl°KXxĶ°nU`@x°¦@'], |
| 'encodeOffsets': [[ |
| 131637, |
| 48556 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '2308', |
| 'properties': { |
| 'name': '佳木斯市', |
| 'cp': [ |
| 133.0005, |
| 47.5763 |
| ], |
| 'childNum': 7 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@nbÞJb@ȯ@xW¤Vln@lUVlkÞVÆxU¼°nUbbVèÈ@nIn@ĢmlUw°żVUn@lnL@VôbwĊlJķĸĢlwôwƨxVVUŦxLźÈ°`nnĠwŎJÞĶwôJ@¤XnÜĸln°¼È°lUbx@l@ÞÞÈm°lôwL°¼ĸ°Þ²nĠ@ôwÞ`ŤIVÒĠU@VJĸbƲ@°ĊKJĶaĢȰ@ô¥°n¤bČU@VxmUw@aÝţÇķ@ĕķīU¯²@ÆmVÑô¯X¥ċç@ĉ»U¥ÝţKWVÅkUVÝŎUmÇÝx¯aķxÛUóL¯a±óōb¯ÑÅVÿ_Åķa@UK@wm@Van@UmmLVa@VImmXUWÝUÅKUwÝUUkVk@l¯XÅ_J¯kJmÅLa@¥U@¯Vz¯@`@¼mxƥŏKÛk@±laÛ@@Xm@@xƽ@WŎnˣĕÅ@@aÅ@@nÝbǯ@_UkUWkbwÝU@çWlw@anI¯lyX°m°VaÛm@mVwÞK°XlaXmm_@UkwÝK@VIXmV»I@a¯ğWbġaU_¯JU¯ġĉkō`±nÝÆkbóĊ¯XĢXmVn²JVlbUèČmKwlóğxxV¦UaJbƑÿÝLl@bmbġx'], |
| 'encodeOffsets': [[ |
| 132615, |
| 47740 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '2303', |
| 'properties': { |
| 'name': '鸡西市', |
| 'cp': [ |
| 132.7917, |
| 45.7361 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@LKVVnkbVÈb²U°VnklVlaÈL@anU°ÜmXV`nôLèxlLXL²aVVmÈX@ķlnUÈl`ȹ@Ť°U@xKnnVmlnnUllVnnaŎwlVÞÒ@n¦LV°lwVkLaÞlnÒ@xmLÞ¤Wn¼WÈLVVUxlÈôWVaU_VKKXUÆbnnôKbÞw°bÆWXamVwKUw¯WUkUlJUwVUa@@kmyzmĉw@kVwkW¯ÅKU_VmxU@aW@@kK@wa@K@@kVUaky°_Vmkna¯K@Lwġk@@IÇóXwVakmV@mwXUWanlĉ@ÇUwKóܛNJÛm°@wÅ@±b¯W¹WVwŹĕ¯kVmōb¯w@awmVUUbVIkaVwķxk¼b@VXXó`ó¼Çó¯kܼWnźĖnxl@X`WzÆ'], |
| 'encodeOffsets': [[ |
| 133921, |
| 46716 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '2305', |
| 'properties': { |
| 'name': '双鸭山市', |
| 'cp': [ |
| 133.5938, |
| 46.7523 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@UUwómÑÞÑUÝÝUkmmÅyV¯ī¥Uÿĉ¯mÇkaWbÅX¯aÝxaóLmmÅaWVLULV`UbXókÇVwUUÇKX»XmÝ£nK@wmÑkÝbKUlx¯kUKm¥@ÝÑkUōxmbUmkVkmmnkUmmL@w¯Vţ@Ǻk_ÇmVk@ĸVxVÈ°lLkllUbōwnVW¼nlUx¯XmWUnÝ@xÝUó¼¯J@LVbkJWnkbW¯ÝLUxn@nÜb¯U¯nWkz°mJ@bkxX@èÞVxlaXlVV`°@ÈÞa@mÆ@@bÆ@ˤĖmXōƾ@@wn@@WÜ@kb@²ÜlŐLƦnw@»_°@y°UV@@¦bÆKnI°lIÆ`°W@kllUVÞVVxLÆÞVXWVnnUJ@UbnKVnm@Ubn@@xL@VbÆĸ`UĀÆÒ°Ŏa²ô°bôKÜVĸw°bÞwÈVnÞōVUÆlXU'], |
| 'encodeOffsets': [[ |
| 137577, |
| 48578 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '2306', |
| 'properties': { |
| 'name': '大庆市', |
| 'cp': [ |
| 124.7717, |
| 46.4282 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@mÇ@ÑÇ°¹¯J±ÅÿKUwI@w@±ÅX¯WanamKxIylX°wmwğKUn±@nVÇUÅkƯKmmw@@¯UkÝaUUVKmUlk@¯U`ĸ@VmxVxÜ@bÛ@mÅL@¦@@yLUŎ@ÆɅɴblġÈL@wÇaakkVa»@ó¯_ÝJwÇaÅXnyU¯¥Å@wbÝaLmm@@VUlbğVm¯Xm_`¯_UxmLa¯b@maó¦Çk¤V@bóJknVxVXx±aLUbVxkLVlLWl@nX@VÅbWlÈnxbWÅbm@xbml°bXbWXVmnn`Lmnbmb@k@mwU@@¯Jlbk°lbkmLXxmbVbkllÅÞxXxVWVVa²VܲnxVVnÅlVlL¼b@xV@XVbIÆ°¦lźbĬ°¼Ulb@kĢ@lw@ƒÜlnȂÆóȘIĉ'], |
| 'encodeOffsets': [[ |
| 128352, |
| 48421 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '2304', |
| 'properties': { |
| 'name': '鹤岗市', |
| 'cp': [ |
| 130.4407, |
| 47.7081 |
| ], |
| 'childNum': 3 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Þ¥ô£nn@°ÆUn`mXn¤mX`UXbÆKVb@@bnWbwUbĊ@x@nbWVm_mm@ó»UmÅWXkĠ»²¯¯nķwŎ@ĊŎK°bĸUnÑKȦĠÈbÆknJÆUĢV°IVƾwaVkǯ¯»mķkÛWm@£óIĵxÝōIğxmm¯_ÇŹKwťUVUƧwóxxġkĸķIkĉxóa@UmK@kVmUŻ¯Vxkġn@mmJ¯n°V@bXVÇxUzÆxkxlVkV@¦lbJLUbÆXō¼@xl@J@bVxXU@JÈ@nxVÆUXW¤knÆb°'], |
| 'encodeOffsets': [[ |
| 132998, |
| 49478 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '2309', |
| 'properties': { |
| 'name': '七台河市', |
| 'cp': [ |
| 131.2756, |
| 45.9558 |
| ], |
| 'childNum': 2 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@²mŎ_lĊĢV°°IV`ĢbaĠX°@bJU¼WnUJ@ÞLlxV@n`lIUa@K°Iô»ÞVwÞ@VmnX°WVwmkX»UmŎxVaklkkKǯUUwÇWUnU±bKWKkwçóKmU_nW¯ÛmV@bÇKkbkUml¯U±VÇaUamlUULKk@U@mwÛLwkLóÆm_±nk¯@@n±KnŚlbkVVmzlWXº@Ķ°'], |
| 'encodeOffsets': [[ |
| 133369, |
| 47228 |
| ]] |
| } |
| } |
| ], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/util/mapData/geoJson/he_bei_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [ |
| { |
| 'type': 'Feature', |
| 'id': '1308', |
| 'properties': { |
| 'name': '承德市', |
| 'cp': [ |
| 117.5757, |
| 41.4075 |
| ], |
| 'childNum': 11 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lLnlmxnIVVlUnb@VVxXJWL@LÞVnnVJ_@wkmKbxwXkWXXKlb²K@nVVVbL@WlU²lKVnUJVz@VVb@lżmVUVnbôaVX@°Ub@lWbX@b@bVb°x@VxÈLVlaÆ@Þb²k°@lVU@Xn@VWLXb@¤VXKVVVLnm°_ƨ¤@aUIVaalkX°kV@alwUVyU@kó°na°UVUUmUÆw@mkLVUWVIWLnn@xlVnKmyU@U°UXaV@U¥U@UÆ@aVUkWU¯aU@WLUV@bkbmKULmKkUVUkmVIUwlWV²Uml°U@WLUwVm@UUK@_KUUÜaXw@VKUU@mVIUUlmnIVVVbÈVlKnbVK@nI@nVnwVLVKKVnb@aUIVW@In°@lVnI@lWĢ@°UVL@b@VyUUa@w@WUnU@WǯK@UkkJWaÛbmk@mVaÞU@amkW@mXUKkÿ£@akl@Um°UXwlaal@nmlXnW°znW@awV@akbĉ¥VmU@IVUJkUmWUKbmkUaKkUVU@KV@@klwWaU@kmXVènbmlUUKX¯JkbI@JmIUWU@Lml@XkJ@UkK@aVKwWaIWwmU@mU@J@UaċUaUUVkI±k@UU@UbVVm@UVKLlkIWaULUWXUJU@WbUb@lkXUxm@@JVn@J@bnb@Vkx@bLUÆnJaVXnKVVmzX°V@_lJXxWXK¯bÅamU@lUIbñJ@LÇKkIÇ`kxWL@@@bUVUb¯xWKkÅVlULW@n¦Ul@IlmUUUVm@kWnkKma¯XUKWmnwVwÝLmVUbUVWb@LnxmxVmbXx¦@nb@`V@kbLUmVUlkbVXkºmnm@@xk¦bĢÜl'], |
| 'encodeOffsets': [[ |
| 118868, |
| 42784 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '1307', |
| 'properties': { |
| 'name': '张家口市', |
| 'cp': [ |
| 115.1477, |
| 40.8527 |
| ], |
| 'childNum': 15 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@kġÛal¥@wn@nml¹UWlaVknUVKla@U@_ma@¥WwnaUwnmw@KXaVUVaUnmWUk°lnUVUXWVwIWVóKUI@WXxUU@mma@kUKWLkw@yk@aVkUUċaUU@Wk@Unm@UVmLm±IUkJkW@aI@m@UVUla@VXVXmVwnkWKKU_k@m¥mX_JmnU@km@U@KmUVU@U@Umk@@LmW@Û£Wka@wk@aI@mmk@mUa@UmUIwW@aWUbU@kbÇ@kw@makVUkU@am@aU@mxkUbKUXU±KXVWLUK@wkU@V@WXUa@WbUxJI@¦VèVVX@±ê¯KUI`¯UULVx@V@UKIVkLmVkKm@nUJÝbkIUJVXVVxVbUVJUn°bVmlU°XnK@Ul@lVÈVUXx@W@VXVKÞbn@VnbVm`UxkW@UVkLKm¼@lUnUJVnVXV@Vm@@LVklIkl@VWlULWKUL@mJ@blbUVUlmzUJUxm@UUbċÜk@Ub@VLVV¦ôbVmUKUkU@m@VlVn¼WbUJ¯@@°nIllÈl@nXWlLkJ@bkxlxkxlXUlklJXL@bWn`@nÆXxlL@xl@XbLKlVlIXblVUbUJW@lX@VL@VVXJwn@WnL°KbVbl@VI@K@U@nmVmV@XUWI@aXm@VUUkWmn@lmUUk@mUmK@UnwVĉ@mU_V@XJôVVULVUn@llUnJl_n@ml@XlLlw²LVJUL@VmbVblVXmVnl@Ť¦nn@Ü@bl@@XV`Unb@VlLVb²JXn¥ÆÑ@¥Þ@'], |
| 'encodeOffsets': [[ |
| 118868, |
| 42784 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '1306', |
| 'properties': { |
| 'name': '保定市', |
| 'cp': [ |
| 115.0488, |
| 39.0948 |
| ], |
| 'childNum': 23 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VbXW@@UlV@xVLXKWU²LVVWLalVnwV@@bn@bVVllUnb@lxÈ@laV@aXV@bXxJnV@VVb@nnl@nJ@bll@aU_VWUwVUkUmUkb±mVwU@VIUW@UWk@VU@ynLm@IV@bnKLVaVmnIlaXwV@@WVL°@@xnX@V`V@VbUVVLVKnwnL@ll@@_V@VVnaÆ@KVXÆ@n@wKmUWm@km@kÜKXU@ÑW±nIUwVKla@I°wU±kkmm¯m_JnawW@IVaUama@wUmU@mVw@aXk@mWa@£km@a_kVmUnWW@¯bkUmk@VÇm@@kUUKUU@UVUamVUaWIkb@xU@@amUkKVkam@@kVUkUWmKmUkLUb@xmJU@UImVÛVmnUwJU@VX@UWm@Ub°¦UmxklmX@`ULU@@UW@@xkn¯@makVUmxUb°lUbUbnUJUUVaLkbUUJUU@mUUUJka@xUIWJUnJ@Vz@kb@`@bln@lb@X@@@XlbnbVb@VJlInlbVw@UKl@lbnan@VbJôLnUzlV@lÈLVbVK@LVxVWXX`WxXzbV`UXV¤nx@bVlVnVlUL'], |
| 'encodeOffsets': [[ |
| 117304, |
| 40512 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '1302', |
| 'properties': { |
| 'name': '唐山市', |
| 'cp': [ |
| 118.4766, |
| 39.6826 |
| ], |
| 'childNum': 11 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@VVl@²lJUVVbČVVb@@InV@VnXxJXbxUL@bLl@VlI@WnkKV@VXnJ@IJla°IWLVVnkmaUçWVkôaܯ@nV°wnJlaV@VUnUUaW¯wXWWwna@£UaWKU¯¯@aVUkKUamUUn»anIVwUWlk@LlWVakU@K_lbÞU°@y°n@KÈkWWţ¥ĉōkġWUw¯£¯Çwţw@kK@k¥ÝwÅbÇ¤ÛťVlW°@ĸx@VVVULVLkl@V@X`Ub@Xm@UWbk@ÆVbnLWV@lnXUbl@X¯lmUVkKWLkK@_UK@U@UmmUxmVXLWVULkU@`W@ULUK@XlJXzV@@xml@VU@UX@Kk@WbUK@Xn`XmJnmkxUVbUVlVVxUbV@nKlLkVKÞbVKXI°KVmVUIUKULVxVJVLkV@V@UbU@WUU@UbUK@b@nV@VkLmb@b'], |
| 'encodeOffsets': [[ |
| 120398, |
| 41159 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '1309', |
| 'properties': { |
| 'name': '沧州市', |
| 'cp': [ |
| 116.8286, |
| 38.2104 |
| ], |
| 'childNum': 15 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@ln@UÈl@Vnl°aX@mXnVlU`@bln@¤Xb@nWl@bUx@nnVV@xnbVbUb@JXxbmXa@kUVwlWkKôVm@wkkK@kl»ÈmVKXkla°@XVV@VI@ml@@Vn@VX@V@J@VxUzVV²blVk¦@Ġ@@»@VK@VÈLlK@XnJ@alIUlaVVb@n@aU@WUIV@mUn@mKXml@lL@LnWb@XV@@aVVbV@VVIVWÈbIÈ»ƒǟlWaVUÅUUm@kVUWVkaUwmaóUJUU¯ÑU¥mk¯UaKÅnÇyóXmWÛX¯aċbÛaJWÝU¯»aóóUm@IVVl@bLUJWLX@@xXUxl¤V@VnVUVXVbV@@@VVn°V@ţU¯VUmUWV@mUXabUKUwUaÇKnVk¦Wb@VnLmV@bkV@nxW`Å_UVV@bUklVX@VmlUx@VVL@xVWVL@VW@UUm@'], |
| 'encodeOffsets': [[ |
| 118485, |
| 39280 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '1301', |
| 'properties': { |
| 'name': '石家庄市', |
| 'cp': [ |
| 114.4995, |
| 38.1006 |
| ], |
| 'childNum': 19 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@la@y@UImVXIVJw@lbIVVnV@VVIVVlaKbVUVVImVaaVk¯VanwVlUnb°@lm@wX@@VV@VK@_nWlknwV¯¥Van@VX@W@UVIVxnmÜUnUVJV@nI@wValKnV@kmU£na@mVk°KLVa@UU@UmknWWkXU@aWW@@km@UaU@@klK@UkaWaUnamm@Ua¯wWU@UkL@Un@xVlUXVJUbLmU@aUWUkmKkLUUm@mWXammkkWUm@@U¯JUUmkU¯@mKĉxÝwÝ¥LUómwkUUUWVkKmkKmLXlxVLVxXJ@nVJnz@VWL@`nX@x@kVUUmJmIXxJVnUV@UVV@LU`UXVVlXL@l@b@VmX@bxn°UbkKWLXlW@@bKmKULmakLUlmb@Xb@xmXU`Vb@`lLx@nWVXL@°WlXnlbKVKXVb@X@l_lJ@V@XnI'], |
| 'encodeOffsets': [[ |
| 116562, |
| 39691 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '1305', |
| 'properties': { |
| 'name': '邢台市', |
| 'cp': [ |
| 114.8071, |
| 37.2821 |
| ], |
| 'childNum': 18 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@nKlLnlLXUVVlVnxôVKÞ¦ÞxĊwnL°@lVnVV°I@Vn@VlXnlnbWnXn@VVlKnLVlVX@bnVKVaUIVWkU@wVm@¯@U¥VmU_°lKkw@LXVaU@wUUUKlUóW@UVUUl°KwlKU_naKVnlKkkWWa@IJVa@IlJnU@KVUUmVlaXUl@lm@kXWÝÑnk±k@wğ@@U@mKĉLmVJ@zmlnWLUÝJU_@@mJkXUVlbklÝ@Ýab¯@¯±JÅwġaUU@kU@mVI±bUKLWUXJkaLóKULWbUVkKmnk@@bmLUl@b@mnmJkUULabnmn@lVV@¦n@l@bznx@`Vz@bxnV@xllbnKVx'], |
| 'encodeOffsets': [[ |
| 116764, |
| 38346 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '1304', |
| 'properties': { |
| 'name': '邯郸市', |
| 'cp': [ |
| 114.4775, |
| 36.535 |
| ], |
| 'childNum': 18 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@bVKlVnInm@@akVnK@al@nmlLVUXaVKôLKlbIVWXKVL²aJnU@lV@VVĢbÆx²I°°@aÞbÞ@lkkaVUlWnI@@V`ÞIVXKmnk@yInUĊKÇkUUamUUk@aU@Uk@WUwVkVJVkkw°a@mK@UX@VVLVW@wwVa@¯Xm@@lUIWaU@UWkXWmU@UwmUkKmn@lkV²VaULUVmJUUUwLma@UmkIUmLmVmx@bLUamKÅL@VmbkU¯KÝamzkJUb±VkbL@lU@WIkJzkKmKnUalWkkKW@@nkbk@WW¯XUVUJ@XlJ@X@XlWLkU`VUnaWaUV@UVIaUxUUmVK@I@W@ÇU@@U@b@nmKXmx@UxkVWUX@`VLlL@`zXÝb@b@VUVkIUJVz°KVlnLlKnLxlLVVUVlXUJ@nnI@mVUlbn@@m@bVnV'], |
| 'encodeOffsets': [[ |
| 116528, |
| 37885 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '1303', |
| 'properties': { |
| 'name': '秦皇岛市', |
| 'cp': [ |
| 119.2126, |
| 40.0232 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lnV@Xbkx@lU@@LUVlVLVbnlaLXVVnlIVUJV@UnĊ¦lab@nJ°UmV@wn@VUJVI°bnWlXnWVLVK²bakklI@aUaVUwVUUalaVwnUVak¥X@WkLVÓmmUK@_lW@n_UK@alÅ@ğÅƑŃÝm@ÑţÇlL@¯mz¯@ÝVak`@LlVUbkXK@klVXUxJmbm¼VnVVblLUV@b°V°XLVb@¤mbXxWX°xXVbmVUVU@kbmI¯xmU@Û°óbUl'], |
| 'encodeOffsets': [[ |
| 121411, |
| 41254 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '1311', |
| 'properties': { |
| 'name': '衡水市', |
| 'cp': [ |
| 115.8838, |
| 37.7161 |
| ], |
| 'childNum': 11 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@KVlV@X°xb@VnnmbVXblb@VkL@lV@Vbn@@l@XX@bWVXlmXnlVV@@VUbK¯LUl@nmbV¤n@lLXnlVUV@ln@lbUlLnV@bV@@wlaXJVbnUVbVU@VVLVVn@VVX@@UKXUU@wUK@UwVnk@UUWlkV@aUVUÆ`X_w@mlU@anUmK@UXal¥UmÈLVbVxVLabVW@nXUVnV°UŤV@U¯Um@U@@UUaWVUmUUU@k£VwW@wW@XKIUa@wU@@al@UK@_mKXKbUU@aVKm@Xm±@kbÇakLğVaUw@a@mkUJk@ykw@£WX@lknk@WVkbUVnUVL@mVkI@JUbI@JXbXllkLUmLmbV`kLx¯LkVUV@VôXkVVLVV@xVUbW@KxlL¯kV`UnV¦°@'], |
| 'encodeOffsets': [[ |
| 118024, |
| 38549 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '1310', |
| 'properties': { |
| 'name': '廊坊市', |
| 'cp': [ |
| 116.521, |
| 39.0509 |
| ], |
| 'childNum': 9 |
| }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@laU@UnL@VWbklWxnIVVV@XJlbUlXVbn@@KmV@@X°WVInJmn²@lmVbnL@amKV_kwlmX@@LVamaXaaVU@UnJVanLlUkaW@UaVakK@IlKUU@an@ln@alKUkIVa@a@klaUKUV@UkUV¯KVV@kUmU@@a¯ImJUU@VV@UL@U@@WXUWa@Ukwm@X@@w@al@@aVIUmVUUUVWUknK@I@l¥kU±aUUVyUw@@I@UUWm@@Uk@@nUJU@WU¯@kbWlULnÇk¼@llLl@xUnóLlkXUxV@lWbI`°nnnllV²¯x@JkbLUVxmJX²@ÒWVÛL@lln@XnnVL'], |
| ['@@@kX@Valaa@KWI@UXW@WanaUIW@UaUKķk_W@UVUKU@b@UamxVXnJUbWVXLVbn@W°kb@U@Wó¼mIU¼k`V@bVbl@lX@lUôVlUIV`lXVn@lUlVn@l@UVaIUWl£UmVWU@@UUKlUUUnVL@KUnLVWUa@U'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| 119037, |
| 40467 |
| ]], |
| [[ |
| 119970, |
| 40776 |
| ]] |
| ] |
| } |
| } |
| ], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/util/mapData/geoJson/he_nan_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [ |
| { |
| 'type': 'Feature', |
| 'id': '4113', |
| 'properties': { |
| 'name': '南阳市', |
| 'cp': [ |
| 112.4011, |
| 33.0359 |
| ], |
| 'childNum': 12 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lKl@nVV@bn@VVnmnLLXx@VLlKVUIXWÜ@Člbl@XUĊUlwnWLÞwm@ÞUVmnVl@nXJXLm@VnnJlaI@VkxVb@VlnJ@knKVn@°aVanal@XK°b@¯VJXIVK@al@nVk@nKab@XL@blVVKVLXK@VaVI°mVaX@V_@a@yUkVwVIVaJ°@anIlaV@nKnXÆm@wUUV±UUWUKnaWwXUWmůVam@kakImUK»lan@VXXaW@@UlUUa@a@UlwUV@Xal@@anIVaUK@VXmwVmUmVLXl@nalLnal@nKlkV@@UnJUXnl@nVl¦V@@VnJ@nUVVVVIn@VaJÆn@@K@mka@kmWVaUI@a@k@@aUL@mmaVIUKUV@@IU@mUmmL@K@UUUU@mW@@nU@ğ»mVmbk@klW@UXnV@LJmlUnUJUUUW@UnkKxmLa@@@lUUbmUVWk@@nkUmam@UakJU_Vm@ÅlÇLUVmVUwULKU@k@UVUlU@@U@UaUUWaÅzJaWLklb@bmL@kKabWUV_@mV@b¯JmXUbUK¤ÇLUU@b@JkLWmkUWIkJ@VmX@JUbVXU`¯VV¯blK@LXKlUV@Um@@Uk@kxWkbL@KkbmL@UXmaU@@l@x@blX@xUJ@bULUlULÇ@@VnU`W@@nÛ¼U@@VmKUkm@VVX@@xÇ@bUbVb@VX@@xLUb@l¼XLlbUlVVUUb@n'], |
| 'encodeOffsets': [[ |
| 113671, |
| 34364 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4115', |
| 'properties': { |
| 'name': '信阳市', |
| 'cp': [ |
| 114.8291, |
| 32.0197 |
| ], |
| 'childNum': 9 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VllInJlknJVkVU@mXlUÞ`VnVVU@U@y@nXlKVnJVkXKWaXIb@yVkVUkVwn@K@nW@kKlUXVVUlbnUV`n@V_V@llX@@Vb@bV@@nlVUb¯WLnbmb@nLnKbUbVWnLlaX@VVUX@Vln@`kL@ll@VXVJÈIVl@XÞJ°UnaLlylU@UXKlnn@lanLWWnbVI@KXKVL@LVWVL@UVKUIVWX@@XÆJ@In`@lJVI@aWÛnK@UlK@UU@VKnlmnXalUllLUbVVknJ@nV@Vm@al@@xnVlJVUU@w@ak@XW@_mWnUlŁUmVKV@VXwW»XWaUwnkWUkVUU@@@WlaUkkaIWVkm¯xmIUmLUVaUIó»m@mmwXk@amk¯¯l@wmkLmmU@UbkUWJ@XUbJ@b@l@znÆmK@Xk@Ub@lm@I@akmVKUUVUkU@U±JUbk@IWmkxa@UUVUWVkIUaW@UlLWn@VkJI@VkK@L@bmKkJmUUaUKWXk¼VxnJ@V@@VULV¼@@UkaUlWL@U@W@IkKmL@KULUWULWKUXUJmIbK²UWnWKUUkLUmUUam@UU@mUL@xkV@VV@bmV@Vk@mwkUVUx@mbXÇnVbUL¯WnUVLVb@xnlWnU@UVUVVUbVVlVkn@llVUXUWUXVbUJ@bmLUJnb@nVK@bl@@@bVJUbnX@lb'], |
| 'encodeOffsets': [[ |
| 116551, |
| 33385 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4103', |
| 'properties': { |
| 'name': '洛阳市', |
| 'cp': [ |
| 112.0605, |
| 34.3158 |
| ], |
| 'childNum': 11 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VVUllLXl@LWn@J@bKUVmnL@`VblLnbV@b@JmL@LnV@VV@¯VJVnXL@nm@aÞ@ak@mImVbXLynLk°@°aVJnUV@UVVXk@WJ@VXLlUnJVnn°U@»°Uwl@bWmUXÆ@VLXU@m@Ua@Imkba@naWW@_@WXUV@@U²@K@I±U@¥kKWLóLla@£Um@kWKXU@mlLXUVKUU±J¯_@`UL¯Wmk@WakklUnVUVaU@KUU@mmK@_a@KX@VaUIm±kaVKVUkw@kaW@kbkL±UUaK@UUKVak£@UmmL@lIkmU@Ualw@UJkbmIUmn@WKImWk@mUUnÝV@nÝxKmXkxĉVWVk@kaċÛ@WXJUV@zmVWnbUbVbLlUnlUÒnWVVWnk@@Vm@kxm@Unl@Ll@@V@XnkJVV@nlVXxU@ln@a@VLnWĊ¦nx@lbVKXLl@ÞVLXJl@XXl`lIXVl@XlXUVKwV@lanxzUbVJ@VVX@b'], |
| 'encodeOffsets': [[ |
| 114683, |
| 35551 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4117', |
| 'properties': { |
| 'name': '驻马店市', |
| 'cp': [ |
| 114.1589, |
| 32.9041 |
| ], |
| 'childNum': 10 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@n@b°UÆXnVlnLÜ@VLm@n@na@Jm@k@lVVxXX@V`lLVXVV@VVÞLVV°²@labnxV@@bLmlm_VWnIWUna@lLbnV°VL@KVLVUVaVLXK@mÆXna@wVma@Xw@KlL@a@Va@wUkaWnIVla@Kn@Vn@VUl@nKVnJ@LnK@aVkVUUW@VakUVanI²XW@UUU°KnUVLl@XaVK@aU@KUI@W@_lm@KkLUKV_U@»@UVJ@XV@@mVL@K@U@Kk@VwUUm@kmWL@VkVkzKmb¯VÝI@WUkÇJUIUWk@@klK@_km@UVWUUW@kbmKUXaVamLmK@namaXK°VakU@mU@@aa@UW@kkU@U`m@U_mVkaUVWUkVL@lmX@Lm@UxVlUUl@zaWJXbWLUlmIUkLmW@@z@VUVUUmÝ_kVW@nUVUlmIklmIkJUkl@n@Lm@ÅIUbm@UJUUVU@mmI@UU@k¥mUk@WmVmI@VU@klmLk@mbkKmb@WkKUVnUnnxW@UVLUbmJ@bk@WbU@Vkx@V@bVbkV@V@XWbUWm@kb¼VLnlJlb'], |
| 'encodeOffsets': [[ |
| 115920, |
| 33863 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4116', |
| 'properties': { |
| 'name': '周口市', |
| 'cp': [ |
| 114.873, |
| 33.6951 |
| ], |
| 'childNum': 10 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lnb@xlJ@UnLlKXUlJl_KnV@xVL@bkbVVUè@Wb@UbmkVmbXVJnUl@a°@@bLVblXxInmnLVwanJÆw²IlmnXVl°VVbÈaVb@lkn@VWnLlUVmÞUUklkVkUaVaVaUwK@kkaVWmw_l@nUVVb@baV@VV@zXJl@@kl@lk°WVnÆbnbUVJI@VKVm@kK@_kK@a@aU@@wW@@k@aUW@IUWVUnLlUlVXKVwmk@W@VWa¥@k@lnUIÇKUaU@UUVmIUVUk¥Vma@¯k@Wanwm@@n@@m@UIVkUVamUXWaVU_@mUVUImW@aUIĉK@VmIb@lU@@nJkU@KIUmmLk@UVm@Um@@LkbUmJXlbV@xUb@@bkK@LWx@bUn@xmbÅW@nWLUKUbUVKU@LUK¯mU@VV@xULUVL@bU`WUz¯aUamKUa@@xkX@x'], |
| 'encodeOffsets': [[ |
| 116832, |
| 34527 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4114', |
| 'properties': { |
| 'name': '商丘市', |
| 'cp': [ |
| 115.741, |
| 34.2828 |
| ], |
| 'childNum': 8 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@XVl@lLÈ@VkV@V»UanWX@VaÆÇô@ÈaVX@xVJXUÞUaVLĸbXKlV@m°Vn_nyXX»mUk¥lK@a_@yInaVKVa°_@WXI@@KVnIlbnaV@l@a@_w@lwUKmXa@UV@»Vw@kUKVUUm@w±VUXUKUwmJUU@km@@±mXkmUI@mmKUwkbWakLWaUIkJmX@l@@VUX@JWbX@VbULWblUVULknlV@bVJkmb¯KknWmk@@nmVkx@VmU¯KUnUL@JUIVmaÅaUm¯Xlkk@@lk@WI@yUUU@b@aUaUmVk@`nxUXlb@lLVxUbUbVbUllkVlÝVUnkVmKUXm@kl@nUx@xnxn@`VX@V²x@V@b@Wl@zU`VUVVbL@VbW@bkXllkLWV@V@VVÈwlV@@XK²LlbWnnÆL@VnJWn'], |
| 'encodeOffsets': [[ |
| 118024, |
| 35680 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4112', |
| 'properties': { |
| 'name': '三门峡市', |
| 'cp': [ |
| 110.8301, |
| 34.3158 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@WKUmUI°U@@UmU@KnK@IaU@makKUa@_KnmVUL@a@IXm@KWkkKVkUU@aUW@UUIVaymwkbU@xLVUWWkk@WUkJk_WWk@WIUKÝk@WKULka@mwĉ¥mXUK@@bm@kVWwkU@mUUlIWm@@Uk@@KkVmn@lwn@@Ul@XmUXUmVÑkmkVKUaVamaUXn@ykLUK@WwKmKnUm@UmaU@mUk@kL@lxċxUnkVmnXxWb@`kzWJ@VLmVUnlmUL@lW@Ub@VXUb`VLUbUJ@nmnUlUUm@@bUJlnUU@lxkb@@XJUn@kb¯VVVmlXXlJlzn@VlkVW@bkKbmkUbVblXVxKÈnwÞlĊKlVnKlwX@lL@xlUnVn@l@lmX@ÆÈb°¼ÈwVJlx_°xalUÈxlUnbVxnL@lllbmn@nb@@VL@V@@VLJnIVVlKnV_'], |
| 'encodeOffsets': [[ |
| 114661, |
| 35911 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4107', |
| 'properties': { |
| 'name': '新乡市', |
| 'cp': [ |
| 114.2029, |
| 35.3595 |
| ], |
| 'childNum': 9 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@XVlLK°bUblbUbl@nX@WXVVKVk@@mb@UbnW`kLLV@VVLnKlVXIlV@@a@l£nWlkVa@°bnUlLVlnabnUVUXKlU@@lk@aI°y@ôkUU@wmônkWakmlUkVmkUlmUUm@nkUKWanamULXW@UVnUln`lblL°KXV@ĠJ@L°JUVwanK@UUImmkK@¯±Um@IVmUmmÅnWaUK¯aUkw@W±kVxUVwnÅJUIWaÝJóIbm`ÝbÅImJUI¯¥¯@mU¯UJmnUVóUkl±V@zXlbWVXL@bmmº@@XmJUXU°llk@nWJk@U@¦U`m¯Wx'], |
| 'encodeOffsets': [[ |
| 116100, |
| 36349 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4104', |
| 'properties': { |
| 'name': '平顶山市', |
| 'cp': [ |
| 112.9724, |
| 33.739 |
| ], |
| 'childNum': 8 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@l¤UbVL@VLVb²VlKlaX@lb@lxUVULbln²VJUbW@@Lb@`nL@nVV@LVUbUVmkVllXbl@Xn°VK@_°`²IVVV@VUVJnInaWK@U@KLÆ@nmlXXWVUUw@klKVa@knyVkVanIJXUl@XbVUl@@aa@mXkbnK@UlK@UUUVaXaWmkUm¥nWmXaWakl@VmÞbKVL@aVI@mUwVm@KÅméULKVaUk@kUK@UWXI@VlKXU@VVnInVV@VLlK@UUkKU_@WWUwU@kln@@Imb@@mnUKÛ@mKUkWVXxmbVLXVVU²VV@xÅnmWmLU@kbmJ@b¯IUbJUUxVl@z@bU`W@Ub¯nUJUb@WLUKULkU@aWK@abmL@lmUk@@bULWJUI°@¯aWLk@mbUb¯b'], |
| 'encodeOffsets': [[ |
| 114942, |
| 34527 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4101', |
| 'properties': { |
| 'name': '郑州市', |
| 'cp': [ |
| 113.4668, |
| 34.6234 |
| ], |
| 'childNum': 8 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@nWVUKÅ@WnVnIV@kÆwV@nn@lxÞlnôJzXJl@nalUČVll@²UlkôVVUnmI°VnV°@°¦VJnIÆJÞan_VmU@ama@kU¥kaUklw@UIV¥kVUI@mmUÅmUlwVU@amUJWbUakVVé¯Im`k@wVWmLkU¯XkWmLmx@UUbm@@xJ@LbW@UUVWUkVK@kaIUamKUkkmmLUkJUVWXkWmnÅ@KL@@VXLmbmJUIUVU@ULWVkK@nWVXL@lVn@¤bkôKXKlL@¦²V@JL±@@VU@WV@X@`XXmb@blan@Jb@V'], |
| 'encodeOffsets': [[ |
| 115617, |
| 35584 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4105', |
| 'properties': { |
| 'name': '安阳市', |
| 'cp': [ |
| 114.5325, |
| 36.0022 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@°kVaV¥kVmUkWkWVkVKUwkkmKUU@awWWXWakKWkXmlaIVmX¥U@a@WnK@kVI¯@KğI@WU¯LkKak_kmmVU@VWXKnVmbXbVLmln@VVknlVUnVlklnXbmlmlXblnÈlWbn@@nK@VLbVV°VVzln@VxIbU@WLUa¯VUkWõ@¯kkmxk¼lXUlVbVLnlULmU@lLkVUlX@xW@¯mU@UmIUWL@aXakU¯anWk°@kkKmmUIWaambUkkKmV¯a@UblkmXk¤@@b@UbULWVnb@lUVVnmnVVUJ@bWXX@WJkL@blVU°UV@XlWnXUbW@UVkVVWbnLUJWLUK@Lnn@blVUnUblxVUVJXUa@UbLnUVV@mVIVVn@UbV@XbmbUV_lVXUWanJVI@WkI@WVIVU°WXXl@la@mX@lLXlkVbmXylIXJV@@kKla²UVaIVyÞb°LlVna@UÆKnLVbK@anwU'], |
| 'encodeOffsets': [[ |
| 117676, |
| 36917 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4102', |
| 'properties': { |
| 'name': '开封市', |
| 'cp': [ |
| 114.5764, |
| 34.6124 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lUVbXaInV@bUVxknVVÆnn@VJlUU¦VJ@kxVllb¦lV@nb@bVUnaôJÞIXbVJÆImxUVwU²l@XxVl°bVLXb`XklUnmVblL@lmx°LVK@UXIVaWlL@Uk°KkVaVUXmmI@UÅKmmXka±KL@W@kUÇxUU@@UXUlKkklW@aXa@UKUaVUUV_@yXk@@a@U±w@UUW@_mmw@wVwmUaÇbUa¯UUkmWkn±JÅxmIbUxmKmnJWwkUaK@a¯@bk@mVUIWLmwm@Ua@WJUb@LUl@UUmLUbWJ@VL@VmXWWzUJUê'], |
| 'encodeOffsets': [[ |
| 116641, |
| 35280 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4108', |
| 'properties': { |
| 'name': '焦作市', |
| 'cp': [ |
| 112.8406, |
| 35.1508 |
| ], |
| 'childNum': 8 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@V@VL@x@bXWV@XklUWX@J@nI@KlLKUVaV@JlL@KUk@KÞLl²_@nWlLUVV@nLWVUJVn@anV@awÞUVLVxb@lW@lbXnVn@@¼L°mKVn@bnl@nVK@blbLWU@VWLXV@nlKn@lVVbXw°nV_@¥Vl@XI@mlkkV¯VWnI@W@n¹n@aWKXUaWk@yk@kċUkVmbk@WIyóImÝkkwm@mU@xÅlU@mJXak@x¯V@¼¯VmUmmIkVWK@UXIl@UWVUU@mVUI¯b¯@lmKzWKUanJ@nlbÝ@@b'], |
| 'encodeOffsets': [[ |
| 114728, |
| 35888 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4110', |
| 'properties': { |
| 'name': '许昌市', |
| 'cp': [ |
| 113.6975, |
| 34.0466 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lIVnKlnVlnLVbJlb@ULVlUXVVX@a@KI@wn@aVV@nwnKlXW°lVnKUXx@ln_°JVIXyXnW@UK@UXIVanKVV@Vk@KVaXI@Vbn@nxKnaUlnVa@Xa@VçUUla@aUK@wmULk`kIWVkLmK@V@XUln@JXV@nmbUóImUa±@@ÑóVUUk@UlKVU@akWVUUlUUaUK@UUKWbUkÅJ@XWa@XbmJ@nUJ@bUKLÝaUnk@lXbWbXnmn¦lVXnWbUbVV@VkL@VmLaWl@nb@bk@UVWak@WVImJUbUlmz@lUbkL@lVx'], |
| 'encodeOffsets': [[ |
| 115797, |
| 35089 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4109', |
| 'properties': { |
| 'name': '濮阳市', |
| 'cp': [ |
| 115.1917, |
| 35.799 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lLXbWXXx@bVVnLllVxULUlXXlVlUnlU¦Ub¯lnK@VbVb@XbVLKVxVVnIlaba¥lU@wnalLnVVlVLXnlWVXn@@lVI@WnU@mÅW¥aW_k@WwXy@km@wUm¦lUxVLV@UwJ°x@VX@Vb@`VX@VX@llIVbnJlIbVlJ@mѯLóa@KUakX@UK@wU@lWUUݯImW¯aLUKU@k»k@mwa@UnKWI@UU@akVWKk@a±bóUWKXUmkKUmLbUx@lmLX@@bVW¦UnJkbWnXl'], |
| 'encodeOffsets': [[ |
| 117642, |
| 36501 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4111', |
| 'properties': { |
| 'name': '漯河市', |
| 'cp': [ |
| 113.8733, |
| 33.6951 |
| ], |
| 'childNum': 3 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@LUnVxnIWa@Xb@WÆIVlXaVL@VVLVbkVVUVlX@bUVkLVl@VVôU@Ò²@VbnôJVan@mWU@ImVk@WkI@wmak@wlW@w@VbnLVb°bVyXV_@aUKVVK@wUU@aK@kmbXVmJUX`knnK@aU@mwakb±@¯UUÝKUUU@WU@VkLUKU@mUmJUU@WVkL@UWJX@VVL@lVlUbLVKnêÆ'], |
| 'encodeOffsets': [[ |
| 116348, |
| 34431 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4106', |
| 'properties': { |
| 'name': '鹤壁市', |
| 'cp': [ |
| 114.3787, |
| 35.744 |
| ], |
| 'childNum': 3 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ón@xVVól@¯zJ@bkl@@kVWLUVmVXbVJnnlLl¯@Xlm°bVlWb@bKVXnJ@VV°nX@@wWVklUK@knVVKmkUKUaVkWkl»nwl°lö@lXV°UVbXKV@aJw@UmkUy¯UUUaK@UL@mm@XaÇkkmWank'], |
| 'encodeOffsets': [[ |
| 117158, |
| 36338 |
| ]] |
| } |
| } |
| ], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/util/mapData/geoJson/hu_bei_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [ |
| { |
| 'type': 'Feature', |
| 'id': '4228', |
| 'properties': { |
| 'name': '恩施土家族苗族自治州', |
| 'cp': [ |
| 109.5007, |
| 30.2563 |
| ], |
| 'childNum': 8 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VKbX@lbUVnL°@VlVnUl@VUX@aVmaXlaUUU@wmaVUn@Vnmmk@mU@knaaU¥VamX_@WUmW@_kVaVKnLl@VVal@k¥@kUW@kUKVUlUVÑW@kÇaU»ValmkUVUVak@aV¯_@WUkmVUlU@aalI@akkVWUaWXUWwWVbÆ@lalIVK@Um@UUW@al²a¯UağÇm@bkk@w@@WaULmxIUb¯@U`UXJmL¯aKXWUL@aknmK@aWUXaWm@I@UÅmVU@aUV@bVI@WkUbXkm@VakwUKULWKXmJ@XUK@mL@KUwVaUI@KU@mmnmXka@»V@@UUaw¯yVk@UUVmmkÛÈU@mWUnmxmlUbV¦UlbWVUL@UUIUmÇKVVbUVVxknLUxV`VX@kJVVUXWaUVVlUnmKUbkI@WULmK@L@LVlLnmUIWV@akn`VXUJIVlUVVbUX@¤mbnLmm@UXk@mm@Uka¥@kV@@KkU@aUKWbkLWVkIVk@UbVlmX@bU@@mmL@bn`@Ln@llVLVk@XVVU@`VXU¼k`VULka@VllVIn¤VU@@blÜbkx@bkLkKn@bn@@b@JUnV`UnVbVKlVXUlbn@°Vx@@bnVbUllVn@VVK@UnW@UVUlnkVÈÞxVbVVIxVaÆ@@aka@UVaU@@ak@Wl@nbVIÆ@Jk@L@VlXnlla@VJnw@UmwXU@aVK°ÒnllnLlbxnKVaV@l¦²nVl@llLx@XVVĶ@nax@U@alXUVaLÈþV°XxWXkK@mLnlUb@bxnLVlVVkb@UJ@xWXX'], |
| 'encodeOffsets': [[ |
| 112816, |
| 32052 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4203', |
| 'properties': { |
| 'name': '十堰市', |
| 'cp': [ |
| 110.5115, |
| 32.3877 |
| ], |
| 'childNum': 9 |
| }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@@a@w@kV@nbVK@nUla@laÅl@nlVakwWX@WkLaVmwV@anK@UlIXmWkk@@mmLkWlwk@U_mKXwWK@U¯K@UU@VUakmkIyUUVUmanU@mlwk@_mWXaUWU@Ç@U@aUaVwUKUIVkK@UWIXmaV@k@Vm@UnwlUamk@V@ULUamxUJkU@I`WkkK¯XWak@@W@IUVLWJkXkaÇVUK@kUmbmUUUKbkKWUkI@kKÝ@@aUm»nI@mU@UnWV_@aUmWbkLUl¯b@akkk@WkkJm_k@UV±@J@bnU@@WÝIUJVbXL@nlJkx@Wn@VkJmbLmU`VbUL@xVn@XV@mVVnnJVbUx@VnVUbVVx@nbUK@b@bJm²VUlbXzVJVJVbn@@Xmb@V@bVJÈ@Vnkn@°aVVV@XKnalLVmUnnVKVlnLWlXXKlk°XWkLUVVV@nU@ml¯nmbk@W`Å@mbLWm¯UxnêVèk@mbVnUK@kKmXk@@JUIlÛLllnbVnlJ@LULnlÆaVLnV@nkVJ@lkô@²bÆm°wLWV@VXKVXI@W°ÆVKb°UJVIVV¦XKVL@lInaVÝnUl@@bX@nmVL@lVLlVLVUnbVW@xXnbU°¤V@a@kWKUUn@VlnL@UV@Ü»@mX@V_akaÞ@VK¯@kkW'], |
| ['@@mUkUUm@nllVKXXVK'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| 113918, |
| 33739 |
| ]], |
| [[ |
| 113817, |
| 32811 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4205', |
| 'properties': { |
| 'name': '宜昌市', |
| 'cp': [ |
| 111.1707, |
| 30.7617 |
| ], |
| 'childNum': 9 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@°`U@blUbUVlVknUbV¼Èb@lXUÒkVUVVL@lVX@ll¦k@UbU@kmKULUbl@`nXV@XW`nUbV¦bmb@lV@nnlmnUm@UVnb@xVVVkbWnbVnVa@an@UaVUJXnWlXX@l¦@lKÆXbXV@VV@°¯°xXxXV@nV°UVWU_VWXkmaVnWVkn@lln@lb@UVLXWlnX@aXUmaVK@UXUU@WVIWXXVU@¥VK@UÞa²LlV@kV@UanKma@UVUnK@UVLXyVLknJ@UV@@UXKWUXaV@Vb@mVLnKWm@aUUm@@UkK@UlaLXKWaXI@alKlmUk@wVKXL@m@WWn@UVa@K@wna@aW_XWWkXbVW@k@U¯WWwka@UUaVIVkU@m±@U@@wVKka_@VV@XUVwU¥yUkm@V±ÈUKk»ÇLmmLk@ó£kmWwm@UIkWKXwWU@kLwkbmabkK@VLkmWIUKkUUÇIǫJXÅJULVÇLUV@UK@kI@WVI@UaWmXVVUL`±kÅLmKkkÅ@UaXXxWVXVbUXll@bkJb@bkVUVlnV@X'], |
| 'encodeOffsets': [[ |
| 112906, |
| 30961 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4206', |
| 'properties': { |
| 'name': '襄樊市', |
| 'cp': [ |
| 111.9397, |
| 31.9263 |
| ], |
| 'childNum': 7 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': [ |
| '@@@Xl@Xb°WlLXl_@JlVVInwVbVK@@UnlVbkmx@VUnl@U@nbWXJ@VlLUVJVLUxVb@b@VÈ@XVVWbnX@`lkx@nmVnbUVVVzlJnlVbUV@@V°L@VXLWxnLV`l@kxlXnK@nl@XlWn`Xnl@@UVa@VÈK£VLVanW°U@UVU@`VInmV@nV@Xa@aVW@UalkXKblIyÆXnlJXbl@@VV@nklU@`nVKLVKVb@VU@UÈKUVKIlUX@V`lIVbn@nblVVmV@@XXJUVV@knKVn@`@XVnKwlLVmUUU@U@aXL@WlU@UUW@UmU@KkLWaXkWmXUWm@U@nk@UmK@U@UaUVUUKV_@al@namWUI@KUK@aV@WUIb¥ULUJkImK@U@KV@U@a@UkU@K@wVaUwlU@mUULmKUkV@@anIWmUK@I¯mKkl@LUb±lUakLmk@WwUKÝVUIm`¯n@Uk@makJU_@Jma¯ImwUVkKbaUÅ@wWaU@VU@mXIVmmUkJkwm@mIlUKWzUK@VmLUV@VnbmLVbU@@lkU±KbÝV@UL@¦VWUWXUJ@XVWV@VULnbWVbW@kmWXUK@Vkam@kkm@UlmXUnbWlUXV`UX¯VmUU@Ul@Lll@nnJ@LnWmbm@b`', |
| '@@kUUm@nllVKXXVKmU' |
| ], |
| 'encodeOffsets': [ |
| [ |
| 113423, |
| 32597 |
| ], |
| [ |
| 113794, |
| 32800 |
| ] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4211', |
| 'properties': { |
| 'name': '黄冈市', |
| 'cp': [ |
| 115.2686, |
| 30.6628 |
| ], |
| 'childNum': 10 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VVUnWVXnVJ@U@V@VXV@@IVJUn@V@L@KlIVlVanLVbnVlIn@@a@Kl@@IJlI@aXU@KlKkVblJXUVlU@VbVkVKXn@VlxVa²I@VlVUxln@bJXklaVWnLmÅ@y@k@aI@W@aXIlVVaV@nnlKnLVW@IUa@a@KUVVlI@wXKVV@IUla@lUXwWnnalLlxXLll°@XwVKVaXIlnb@nln@Va@U@k°UmÆUVaXIJV¯ÇUmmkU@WaKmakVm@U@aVKkkmKkVmIkÇ°£@aUUVaVVnKlkXmk@lUVaX@@Um@UmlUXVUVU@wK²¥Ua@I@UVl@UV±UIUÇ°»VkUmVI@a@Umĉ¯V±bŹĖğaÇL¯lmkX@óĀ@mÝêb±WkLn@xXx@@b@V@LW@UblţX`kxWnXô¯¦ÆV@L@JVLxkK@V@bkz°llXz@JUlVla@XUVbVKXnW`XXV@laVV@VX@V¯xx@xULVbUJ@n@LU@VmmakbUK@bIWWUUVkUmkLm@VJkb@nUJ@`V@kXaUaVmmLkUmJ@Uk@U±lkzmJUb@bVUxVXU¤L@JX@VlL@JkLUVU@mnUl¦@V'], |
| 'encodeOffsets': [[ |
| 117181, |
| 32063 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4210', |
| 'properties': { |
| 'name': '荆州市', |
| 'cp': [ |
| 113.291, |
| 30.0092 |
| ], |
| 'childNum': 7 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ÈJVlVVLXJlnK@UlLanblaxlK@XVWxXLlJ@VnXxlnô¤l@nKnÈKl¼VL²ÇUn@VlzV¦UxWVU@@U`lbUL@xV@²@@nlVUUJVb@VlbXx°XVWX_VKUwVKVa@UVKUUVk@KnblaUU@wnWl@UX@lÆ@@aIVmUkxVJUbÜ@Uk@WWnk@VVm@I@m@Un@mXUlVlUnJ@knJVU°@@aÆLX@llL@¦nJV@XblLVa²U@UlW@VX@`@LV@@bXJlIXml_lJU°bKÆLnVVl@öVmXaVIĢllUlVnLVlX@@bannxVLbn@°ÆXmmkĉ¯w±Uċ@KÝÅƧŃÝçUw¯m¯k@WkV@¯UIUJW¼kbUwk@W`@¦Uônb@VÆlÈ@VU@£UWWnUÆUnmJkUÇ£VWUI@aUU@WkI@Ua@JW@k£kaWVUKmnkKbkkVWbVmUUmwU@kk@UakUUa@V@nlx@lUb±lUbnnWLUyk@UamUK@mlk@Wb@VXL@x@xWI@a¯¯V@bVn@LkKmL@`XmKmVU@@bkL@V±bk@UaaLKUVIWXamVVbUK@b@Lm@UWkxULWVUnm@UlUX'], |
| 'encodeOffsets': [[ |
| 113918, |
| 30764 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4208', |
| 'properties': { |
| 'name': '荆门市', |
| 'cp': [ |
| 112.6758, |
| 30.9979 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@n@lxlInVUnWJ@nUVV@Xb@xVÆbalLVUnx°JnbI@V`lInbl@@V°mn_VJÞUVLXx@nllKVb²kVa@KlknL°@JVLXnmJ@bU@VlnLVKV@nX@lUKVaXal@VKn@¥°L@UnwbnaV@KV@VUX@lVXI@KW@@IXWV@laVLKlaXUVVnkVWV@lwXblIXWVkVmaU£VaUmVIkU@y@WakKUamU@UUK@kmK@w@@mK@LV¯U@WwkmULamVVUU@IbUKUakmm@UakLmxU@UÒWlULţÿmwkIUm@akÈblW@UVUUk@JW@XkWWUkUKUIlw@aUWknWUUmnIWaUwVaÛaVUIwVlUnJ@bÅ@@kVWk@mX@xVVkbma@LUlVVUL@VUbULVxULW`UX@V@lUXWaXlWXX`@bmb@x@LUb@VmXX@@nWKUL@xVlknkL@bWJXbWLKkb@VlL@Vn@VV@bnXmLUK@nUaU@WbXVWL@VU@@V'], |
| 'encodeOffsets': [[ |
| 114548, |
| 31984 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4212', |
| 'properties': { |
| 'name': '咸宁市', |
| 'cp': [ |
| 114.2578, |
| 29.6631 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ÞÆLČ@V²°xĊnlWnům@aK@°nJwnVIUaÆJÅ@wwVXW@aV_l@²V°lĊwlaXLwlUkalVVaX@lVXI@aUXJ@U°UU¥VIVKVklanLVa@VÈIVV@nk@aVa@mV_@aK@klKUa@UnKWk@@lU@@UW@@nUWUwmaVIXlV@mLXblJ@kV@kk@KU@WkUWVÅwkLmW@UmL@lULKULak@maUUÝwUJIbKUU@aWK@kUWVkUwVw@mÝ@I@wkW@aww@LU¥kJ@nVJIkVVnkVUkyUIUl@xWUkaW@@°kzWxkLUWmzk@@bVVVb@@XlV@Vl@bVbUn`Wn@WbVVI@`LVbXLV`mnU@@lL@LUak@Lk@WbUJn¦@lVb@xVb@n'], |
| 'encodeOffsets': [[ |
| 116303, |
| 30567 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4213', |
| 'properties': { |
| 'name': '随州市', |
| 'cp': [ |
| 113.4338, |
| 31.8768 |
| ], |
| 'childNum': 2 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@n`lwkUmUVWX@lk@VanUĠ¼V@@mX@@nVVVXLmJVLnK@bV@@J@VUn@VaVUUUVWVLV@@Kk_@almaVkUU@WVVUVLXmmk@wUaUKUV@°@kmaUaÈmWmUVklaX@lVnxl@@UnaUk@VUVwVKn@VVn@VbVJUknUmmVmk_VwKUUmVak¥@UVKVIkW@UmIVWkIVkmmLkwmVU@LUU@VVXL@JmLUbmK@UUKmkKUUmVUaUnÇlk¯mJUnmLUaUJUaWL@UkJU@aklkU@¯@KWLUmUUWVkbLUKkbU@WX@JX@@LWJkUW@UVU@@LUmbamx@V¯K@¦mULk@WbUbLkVW@kVVxUb@x@LlV@V@b@VU@L@VLnlJVIVK¦aVJ@XU@bLV@LVJnXmbk@@bU`VLUVVb@V@VnL@Vml@@VXnWVXnWlXblK@LnV@VVX@VkV@XWK@bVV@VV'], |
| 'encodeOffsets': [[ |
| 115830, |
| 33154 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4209', |
| 'properties': { |
| 'name': '孝感市', |
| 'cp': [ |
| 113.9502, |
| 31.1188 |
| ], |
| 'childNum': 7 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VnXK@L@°lVlkb@VlI@VXKVbVIVbnKVmnI°lÈkVmVbnUVVlLnVL@VnLVanK@IWKUUV@V@KVnUlxnKlnUlJUXnJ@VlXUJUL@Vl¦UbnVVLUxl`UnnnmVVlnVKbmVX@a°Ý°LaXJV@VUnKVXVK@LnKlLUbVVX@VwVJVn@@UU¥V@@UUK@maUVUkkJ@L@K@UmVUI@JU@W@U@UV@UIWmXUVmUUÇ@UVmIlmnmakK@akaW@UwVUkKVnUlKVwkVU_WKUkVW@UXaWkUa@w@VU@XaW±@IkbKb¯L@WXkW@UakL@UV@UmVUmL@UXWVL@aUVUUUVU@yUUIUa@wUKWVU@kWk¯UkwVKLUxK@nVxUlUUWVUmw@wUUyXWlX¦WbUV@U@blbUVVbXXl@lVL@bk@lxkVVnVx¦`UnkL@V@L@@@xnL@lVL@VnVVblLXb@@zlVUJVnUbV¤bUnUlWXkJWakxU@UXml'], |
| 'encodeOffsets': [[ |
| 116033, |
| 32091 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4201', |
| 'properties': { |
| 'name': '武汉市', |
| 'cp': [ |
| 114.3896, |
| 30.6628 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@nbnmknJVUÈ@@U¥VknmV@VUlK@IkK@UW@IKV£UWVwU@aVanIly²kVl@@VnIlVnKUnVbblWU@@_VI@mlaUIn@lKVnUlVVXXJ@aVLlanbUnV@@K@mVIUaVK@ww°w@UW@UUUkbU@WWX_WmULaVU@WkbkUV@IWyk¯kly@a@UlLwUK@I@KÅUW@űUm@wl¥ka@@_Vw@ķa@akw@kKW£XVUVwVwUaU@VUUxWKkbĉx¯k±Uk@U`@bWXUx@xÆÅIVbUJmxIm¯@UmxnUVVbnJV@L@@kV@bVn@UVULlx°VXllV@XUVL@xVbJVV@zUVVVUVV@bUKWX@VnKUVVnU@@VlKVb@lXW@X°KaLla@JX²Wb@UV@@xVbXlWb@VUXVlXLV`UlUxkLmVUlLUVVxX@lb@blL'], |
| 'encodeOffsets': [[ |
| 117000, |
| 32097 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4202', |
| 'properties': { |
| 'name': '黄石市', |
| 'cp': [ |
| 115.0159, |
| 29.9213 |
| ], |
| 'childNum': 3 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VUVV@VbUxaWUblUVmnKlX@bXJVIlVUxVVVIUzlx¯@VbnL@xx@UVaXKb@XkWU_Vm²klWXVKl@nXV@@wmlK²XaÞén@ôÿ@lWn°kUKmmUÑUmm@wkImWU@UakL@bVLUVċ@bUK@alIXKWK@nXnKmkUVw@¯b@LlUL±Wn@KULUaW@kL@lL@bU`@nUb@bmlU@UÇJ@UUbmKkblUULUJV¦¯V@VWIV@bWJkUW@UbkUlbkV'], |
| 'encodeOffsets': [[ |
| 117282, |
| 30685 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '429021', |
| 'properties': { |
| 'name': '神农架林区', |
| 'cp': [ |
| 110.4565, |
| 31.5802 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@n`lIXll@ll@b°aVklKXaVn@bU`mX@VV@nmJn¼V@bÞ@lL@lJXVlLaVLVnVnalV@VLÈUlblWXIKVU@J_@annaXm@KmI@mkk@KVkWWw¯w¯°@UUU@WaÅWkL@¥@kWWXkWmIUVVbm@@bUbmUUbW@UVk@mVkU@U¯mKVUkaW@aULÆVbb@VÅ@Un@VLWl¯L'], |
| 'encodeOffsets': [[ |
| 112624, |
| 32266 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '429006', |
| 'properties': { |
| 'name': '天门市', |
| 'cp': [ |
| 113.0273, |
| 30.6409 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@K@UlKVm_¥UwUmlUkwl@@aUK@kkWWUaVUka@aV@VUXaW¥Xk@WWIklm@ÅxmIVÝUkxka@bWJaUL@W@l¯UULUbkVUa¯bm¤UnÇUkmUUxb@VkXÇal@bVnlJnxŤĀVKXkVÑV@nwlKVbn@nlVbVLaJ@VVUnUbVKlnXxV@°U@KnL'], |
| 'encodeOffsets': [[ |
| 116056, |
| 31636 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '429004', |
| 'properties': { |
| 'name': '仙桃市', |
| 'cp': [ |
| 113.3789, |
| 30.3003 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VK°VkX@@VKbXI@alblwÞVUnJÆwn@lkXJ@XWVzV@xnxVXUVVVkUw@mLVwKVU@Um@alU@@@KUmIUaVUmnwmwmb@aW@UkmKkUkVġkUJWbnUõ@UkmUÅKL¯aVkIk`WnkJ@xVLUVVbUbk@WlXbmVxnxUblbUV@@VUV@nVL'], |
| 'encodeOffsets': [[ |
| 115662, |
| 31259 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '429005', |
| 'properties': { |
| 'name': '潜江市', |
| 'cp': [ |
| 112.7637, |
| 30.3607 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@UbVxbXmJVnXVlmVX@bkxVJVLVlXXWlX@@IVlVUaVwVlnÈVVmn£°aVbUlaVUK@mVU@U@VUkaVamwUwnWaXkl@VaUaVUUK@wWI@aU@@K@_UW@kX@V±VUbkKWaU@mI@¥kKkW@ÅK@b¯@UVmI@lmIkVkUWVnm@@V@n@JUnU@mlXXl@@V'], |
| 'encodeOffsets': [[ |
| 115234, |
| 31118 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4207', |
| 'properties': { |
| 'name': '鄂州市', |
| 'cp': [ |
| 114.7302, |
| 30.4102 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@°¥WóXmlw_ŤWkVaX@@K@U@a@WwU@mWk@ULWkX±lUnV`XWl@aWLUb@Vw@wmKUa@°kwyVUJUUVwkUUJWI@akWmLUnkVaXVbUxUVWX¤lL@lx@bb@ĸUx@`@lbk¦@xn²VÆX@'], |
| 'encodeOffsets': [[ |
| 117541, |
| 31349 |
| ]] |
| } |
| } |
| ], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/util/mapData/geoJson/hu_nan_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [ |
| { |
| 'type': 'Feature', |
| 'id': '4312', |
| 'properties': { |
| 'name': '怀化市', |
| 'cp': [ |
| 109.9512, |
| 27.4438 |
| ], |
| 'childNum': 12 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': [ |
| '@@@n@b@XnJ@k°x@aVUnlUXnV@@VnJWUJVnIVV°UbVVVL@²LUVa°V@aV@nmUXblLXWVXVmVLVK@an_`@X@l°VlXXW`nX@Jmn@b@nV@Lm`bUbn@VUVl@nIVbUlV@LkJUnVV@xVblVUbU@zUKU@mx@xUnn@@WV@lbUb@nVWXXV@VIV@VUnJ@VUz@JWbXllI@VXVVL@Vn@Wlb@lXVlLaV@VJ@XX`kVwVl@bkbUlVXIlnLVamVwV@@nV@XaVJVbX@lwV@n@nV@VWnIVVUÆ@Xxa@IUUKmk@mVIXmWUVJnUVU@anaVwkU@UXa@W@m_@a¯@@K@UVbnK@blIlbXa@WW_n@VU@¯bmyUkUJÇÅ@WU@kWKÅwnm°KVkmankVWnXVWV@UwXkV@mUlLnaVaX@VUn@VnVK@xlnXWU@a@@klakVwmUaV@wmIÛ`m@mVUXmlIXVI@K@aU@UaV_UK@wkUmmUKWXmVkUL@mU_nK@aVU@Ukak»@U@ymU¯UUVKkam@nka@mwkLWb¯mka_VaVKUIUw@kKmU@WK@UnmaULkU@wUalWV¹U@@WUI@WU@_@W@U@mU@WbbUK@Um@@UmbUwWWkk@WUa@anUUwlWUwUU@wlJVUnnV@@mnI@mK@U@wa@wUm@_mVUUaVUk_kċUkVWL@mlU@kn¥W@UwUWV@VÝU@lXLWVUbVLXlVIlknmU@VUJk@@@kVmwmVkxU@@XmVUb@xnKVLl@VxUxkIU`@bWVXX@JWL@bkb¤@bmUUU¯Kkmb@VVUVVn@@Vb@`lnxmblUnbk@xUmV@bmWbUV@VJIl@nVUbK@nn@VbnJVIlJVkXJ@X@lmx@bnnWVXJWXU@UlU@mk@@llb°xIUbnJ@VWbXVmI@JVX@bk@bWL@JUXUK@U@U`n@@Xm@XVW@@nX@@`ImxU@@JUI@KLmK@UÅUUV@VW@¯kUU@UamVUUmJ@nxmLKkmJkwkKm_mKXU@aU@b@Wk@ma@zUJVUmbUlU@xnXlWlXXblK¤V@@nUVVLkVl@Xb@VVKnXKVx@znW@X@@lVK@X@JXbWbnn@JUamLVVXIVxnK@aWUX@x@VnI@WlI@anVIVxkl@lbXXxVVVJVInbV@@ln¦ml@XXVWbkJWb', |
| '@@XLVKVXVKUa@UUUmV@l' |
| ], |
| 'encodeOffsets': [ |
| [ |
| 112050, |
| 28384 |
| ], |
| [ |
| 112174, |
| 27394 |
| ] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4311', |
| 'properties': { |
| 'name': '永州市', |
| 'cp': [ |
| 111.709, |
| 25.752 |
| ], |
| 'childNum': 10 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lxUXVlXUVnlVĢJVbUXVJV@XUW¯VIUK@klW@Un@nl@V`XUVL@l@Vx@XXW`UnUbxUlVnUVlb@VnJUVVVInJlUVnwVklKnwLVJVV@nIV@nbVa@KVVVUUaKV_nVVJ@_VWnV@n¥lI@anl¥X_VKlwVlULUVVV@U@VXL@IUmn@VU@wmKXUWU@m²l@VIXWWkWUkWlkIVamUXamUnmWUU@@UnlK@XJl@kVUk@mWKXkl@@aVU@UVWUUVaIn`VUVLnw@U@K@U@w@UVmUU°K@UnV@bV@Xk@KVm@amkaU£VWUUmUUwm`UbULkaKXU@kVmU@aV_UWVIn@yXXK@klmVV_kWVUn@WUU@UmaU@wnwWanUmmXkam@UakLmK@bxUUUU@Km¥Va¯@kUaVUlmUU@mUUÇmUkUybbUaXUWWbÅLmL@VaL@WWXUKmmk@a@UUKXW¥kU@VUkxmVkUWbUJnVJ@nVJXzWxk@lVbUX@VVL@`mbUnUnVV¼k@Ulm@mwLb@lmLUK@UamWkK@£Ua@UkJkUmbVlkX@bWbUVnnUVl@bbVK@VX@lbV@nU¤x²Knblb@xVô@l@b@l@XWxnVl@VV@XLVlLUUXV`bXXmJU@@bm@UUkLW@UlUKWUUbwUmL@nklVVmVXXm@@bUKlÆnXkllVUVVL@nUbV@V@nnV@xUn¯U@JW@UX@xĉ@`m@@LV@b'], |
| 'encodeOffsets': [[ |
| 113671, |
| 26989 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4305', |
| 'properties': { |
| 'name': '邵阳市', |
| 'cp': [ |
| 110.9619, |
| 26.8121 |
| ], |
| 'childNum': 10 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@XIlJIVVK@n@VVVKnLVwVmnLVK@U@wJ@wVIÆ°X@ÜÈUÈxll@kn@VwVaXJWXn@@WVL@UUKVKV_U@@aVKx@UaV@lk@XylbUaV_Vnal@WU@aI@aV@@aVUl@XmUXWaXml@@kk@ma@V_UnUVUUWJUa@kkaWLUmk@@LUVWUkJWkK@¼UnWJIkV@b@JUIm@UlVm@Uw@a@kWXWKUknW@WUU@kmxUkVmIUJUUVmI@UkaUVUmVkwVaVmX_WW@Uw@@kUKWVU_k@mm@@VkX@lVLUJX°WVU@UIVWUaIUġmkVUkWUVWkwWXk`mI@¥kUVUUn±@mXkWknVUVmmU@@XVUk`@Xk@¥¯»mbĉó@mkU@kUKmX@UnmL@lULkKUWUU@bUaUn@Vb@l¦Ub@l@UKmnKUnlUVVbUVn@`Vn@xb@x@VL@nmJ@nU@mmUVkI@xVVVxkXVxmV@bbXVl@XlXVxna@Vn@@VVLaXaV@n@@V@X`V@@XVJ@XV@UºkXVb@xlVVKnbm@VXLV@nlL@VxJVULUb`lb°nXalKnx@lbmn@lbULVV°nV@z@Vl¼lb@VUV@bmLV`@nKlVnUXWVLnnlV@xVLU`VbV@'], |
| 'encodeOffsets': [[ |
| 113535, |
| 28322 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4310', |
| 'properties': { |
| 'name': '郴州市', |
| 'cp': [ |
| 113.2361, |
| 25.8673 |
| ], |
| 'childNum': 10 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@²zVaVlnVl@nVkJl_XJlIVmnL@mV@VXn@lV@XzV@lyV¯²U@UlJ@XVKnVVIXl@UVLV`@n@JI@mlIKVLnUlVUVVLXaKVLl@nb@WXV°KUnVVL@xVJL@b@LUVVVUVXbmbVbn@@lUbm@x@XVVV@@@bkImx@Vm@Xbb@l°XU¤aLmnL@bl@@VUX@VxnVanLnW¥XKVwnUWXmVIUWÆLVxLw@wVmlU@¥XWUkwlÇn_UwWV@VU°wnUy@aVkVlnL@lVnw@VlJ@bXx@bVKnb@U@WVUl@@Vnbl@XLlK@aVLVKnxÞn@aLlmUaVUm@ÅknUmaUKmVk@mkk@UlWUkVm@w@kUU@WU¯¥@wÇ@aVIlUV@kUWU@UUm»@k@mKVkUKUwaUaUa@kkUWJkImaU@UK@maUzk`@zy@XmJkL@UUJmUkV@z@kkVmK@¦UbWL@a@UbmKmwUKXkVUUkmVkw@UUKmL@WUIWaJW_k@@WmI@mk@WkWULUUVKUUVm@Ub@nUÇ@U@wV@Ua@aL@akl@kUJwó@@L@V@`@J@xnnmV@bkJmUó@nJWUUmU@UV@LkWlnnmVXbmxxV@nbVV@XVm@UVlXU`Ukn@lWLWzm@UJVXU`@bVUn@lWVLlbVKVan_VxnVVVUXV¤bnl@bUn@LWlU@@amU@V¯LVVUn@V@x@V@L@VmxUKUVm_JUbVV'], |
| 'encodeOffsets': [[ |
| 114930, |
| 26747 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4307', |
| 'properties': { |
| 'name': '常德市', |
| 'cp': [ |
| 111.4014, |
| 29.2676 |
| ], |
| 'childNum': 8 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lUmkUwUyV@VW@¯VaVmUU@KVUVUVLnaWnkUÓV_@mVU@Ýw@ka@kVmUmK@IkaUamKkXWaUW@WUk@@KVU@aU@L@J@XÇVUKVak_mWkLWakVUbmLUUmlUVKUU@kUWW@UImJ@xkLkKm@@X@óÝ@UUk@UKVULKXkWWbkaIUWU@mUk@WLaUJġ@@XÈÆVIlVnz°aV@Um@X`@XWbkakJ@amLaU@V@L°@@bn`@@XWb@VVlUxmb@bUVmVUIXVWnJU@nnlVLV@JbWzk`m@UVK²VxkLVl@Vn@V°xVKVkVVlUblx@bUÆ@@nVnUllkx@VW@@VkLWxUL@bÝ@kKkVõV@bkXVVUV@VkUkVLkVa@@¯xUxmX@JVb°WXkK@Vm@kVbbn¤xUXkJblxnXÆK²l_@Wnan@UL@bJnIlV@lU@@¯ô@lWȂIVKVmU@aXaV@lwVXn@@K@UVKUUnUbn@lWXlJnULKV@l@²a@UlK@aV@naVXWV_nKlL@KUm@a°U°@VXL@a@wWmXal@k@VLnV@@bl@VnX@mwVa²aVU@mk@'], |
| 'encodeOffsets': [[ |
| 114976, |
| 30201 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4331', |
| 'properties': { |
| 'name': '湘西土家族苗族自治州', |
| 'cp': [ |
| 109.7864, |
| 28.6743 |
| ], |
| 'childNum': 8 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@KL@wnK±nnm@WUkÜÈn@n»@mVamkmUl@VnmmU@wUan¯VKLnVWlInyWUI@WWk@KXUn@mnUmU@WmkV@kXaaVaUmIk@kaX@Um@UKWU@UkJWkXa@IVy@UmIUVU@UJU@WXWmU@VakaU@@Xm@Vm@wnwV@VLyV@VakUUa@wUUVmlI@KUVkUamJk@VU@UmVaan_@KmU@@anm@ImWX_WWUk¯@k@W_m`@bULUKUnUWWXkKWaVmnU@@b¯UUbV±K@UKUUVa¯UUmJUVIXmI@UU@WmVmkUV@b¯w@lmI@W@a@m¯LXbmJVLklWL@V@XXmbVVU@@VU²Ul@VlX@b`XxzUmkUVÒl@bXLWxXVl@VbkLma@nmVmULVbmVUb@lnzmbUÒVl@°nLVlJkn@bmJk_VmmkblxÈx@LUbxVb@Vn@JmLVU@nV@¦VbnJ@lVVbkxbm@UxVLV@n`UnVVVkl°zxVb@VU@@ÆlXnWm¦nbVK@XVVUVVl@XKUV@nVL@WnIWXLVKVLlxUbVKXVWbn@@UnKVLVbJU@aVU°b'], |
| 'encodeOffsets': [[ |
| 112354, |
| 30325 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4304', |
| 'properties': { |
| 'name': '衡阳市', |
| 'cp': [ |
| 112.4121, |
| 26.7902 |
| ], |
| 'childNum': 9 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lV@XV@mXVlXLWX@l@bVxn@UVkn@VJ@I@alUJXIVm@»LXllIXVVU@Kl@VnXKlb@lVbXIVVUmVVU`@nbl@@lXLVVVKVbnXWJ@VXbWxXbUlVK¦nLVVUVVbbK@ULnK@Un@VxlUV`UnnL@VVL@JV@VUnxnKVbV@@VIVUnJUVUl@nWXllIUaKVbÞLV¼²`V@VIUwlaVmXa@IWanK@U@mkVVUVaX@lnaVLÈ@¥@kkJUWJUaXkaUmwVXJ@_lWUU@¥n_KkamUK@amKnKbV£¯W@kaWan@@UnwlJ@a@@UUU@Wwn@Va@km@UanaWaUVUUVU@K@aKUI@wKUUVm¯LWUX@mak@UKLWbUKVUkUmVUKLkJ@nJ@I@mU_UK@VWkUJmUUL@WkI@V±VU°kzU@Wy@kUm@UWU@@nmKUnkJWIk`IUlmk@mUUkUb±yUX@VUV@bk@WlXL@nVlUlk@WI@kLm@VV@XVmnnVWbnVUblJXkVlXXlWXUJk@±@nXVWVnL@xUVm@Vn@JWK@UV@UUVUVKUkkxULW`k¦m@bkJm¦U@mUX@`UImUU`LVbUVUU@LUbmaU@mJU@UUIKmxkLUl'], |
| 'encodeOffsets': [[ |
| 114222, |
| 27484 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4306', |
| 'properties': { |
| 'name': '岳阳市', |
| 'cp': [ |
| 113.2361, |
| 29.1357 |
| ], |
| 'childNum': 7 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@wUklmUUmU@@UVm@wUaV_mmUKmwkIkJmUUnm@@UUbUKUmÛamm¯xVLkbÇÆUVUzkVUlUUKWLX¦W@VUUUaKUbmLKm@akU@amVaUUVIVWkk@wk@@xmLlmÅwmbVlXlÝIWVkK@kkVL@VWKU@Ublnam@b@bnW`@XUJk@UUWKk@UKnn@xmLUVm@kbVbVnV@Vb@KnVLWXÆVĢ¦VblnUJWz@ÆVóUVbkVaÅx@¦lVUbVVknWKk@wKVUÅl@zkb@`m_mJ@xXmbVb@llV@n@llbXLUXalUlalVnwnLVKlVbX@@IV@blJ@bVL@VVVUXȤVnkVÑXmlbnVKkÑÅ@UmaVç@±XUlIxlV@VaX¯lUVVUVJnV@°°n°Vxĸł°¦b²¦lJ@U@aUK@kUm@_m±VIXal@Kl@bV@KK@km@UmUUaK@_UJaXU@Xm_VmUk@WUk@kU@a@m@UaUUU@al@nyXXWWwkly@¯n@@bnV@k@mVIVlUUmlUJUwIbXVaUal@Kb@VKVkXVl@VkUU@ylUVVaVL'], |
| 'encodeOffsets': [[ |
| 116888, |
| 29526 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4309', |
| 'properties': { |
| 'name': '益阳市', |
| 'cp': [ |
| 111.731, |
| 28.3832 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ÆxXL@lV@ĢVIbXKl@nVV@XVJlbXalXWLVKUVLl@VV@ôÞ@@Wn@lLlK@wnIVJX@VX@lVVULVnkVVnKValUXblKnXl`UbVLÈU@W@IKV@@bUV@L@lXV@VXXblWnLVblb@JnLVUn@llb@x@ÞUV@nU`VÔmlXmbUKUVUV@LVVUnUb@°UX@UVzVxnlVkVnlVnaW@wnIn`@_la@ykÆVULxl@XLlmUUVakU@¥ÆwblUUaôVU@ÅXyVImkUaġ¥ÅUWXKmU@La@UmUUUalan@VUnK@wmmL@VlXLVVl@VI@WX_m@a¯mKUkwW¥UK@_UWWLUVkUWL@WUIkVU@JwkLUUmJVI@WkXm@VmkKUIU@mmm_@VUV@kJċwUU@KUWkkW@IWW@km@klwkWVkkUV¯m@kWLU`mIkmkXm@@`@L@xUKWkU@VL@JUU@mbUKVa¯WVnL@`lXUVkU@xW@UbUWVU@UJ@lnU@mnÈmVa@bULwUb@@VkxmUUUVK@IUmk@akm@wmIkK@bVWXkm@wULUmm@UVW@UbmbkKVnU@WlxVU@UXmWUXmlnbUl¯Lmn'], |
| 'encodeOffsets': [[ |
| 113378, |
| 28981 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4301', |
| 'properties': { |
| 'name': '长沙市', |
| 'cp': [ |
| 113.0823, |
| 28.2568 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lVUllXkx@lln@XX@JlXXlV@LVVČxlI@VU@Un`nnV@VJlLUnn@lW@XUJnIVVlKx@IVlUVJ@XXKlVVUXKVX@`VLX¦lxVnL°an@bkmVaV@XL@UKlU@llLXUÞJWkUknaÆxnknK@w@l@xllUXUJVVUbn@blV@bnLnKVaLVbVVUX@W¥XKVLVVklUVyUVÈÅlaUK°wnnÜbnVVLaVV@n@VmnVlIlJna@Valkn@na@amwm@UXwK@aUUVUUaVawWK@kU@UaW@kKUU@kW¯XWan@kmmÅ@@I@U@KmLkaVUKkLWVUk@UVmU@am@kkk¥UVUKmaUb@UbI@aKkkWm@W¯K¯b@VmaULVxUXlVk@UxVJVbUb@xUL@ULWWLĕmxVVL@VbKUwaŲWwX@@WUWLU@VbkV@aU@@VUnmJ@VUn@VLUK@UmUIk@UÇmU@@UW@J@LbUmVI@aUmW@@bkXUx@lmLUbm@UbkJ@V@XmlUbkKm@ma@kUaVU@aUK@mImJUIkVUVUakbWwka@UWKkLUamKUXm`Å_UULmaU@@lUV@X'], |
| 'encodeOffsets': [[ |
| 114582, |
| 28694 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4302', |
| 'properties': { |
| 'name': '株洲市', |
| 'cp': [ |
| 113.5327, |
| 27.0319 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@XUnwĖKXXVK@VK@wVaUaUIVwl@kUVWUwVKnb@U°a°LX@XnllL@bJVa@VanbVLUV@al@@UV¯ÅÇ@Ummkw@¯yVwnUVVVUkmWVnKVUa@WXkVKn@lUVUVVVXIlV°VnI@VlKnV@mwVm@LXKWkU¥wWw@k@mX@KX¯V@VUVa@VnKWkV@VUkm@aWa@wkUWwkmV£VÿXUVL@mVIXaò@nW@aU@@am@aUUUmXmWUk@nUW@_maVmwUkamaUL@awW@akI@UxUm@kmKUklU@bzVm¯xUVU@XVxm`kÈlxXVW@¦kVUn@xxKUwÅKVXUJWnXmVUxWL¦XmmKbmUUwW@UV@k@VLnlbLm`@¦VVkX@`WIUxVnlbWVbXIVlI@l¦Ç@UKmbkW@UbUVUl@n@VmLXb@JWbUnkbVxUJUxWXXlWL@V@V@XXJWxzUVVVVKnXW`@bkIUlnLVJUbUIWVXlWV@XklVbnn@xl'], |
| 'encodeOffsets': [[ |
| 115774, |
| 28587 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4308', |
| 'properties': { |
| 'name': '张家界市', |
| 'cp': [ |
| 110.5115, |
| 29.328 |
| ], |
| 'childNum': 3 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@InWVw°w@@blUKlUlVU@VUUUlW@aöUlUlLÞ@@aVKXwlK@UX@@UlwkVkUm@m@ÅV@akwVaUkUUlUL¯w@UUm@UkKlw±UULVn@l_XyWwÅ@VUUmJUXU@@mmU@kxW@UaUIWbU@@mU@UxnUbmKkWJkUVal@aUkUxlW_@WUIU@bkKWUJVnUbbWblU@nl@XnVmV@nmWV@LXl@XJXVmzkJUXmKULm°Vb@xnVmnUk@VnnlUb@nm¼m@ÛÇVl@Xmnm²mL@xK@LUl@nULÆx@V@VXVWbXXl@nLlm@bVKXWL°bnU@VaVU@mVwJnwVK°zn@VVba@Ċ¼'], |
| 'encodeOffsets': [[ |
| 113288, |
| 30471 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4313', |
| 'properties': { |
| 'name': '娄底市', |
| 'cp': [ |
| 111.6431, |
| 27.7185 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lLnJ@xln@bnlV@JLVUVnVlw@U@VaxVK@abnUmÇnV@km@I@VUVVXVaX@@wlVVUkW@_mKXU°UbVLnaV@V@IUKV@XlVL@w@K@_n@lWlnnJV_XK@l°nU@WVU@kV@nbVKVl@nLlLXU@lmkw@nW@UKVa¯IVn@@aVUUKl@nXVKVn²aXblKnLlmVI@KUU@akLUaVaUXm@a@wVUVKnLnWlXln@@U@anUVm@UInm@IUK@UmKVmU_kVUwm@@VmLK@VLaUaVUUUmK¥ULkVWaXwWa@UXImWUaULUUWKk@WnXbWVWnk@UV@bU@@bJ@bV@XkmbUU`VbkaWz@klU@b@VwUL@bV@U`ULVL@VUK@Xm@XWWIUbUxm@@lkkÇwVÛÇW@¯ÅUJ@xIx@@VULmKUnUxmKULUUm@@ULUJkIWJ@b@LJUWkJWnUV@nnÜ_nJxU@VbnUxlkb@l@'], |
| 'encodeOffsets': [[ |
| 113682, |
| 28699 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '4303', |
| 'properties': { |
| 'name': '湘潭市', |
| 'cp': [ |
| 112.5439, |
| 27.7075 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Æ`n_VWnLVblKXL@VlbXxlaVbUVlUVJnInJ@VL@bUVVb@lnbn@lLVank@W@UlIVan@VanK@kVwlW@aX@Vn@bUJVna@KIX@@VV@nVÈl@VJn@VVLK@UVm@UnIVm@UV@@blUUaV@XKV@XW@XxƱbVxLUa@UKWk@wmmUalk@WXUWkXUVJVaUImKVklJ@aX_mWULUUVUyXwWI@W@U@UXKWkXWVwU@±_U»ÝKUaLVbkJkWmXk@UVVmIUVJ@UU@UamLmwUVU@mnJ@VUnmV@b@Vm@kkWmXmKULUV@x@bWnVUbVblK@bVV@LUJknmKkLWa±bUmULmWk@VLUV@bm@U°JUbVLX@@mlxkn@WVKkmK@k'], |
| 'encodeOffsets': [[ |
| 114683, |
| 28576 |
| ]] |
| } |
| } |
| ], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/util/mapData/geoJson/jiang_su_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [ |
| { |
| 'type': 'Feature', |
| 'id': '3209', |
| 'properties': { |
| 'name': '盐城市', |
| 'cp': [ |
| 120.2234, |
| 33.5577 |
| ], |
| 'childNum': 8 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@n@°ĀÞ°@¦ULWKkx@bkLWb@lUlVXXJVbnUKmxXV@bm@@XLÞܦXlVnmzVJ@n@²ÞôkÆÞaȰĉwnljÜóéVÛnĊīČljĉ@ō@KÞUlU@kklÇÈÑÑlġXɛ@UġaU@U_W@n@kaUL@VW@kKmkUV@bkbWW@bkzma@JWI@KUKUL@U¦`@XUJU@KmXw¯KXkmy@aUIWJXXmV@K¯UU@@bVL@¤VLXbV@@JVXVK@JVn@bkKmakVVXUVVVlI@`U@nzVVb@¤n@@UlKXLVVI@V@nV@V@ÈUx@óVōkÅWó@mU@bk@Ýwk@WbXxm@@J@zV@kVbVnLWVUXWUXUWLU@Wl°z@VkxU@UVWIxWJkbĬnW@@bUl'], |
| 'encodeOffsets': [[ |
| 122344, |
| 34504 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3203', |
| 'properties': { |
| 'name': '徐州市', |
| 'cp': [ |
| 117.5208, |
| 34.3268 |
| ], |
| 'childNum': 7 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@XKVX@WnIVx@K°Lnll@@I°KnVaU°x²mlx@VanU@ak@akmV@@w@Ua@aUwVwUw@w@UK@£kaĉlóIÇVk±@@kUKmVkIkxW@Ua¯UUm@UVI@WVIJV@@Um@UanaU@mI@J@XV@XaVlkXVaUUWLUyVIXmWak@XkJókJUL@KWkk@ULU@WalUIkJmImkVbV@lV°kXUKWKULUmb@VUlVnb@VV@IVKUUmU@ak@@bmV@xklUU@UKmV@nJVbkXKUamLUJ¯UUVmIbVVLl`@LLU`m@kXUVU@VlxUK@xkIWbUKx@VkVVnb¯@@U@xkmbkLÇKb@@XnJ@LmVkl@@XlUVkxakVVb@bVnUbU@@xVUVb@nIĊ`XVVôJ_K@xlU²KlkU@VaVVÈm@kVUVmnamUUaVXIVJ@ç@¥nkVLn@@XVK@VUX@JVUV@UnVJVLUJVLUVlnIbKnU@m°VanI@anVKVLanlKblKÞk@¦@¤@VKnLVKLKVzlWLX@VmV@VbnU°@UalkWXLVUKWkUUW@£Wa'], |
| 'encodeOffsets': [[ |
| 121005, |
| 35213 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3206', |
| 'properties': { |
| 'name': '南通市', |
| 'cp': [ |
| 121.1023, |
| 32.1625 |
| ], |
| 'childNum': 7 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VJ@bnzWl°LxnW@LVVI@W_V¥@VKVL@LXJI@nbly@aXXla@aVUnllLX@@UVKlb@@mXV`V@bĢlkČÇÆȘ¯wnĕVĉVÿUƒUĠŦğlXÑVǵ@±ōLʵĖ¯lÇbÝÞ¯xk@Çkķén¯@ğġƴǫ@kVVlUbL@xULÇóLUl¤@nkVV°VLkxVb@laUXUKWĖklVX@¤UUkb'], |
| 'encodeOffsets': [[ |
| 123087, |
| 33385 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3208', |
| 'properties': { |
| 'name': '淮安市', |
| 'cp': [ |
| 118.927, |
| 33.4039 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@nźUôÒɴèl¦nĖVkbmX@xVlVL@xUb@bUJVnUxlKVLÈxmzXV@lW@XVb@bÈVxnbVIXa°LaÆVVaXUlK@aXIÆVlXKVUlIXalK@alwXLVK@¥Ý¯¯ÿ@mVk@aX@mīlaXIwXJVUV@lw@U¯ybUaUġUÅaUKVknaġm@kUm@wÆIV±nLÆwÇnUUk@ƅÝU¯JÝI¯¦Ul@b@@VVL@l@LLÅmL@b@UaVaUWmLUKV¹KLWKX¥WI@mXk@UmaUVUU@VmL@WbkIUWUmVóIkbmm@UbVLUxmJkU@bkJWbnXU`WzKUÞÈlVbLmx@kè@Æ'], |
| 'encodeOffsets': [[ |
| 121062, |
| 33975 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3205', |
| 'properties': { |
| 'name': '苏州市', |
| 'cp': [ |
| 120.6519, |
| 31.3989 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ôèĊVnX°¤²lxƒÈÜ@²x@J@b@X`nIUÆUUV@bl@VVnL@L@xJ@X@blJXnW@@`XbWkV@UbVxXUxkV@LóxVbUVW²VJĸklUǬ@ĢƳĠ°@mƒī°»ÈÇ¥ULUU±a@bU@¯U@KnImUVWUkmXUVU@lIVaUUVWKUbUkWKU¥n£WakJUkULK¯LKkVIn@VaUVUUUkVk@U@amUkJ@UUlwX¥W@@UkVmk@JUakL@kk¯ÝmJUn@nmVXlmbVVkn@UJ@±WUxV¯a¯KōbżÇxUxUUlWL'], |
| 'encodeOffsets': [[ |
| 122794, |
| 31917 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3213', |
| 'properties': { |
| 'name': '宿迁市', |
| 'cp': [ |
| 118.5535, |
| 33.7775 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@XbWnUJVzXKVVUbWklUWbU@@W@IJ@nVmbVbn@@V@UIUJ@XUJ@VVn°VVbX@lwlJnUVL@l²@lÈUôJĊklb@¤VL@@xVxUxVx@bVb@@xU@lnmnXmXLVmV@X@lxVnVJôLLXax@b@@KVL@bn@@m@@alLUUVaU¥nIV±I@mXI@aWWXU@LlUXWW_XWmaUwÇ@aaWUX@@kWUynÇwUKkLVwUmVI@aVa@wUKUk@wWnlaUmĕk¥ɳçóÑŹVmmzkVmm@a@Iók@@LWU@`WbXLWlkImJVn@`nXVbXmL@Vn@l@nUVl°Xx°U@LVĠ@z°@¦UV@Xn@VJmV'], |
| 'encodeOffsets': [[ |
| 121005, |
| 34560 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3207', |
| 'properties': { |
| 'name': '连云港市', |
| 'cp': [ |
| 119.1248, |
| 34.552 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@lzXxmÆV@@¦@l`XnlKXXmKnLlab@xmbm@kL@V@Vl@@VUXJXmb@@°Æ@èÈzlW°XĢJlÈ`lInbWV_@m@UUķnôw°ÆmnaVVÛVmĸ»Ģw±Ý@@mUInyUmWkÛ¥ÝK@Wn@@aWUnwVLmUaWIUWVk@kkJUVWLUkÅWJ@bkLWVUbÅUb¯KWbUJWXX`WXkV@KWVXX@bWJ@nJU²mJV¦UbVVkK@b@@nm@@aUK@L@@awWbKóKUIUmkwW@U@UnWKnmWn@bl@bmVUb@kw±n¯wVUb'], |
| 'encodeOffsets': [[ |
| 121253, |
| 35264 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3210', |
| 'properties': { |
| 'name': '扬州市', |
| 'cp': [ |
| 119.4653, |
| 32.8162 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VUXblVVVb@xV@kzV@lwVLUbVV@VU@VbUblb@nkĶ°IÞV@ƆVlmVÈÅxmKU²ÅJ@xVn@lĢnmbUlVLÆbĢVVbVaXk@VXKVVWXVWXUmKUaWaU@¥@£XWUUV@@ynam_VWkUVUna@ÆV@mnkWmXkWUW@k@@akkllWUI@UnKl¥I@VVma@a@I@U@a@anK@UmK@ÅVUnJlkI@aVwka@mVIUW@UWL@WÅbmIULkaUWUxkLUKWlXL@VImÅVUmĉLUól¯I±l@ÒUbVbUVVXUJUnVV@lnbl@'], |
| 'encodeOffsets': [[ |
| 121928, |
| 33244 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3201', |
| 'properties': { |
| 'name': '南京市', |
| 'cp': [ |
| 118.8062, |
| 31.9208 |
| ], |
| 'childNum': 3 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@k@ma@kUUVmVIUWVUUaVa@Ѳk°Jôk@Wmk¯KmX¯aUakKWU@XULXaV@@mUaVUUl@VmkaUXm@WUUna°IlmVmIUW@Uk@@aV@VVX@VI°»nmU@VKVan@m»UaU@U_@WlIUaaVaUala@¯n@kaUkUUWKU@mwkUUmmL@K@LmUUVKVÅImUJVkVVLèVLVU@WLV@nVÜULVUL@bW@XbWbkJUUVUxVXmVk@WUUkVmIV@nbnVWbJUkUULa@Jma@XkK@VVL@L@JLUVU@V¼nXlbm@kbUKmn@lVb@VXXVUV@b@LVbÆxXbl@@lV@UVV@XVK²VlI`UbVbUlVVn@WXn@@VUV@@KmbVLXÒLkKV@nX@VVUV@bnVllbmnbIWVXU@`lLlknVnmlLlbUmVInK°nUU@l@VU@Vn@@alI`VIXaVaVa'], |
| 'encodeOffsets': [[ |
| 121928, |
| 33244 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3212', |
| 'properties': { |
| 'name': '泰州市', |
| 'cp': [ |
| 120.0586, |
| 32.5525 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lUU@@y@In@WwXal@Þxl@@anVô@ÆXlŎôU@Vw@ÇUU@@m@UJUUWKkL@Vm@@£aUUmyV@@_kJUUVUUWlUnblL@aUmI@ULUW@IU@WaUK@£UK@aV@°V@LnUWWXIlaVV@£UWlkXĕVLVWb@kUalwUKU¯lU@mk£VôKÈVK@wKVaUkķlUI±ğ¥ÝUŹ¯ôm¦ĸ@XXK@VVXUJ@nlbUx@blJkmIUV@ÆnL@VmL@b@b@V@J@bnbU@UJk¦mL@VVJkXkll@b@@lXXVWlXnml@nÅU@mbUVlVUXn`mb@zU@VVWX@¤¦V@Xb'], |
| 'encodeOffsets': [[ |
| 122592, |
| 34015 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3202', |
| 'properties': { |
| 'name': '无锡市', |
| 'cp': [ |
| 120.3442, |
| 31.5527 |
| ], |
| 'childNum': 3 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@nLÒlxUVkLam@kVWUULUxVVVbUV@bVLUnnźÞVĠ¦XVUUaôw@KlUVwWUwVa@lUXWa@_X@WmkI@a@WI@w@KmKUUk@@aVUVVÅmJ_@W@a@I±wÛ@ƑÇkw±¯£mWĉUóçK¯VkUWK@XkV¯UWabmUaUUblln@b@xbXWX`@VxUblL@bn@Vb@`m@XbWnn@l¤n@xnVlUVLÆWkV@VbÞJ_nl@nKVU@aUU@mVk°WVLUV¯bVXbXlVn@VmL@xV@bl@nW@X@VVJ@²VJVU'], |
| 'encodeOffsets': [[ |
| 123064, |
| 32513 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3204', |
| 'properties': { |
| 'name': '常州市', |
| 'cp': [ |
| 119.4543, |
| 31.5582 |
| ], |
| 'childNum': 3 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@LnxUbVVL@xnnWnn@VVXn@yImx°La¥n@VkKVwW@nXVJ@b@UVn@UnUV@Lb@`VLklVÞnÆ@VaXLlÈJmmVUK@aVUUaUUVwVKXVlUn@blKVUkwÑmKUVUI@±UI@U@WmX@k@aU@wnK@UUmWkaWU°aVUUK¯XUl@nVV@bUVmLk@m`ÝIUaU@lÅXUKkVmU@wmk£m@XmWan@@_Uam@@akKVaUw@W_XWa@w@akmm@mL@UJmnUK@@XnJWLkKUb@VxkWLaWVUImVULUK@L@lkLVVVllbm@@°kbVbUbbVbkJ@XV`V@Vbn¼'], |
| 'encodeOffsets': [[ |
| 122097, |
| 32389 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3211', |
| 'properties': { |
| 'name': '镇江市', |
| 'cp': [ |
| 119.4763, |
| 31.9702 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VĊKnVÆUnJ@UWKXkVLlKVwXVlbVKnJÆaķn¥°óÇIkWKUbÅ@mUÝlkUK@_a@KVUVm@mVU@@aUIW@mXUxLUlm@¦bK¯nwJzm@UW@UmmXmm@wKUUVamwKm@UbUL@Vmn¯¼JUW@UUU@@bl@@VVXJnnUk¯JmbVVXn@VWlbUnk@VVUVb@nU@WbKWV@XVlLVb°bnW°Lnl@X'], |
| 'encodeOffsets': [[ |
| 122097, |
| 32997 |
| ]] |
| } |
| } |
| ], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/util/mapData/geoJson/jiang_xi_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [ |
| { |
| 'type': 'Feature', |
| 'id': '3607', |
| 'properties': { |
| 'name': '赣州市', |
| 'cp': [ |
| 115.2795, |
| 25.8124 |
| ], |
| 'childNum': 18 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@`l@Èbln@KVLl@V@bÈlnKXkVlVL@lJnb¦VKVVnXW@w°@VUmlnUV`UbVUV@xnKVI°KXKVkVL@al@XaLVlULWVVVL@bx@VXVmb@x@VVV@nn¤lb°b°KXXWbX`lbXxz@x`VIVUnKLxWXLVKVbVLVU@wnW°b@nalXmXVJn@U²mKkVlU@@xlnaVmlKn@JVLlnVl@XXÆèVlUX@xVLXVb°W@wnUWmXk@KLVwUmUkUKUw@wVaVK@k@WnkUKWkwlmXL@KVUlLVKXmWUL@aL@malaVk@aaanX@VVUblbJnXaVwn£K@UWmUk@UaWIV@bJW@KmmU@aUUUkmKkVKlUUnKVUlVaV£Å¥WUUK@UkUUw@m@mIkUUWLK¯Uw°¯@wUKUbKm@kkKUL@UUKV¥U@manw@k@U@Wm@@U@WwkmwWaUU@UUmV¯kw@@kmkKkUW@UK@ÅV@XWWkXa@Ul@Va@KVaUUU@aXwla@UkVWaXk@K@lmkUmV@Vmbk@»XI¥VUkVUVU@anKVUKUalU@wX@@a@K@ÝwL@UnÇlUIkJmn@bVVb@VmnkLV¯U@±lIWm@kaUI@aÇU@K@KUIkbWbJUIUyX¯UbU@méUUmUkWKxWIkJm@V¥U_UJUwmVkUU@@knwm@UmkWJkL@n@VW@@U@knm@kUml@xÅx@@XUJlb@VXJVxn@lbV@lULnV@VlnV@bWV@bXL@lVLVbV@blLn@VlK@xln@bX@laLVbnKUVVbKlXVVkxV@nnVUblV@@z°WWkbIkWL@LUJ@bUI@b`@UmI@mkK¯XWmUV¯@UUVUUam@@VULWUJIm`IUJKUkW@UxnWbnnmlXbmIUVmV@Vnb@VLUKWLnÒVVV@VUL@kJUV@bÈ@V°@XVV@l@xUz'], |
| 'encodeOffsets': [[ |
| 116753, |
| 26596 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3608', |
| 'properties': { |
| 'name': '吉安市', |
| 'cp': [ |
| 114.884, |
| 26.9659 |
| ], |
| 'childNum': 12 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lxnb@V@bV@ln@nlIn@blVXKnk¼@VUKWL@bL@`UXU`@V¦XLĠ@lJ¦@nV@l°nn@mVXna@nbKn@lIV@VanJ@_lKVVnL@LK@Vn@VbUVanKlLnbnJVbnWVnVVanI@Vb@LbVKVanXVbVJVU@aXLllbôlƼXxVLVK@Xn@xnVVVmb@LnVVKVXV@@mnaVXUVnVK@_UaUmwnKV_anKVL»K@¯ÝU@U@kWlUnlknKVnaUkma@UIUwl»Åw@VwV@nn@ÈXlKVmna@kVw@anm@n_WWk@mUkUK@ImkLUnbkm@wV@klUnLV±m@UInWkWmb@¯amX@xUVUKUaULWKXwKmLUVUJ_@wyWwkaW_XaWW¯L¯akam£@mUU@U@wnaWU@Uw@aUKUXUVKUkKWbk@@bUKUlWL¯LUJmLwU@UVaVU_VkmnUV¯@@xXmWUUUL¥makI@UKUkWlLkmÇ@aUk@UKL@kmÇak@_VlkL@`lbnlLVanLnbmVÆln@kJlbknmKUbÝmmwULUK@bkLWKULUUma@Kk@UV@L@llbVzxUxnl@bVLm@IVJXVlLV`@bn²@J@V@Xmbñ@WbUJ@bm@@LUĬU¦lV@xXb@blnUV'], |
| 'encodeOffsets': [[ |
| 116652, |
| 27608 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3611', |
| 'properties': { |
| 'name': '上饶市', |
| 'cp': [ |
| 117.8613, |
| 28.7292 |
| ], |
| 'childNum': 12 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@VI°`nm¤²@bVJUVVXUl@Vmb@xV@XbmVV@lkLmbn`VbnU@VaUnbVllUXVa@w°VW@_VWLnVlbLVbnlKnVK@IUW@_@am@ÑUólK@U@WU@VwU@UI@aUUaX@kwmJV@yX@kan@mkwVmmI@aUU@aUUW@kVkV@@anK»XVWnIVUl`@_W@wlUV@UWKnUbn°InJlUV@VnIbWn@VklL@l@Vn²m@U`kI@bWJnV@°VXnJmXVmx@VVL@bkLmWULUmU@bWXb@llnX@xkxVVnVV@¤nLnVxnJVXX@bn`VIb@blmlLnaV@blWXnlUnbl@KVanUVmm_XK@kWWnaU@UnaWUXaXamUkKmXUWLX¯WakKmnUWwXa@KW_aXWW_@WnIVl@XULnWVknK@ImyUUÆbXKÛ@W@IÆUnVÝlkVK@mUIVwkUVaUm@aVIVyXIaÈwmmk@UnanVUmÅaó»lwW@kkUVmUK@WKLUmWULkamKLk@Wa@wk@UU@U@mbUIWVKUXWmkUmVmU@LkakKw@w@U¯UUn¯l@bmn@xkJWxkL@VkI@mkmJUI@V@b@VVxnbWlkÈkVLbkKmVL@V@²nxWkLUL@xlKVxbXmVnWJ@Þ°@nxUKUw±`UImVmnU@kalm@akwU@UUJmxU@@U@kU@Um@@KnVm@kKmkU@@WUnkLWxkVUwmKmLkUbmKUbV@xUnkJ@n±UxVXUWJ@LUblUnm@W@nknUJUVm@kXllknVbÆKVVb¼V@Ul'], |
| 'encodeOffsets': [[ |
| 119194, |
| 29751 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3604', |
| 'properties': { |
| 'name': '九江市', |
| 'cp': [ |
| 115.4224, |
| 29.3774 |
| ], |
| 'childNum': 12 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@WUkVUkmaVUb@mVUam_nalK@kUnUWaU@@wna@UVkUWVUUI@a±n£m¯_JU@ĉ¦Ul@UVKmmLlm@ğ¹m`Uk¯@@UVK¯@UUK@amkmKkVVUa@UkUKUaL@VVXUJ@n@WUbnVb¯V@LÅlÝIJÅkÝm@UaWUU@UmUXmmwVUUKWUX±mUam@kWzUaVmÇw@aÅLmKXUWKkL@W¯IwVwlkUJ@Um@ÛÈWKUxWkaUU@KkLVl@UKUX±KUb@nVVUbUVmaUlUL@aUL@@nUlWzX`@V@lx²@Vlb@bVÞ@°nl@UxVL@lUbVV@n²xVUVmnUÞbaJ@IV°xnbl@nbÆ@VwnK@VnXlK°xnUlVXV@Vl@L@lk@W_XK@KkWxUL@JnVx@aX@VVUaIXlmL@bVVX@VbnKa²XVWk°a@UnV¤nbmLmW@XbmJUbVLaÞKL@K@U@aVKlbV@nXlJxV@VnVÈÞKôbźĕČmV@Ċ²xÆIV@Þ¦ĸ¼ÞVlVÞnxln°JkLXWVUVUVwnJVI@yn@lXlaXmWI@w»ma@UmK@akKkXmW@_kaWakKWk@@K@IWkUa'], |
| 'encodeOffsets': [[ |
| 119487, |
| 30319 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3610', |
| 'properties': { |
| 'name': '抚州市', |
| 'cp': [ |
| 116.4441, |
| 27.4933 |
| ], |
| 'childNum': 11 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@°V°UnÜ@n@lnLlV@bV°LlnLllVzVVXlVV@@L@xX@WlXm@UVL@V@n°kVmVUnKlaXxVbnlU@lVVnaVI@aX@VJ@V@bb@Vb@X@lUL@@VlIVm@wUVanLalVnKnLVxlUXwlKVm@k@Una@mWIXKWUÛVk@a@UVWn@@kl@@WXlW@_Um@UVK@aLnalInWV@@xnI@¥Km@kKmnk@mlI¤laXbVblknV@UKXVlUXa@@Unw@±mU@ak_±a@UJUIVKW_Xa@aWUK@mmUVa@IXa@UWmannlmX¯WKXwVUVw@XUlK@klJXa@kkmm@Uww@¯W¯kw@WmbULaUUU@mVUUWmkUbKmkkK@akU¯¥Ulm@akU@m@KVIVV@KUkUVUkaUWbmIkaVaUU@mWbb@bUlkbb@nK@bKXVWnULkKUV@LWKknlxXVLml@X@lULUb@xVxVLVlVnUxK@LWlXnmV@x¯XaWUUK@wVWUkÅçm`@mn@bUx@lmbUnkLÇWm@mU@Ux@Æxk¼VxVJ@nbVlmbUmLklmkVlX@VV@°Þ'], |
| 'encodeOffsets': [[ |
| 118508, |
| 28396 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3609', |
| 'properties': { |
| 'name': '宜春市', |
| 'cp': [ |
| 115.0159, |
| 28.3228 |
| ], |
| 'childNum': 10 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@VlbnK@b@JLlUnx±ĀXxÆWX@l@V@@blJ@nX@xUbVVUbVV@bVmnmJ@bmbm@klUbLmb@lVb@xUX@bVVVbV¤@LVVbXlVwLXÜÇn@@VIlVkUxx°J@XlKXLVWnLÆK@bÈxUnVbylXn@VbnW²XVLVVUnxWnnV@VVVXVbn@ÞÆlIÞJÆk@K°UUamVa@UUU»@wV@VkkUKUVW£U@UmW@@aXkVUnVlKVVUUkVmU@kWaUanUVVamIX¥W@@aUaUVW@_mW@UnIVVn@VbVm@bVL@anKVUkWKUXVIkx@nabVKb@nVJ_V@VwVUVVXUlUUaV@X@VblabnKlkVaXa¯@m@UKVUn@WXkW@@w@KU@UWkUUUykkmKk¯KU@akUmK@k@mmÛ¯V¯U@L¼UKmLbU`mLxVnVb@`LmUVUUWmb@nU@UWULmU@KnaUUmUwmJ¯IUJWIkVkaWVUIUlWaUIUVkKmbUIÒlVUnn@VlLUJ@bUX¯@aWVUKUXKUbm@UwKWa@a@VkUWn@Uak@mbXWJXbm@mLaWVk@wL@WmanU@knwWmkaWLKWUXaU@¥lUVVVbnw¥nKV»@aUk@a@UJ@kmLma@mbUWnm@ULǺ@LXnmxUm@UbkbW@@akLmWk@UXmJmUkV@VUXVlULmKUxkL@lmXnJ@Xl°Vnb@bU@WbKUX@VmKUX'], |
| 'encodeOffsets': [[ |
| 116652, |
| 28666 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3601', |
| 'properties': { |
| 'name': '南昌市', |
| 'cp': [ |
| 116.0046, |
| 28.6633 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@X@m@VIUW@UKVbLlV@VVbUlUnLnl@bVL@V°UL@V°@Vln_Ġºn@knKnLVU@VkĊ¥Vk@U»UaUÅLUalmkklWn@VUVIlm@mXn@VmkVa@KXIVUWVw²@m@U@VK@k@WUa@a@aU@IUW@@bUJmbUU@kkVmUaWwkbmLUVUnlWbUbklmLakbUaW@U@VbkVWVUUUVUx@U`UI@maULamb@lwJWUVXLlUVmL@bUK@aUnUam@UUmJ@VnX@`UXVVb@bX@W¦nJUbUmVVbXb@lVUnVlVUUkLmUUVWl@bX@VnV@X¤VUVLllUU@@x¼VV@V'], |
| 'encodeOffsets': [[ |
| 118249, |
| 29700 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3602', |
| 'properties': { |
| 'name': '景德镇市', |
| 'cp': [ |
| 117.334, |
| 29.3225 |
| ], |
| 'childNum': 3 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VVX@VbmzxUlU@mbmL@V²xVbUVVblbX@VkVykValKVI@bn@n`lVWnX@lL@WKnVIVa@¯nK@alIXJVIVWUwn@nUnK@alI@a@anKm_aW@UWmIUwmmK@£UUmUUlwwW@km@kWaXaV@VnVKnXlK@aUK@UnwWUnmIUW@¯mUXI@alJV_n@m±@U@kkKUlm@XamJ@UVUkmI¯JmamVXL@VUkV@xX@`k_UVmJUXW¼mL@bU@UllX@VV@bVV@bnJUnlx@nmb@lW@zUnIlx@WbVV@bVJV@UxV@@X@VkLVôÒn@@b@`VX@J'], |
| 'encodeOffsets': [[ |
| 119903, |
| 30409 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3603', |
| 'properties': { |
| 'name': '萍乡市', |
| 'cp': [ |
| 113.9282, |
| 27.4823 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VWnL@UVWLXaV@@ama¯Uk@WmInW@klKVwnLVKUkVW@UlUnVnIVWl@nXlK@bX@laVan@VnwWm@KȹVK¯m@kmU@¥kIğ@WKU¥@V_VW@_K@aXKVL@Ul»mWLkU@amkJm@kmU@@a@UmakwU@Xl@VXk`UIW¼kWWX@@lxV¦XlW@Ubn@mUkL@UmJ¯UkUWVUaUlm@UXWlnUJ@LmLUnXll@bUVUUmVUn@¦xlnn@VÆÈU°kbVVxllnL@VnVVUl@VanL'], |
| 'encodeOffsets': [[ |
| 116652, |
| 28666 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3606', |
| 'properties': { |
| 'name': '鹰潭市', |
| 'cp': [ |
| 117.0813, |
| 28.2349 |
| ], |
| 'childNum': 3 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@XV@nlL@lUnm@Ln@@VlV@@VV@nwVI@VVlx@bknlbV@nmnUVJ_²VxVLw@m¯@ÝXImnUWaUwkL@wVKlKXmw@±@UKnUlLaKlUlÇXkmaUw@U@a@UUkwUJ@zWJw@WbkVWUL@VmUklUaWakb£kJ@nmlnlL@nL@¦mJ@wU@mXkJmbK@bUL@VVn@`kXW@Xk@@lm@UX@V@blÜUXVWLXJ@nmb@V@l'], |
| 'encodeOffsets': [[ |
| 119599, |
| 29025 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3605', |
| 'properties': { |
| 'name': '新余市', |
| 'cp': [ |
| 114.95, |
| 27.8174 |
| ], |
| 'childNum': 2 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@m@@WULUKWwÅ»ókakkWK@bUVUIUamWUbULa@KUa@mJUbmUXUmUamImakKmLUbVUam@@UL@KKmUUkL@`mIUb@U@V@bVl@b¼UmL¦mxUaUUVk@¦VWbXVLXKlbXnmx@lmVnb@XKxl@XUbnKn@WaXIWnal@Vb@XmlV@U@bXbLVxn@VaLVWVLXUb°@VW@aVIkK@UmVmkUÑVJnalLVUVJXbVkVJXUlblUXJVI°JnI'], |
| 'encodeOffsets': [[ |
| 118182, |
| 28542 |
| ]] |
| } |
| } |
| ], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/util/mapData/geoJson/ji_lin_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [ |
| { |
| 'type': 'Feature', |
| 'id': '2224', |
| 'properties': { |
| 'name': '延边朝鲜族自治州', |
| 'cp': [ |
| 129.397, |
| 43.2587 |
| ], |
| 'childNum': 8 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Wxĵm@ó¤VX@@xܼƨ²xWxVV@XVbWXllaÞU°Ċ@ô¼LôÝWanV¥Ñnĉ°¥ÅX¥°¯@w°w@»°k£°mÈŹmÈbÆŎ¦K°z@kxl¦UbU¤klVKŤÞȰ@@bV@nVVUlÞ¦lUllVlU°ÑU¯V°wbXxl@V²@nô¼ó°kmVk²ĕw@wVÞÞ@@Ġö»¯@bnb°mÞ¯°V°ÈJmX¥mamUÅUlaU¯@wKkl±n@@wkÝVUUl±¯I¯bal@kLmakb@ġŹé°Þb°ékLmwXaÅb@bVlbVbÒVbUbUUanwakbVUVak¯ULmxV°UxnôŻX@JXklbkbĉabWU@kWUU¯@@klm@@Å@awWXlKkI@WbUaVIUanU@ĕ¯KmUnWUwm@£ċèkUmbUmm@@nkJUalwk@@nmWUan_óaWmnw±KIwl@UmI@an@@mlUÅmV_KUk@U`@_KUmU@U¯mmb¯@kbImV¯LkbKÛ@ÇnɱJóaÝĢkb@xÒÇll@²VÆUVVUÇ°XóxlV¯lV@bV@nx@¤@șŎnxV¼knJnKX°¦UlnVbUbÆVnÞWVX¦llb@l°VJôÒnLVbbX'], |
| 'encodeOffsets': [[ |
| 131086, |
| 44798 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '2202', |
| 'properties': { |
| 'name': '吉林市', |
| 'cp': [ |
| 126.8372, |
| 43.6047 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ôlzaÈV°K@mLWlnVxUVÈ@ÝĬUÈnôLa²VmĀkV@ĠĊnU@bV@b@nl°UVnÞaôJ@bV¦mlkbmVXx¯@VxmnbbÈKV@bÈLwĠyônmnbÜ@nnVx@n²KJ@kal@nxÞULź±Vwkw¯LWWUkŎīVww°yVĕ°wÈVlkÛ»@wW@Uô£@nĶXwWaUamKóÑUI¯@kakkW¥XUmÝÅUVaUamVk¥W¯LmIlmU»mwȚō@£kJUÇk@am¯y¯UVwa@wġx¦K¯X°Ċ¯¦U°ċWULÅa±b¯@UkÅWmVkIUlóċ¹`óIlXWXxmbULÝbƧ@x¯bÈl@x¯zaݤ@nmVWb²bmn¯J¯Ò@n'], |
| 'encodeOffsets': [[ |
| 128701, |
| 44303 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '2208', |
| 'properties': { |
| 'name': '白城市', |
| 'cp': [ |
| 123.0029, |
| 45.2637 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@óǩŁ@WlwUaƑwÛÅÇéĉamKōÇ@IôġVȁÑŹçÝUƧċĉwóóÝ@Ƒ»ğL¯ll²@ƆÅV@¦mÅb@nmlU²VxlUn@VbnWbÇbkÒn@èlnlUÒ°Lx@¼ĉb@ÒUċxÅènLVxÒbÅJ±a@_ÅJÅnVbKlnUÜĊ@UxXVÆnmVJÞ¯VĠwXw°xWLxKV¦ôUwVÝǬóÞÞ¼ÞkVôȘxÞUlVn¦ÞĊa°wb°@bÆwlŤL²`z°@V@@nJVnl@@¥nUmmn@mwnmmUnk@mlwUaLnwn¯°anWakIÇmXwÆamUXUlJXaUUklKUknmÞV@K@VWÞ@VkUwV'], |
| 'encodeOffsets': [[ |
| 127350, |
| 46553 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '2207', |
| 'properties': { |
| 'name': '松原市', |
| 'cp': [ |
| 124.0906, |
| 44.7198 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@źèȂÒUóĢ@JŎÈLnĊbÈêÜƃxVbkx@XǪłôkÞ`Wb@n°abKnVw°`_X`W¦ĊIkmVakwKx°UÞbU@ll@°¦VWaÞbxÞI@mVI@VkÅUWK¥nLa@@È@°Æ@nU@KÞalkUwVékUWwkUVkkJk¯@»ókV¯ÆÇI@bĉô¯@ķw¯nmmÅL¯wVUÞy@UówÇLkmm@@UóxkkĉmL¯wVwkWWXmLõm@kűV_ô»ÛƯ@VaVaĠVlmğwķUóÝƽ£ÇJkbǫaƽLW@nxݤkzy¯XɅm@VôÇX¯Ė¯ºÝnUnLVlUÔmV'], |
| 'encodeOffsets': [[ |
| 126068, |
| 45580 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '2201', |
| 'properties': { |
| 'name': '长春市', |
| 'cp': [ |
| 125.8154, |
| 44.2584 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@U°xÆKnn°mĸx°@Ċó@aÈJ°ÅUôl@¼l°IllUlVXxlVUêVxkllnÈUVll@Vx²IÞ¤VUlVnIôlÞlwô_bVaĶLXÅÞÇ@K¯@wÛaçn¥¯WXyW¯XwUmmÛ@manómğzxÇK@aUÇLamanUw°@WwnUalnk¥U@aóIÝbUm¯Vmk@@aU@amVğĉ@lUnÿ±UbóKmVÇÞī@ÇVUUwmXkKn@L¯ÇUbyókōè@bn@lÝX@x¯ô@ÆUV_maXm@aóJWxnX@VVnĖVnUJ@nōÆǼV¼kxLklÝw@xx@zV`ÅbmxU±xUnnmknğUbUUb@Å°Üó¼U`Ʋ@lönKnXWlXUx°xnKĊllôw@Vn@lnÈKôx@VÝzV'], |
| 'encodeOffsets': [[ |
| 128262, |
| 45940 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '2206', |
| 'properties': { |
| 'name': '白山市', |
| 'cp': [ |
| 127.2217, |
| 42.0941 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Ul¦kÒÆ°IlÒU¤ôz¼lJUnÆXVl°@²aÆbVKČXV¯°¥¯ĉ°WL¥Ģw@xbUx°V°znb@ÈlVlI@w@mU@akU°kUôwWȯVUVUűU@kÈkÑw@laÞġUÞ£@ƅKnÑĢ¯@WaUaVUVkkw@a¯@¯ÝVXnW@@WkXmK@xkKUb@bW@Uw¯mmb@WKUbmUbUaWbJĉIVW@Il±LkmUbUm@nkKWa¯n@`UbmaĉL@bÆ@W`L@n¯Xb@kb@xL@VkL±mlUIU¥mL@lÅx@_la@UaV@kmmK£LmKUnÅKVbmXVlèĉUUbmlĢŤIl¯bǦl@ô¼Ģ@x°l¤nal@xb'], |
| 'encodeOffsets': [[ |
| 129567, |
| 43262 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '2205', |
| 'properties': { |
| 'name': '通化市', |
| 'cp': [ |
| 125.9583, |
| 41.8579 |
| ], |
| 'childNum': 7 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ÆlXnĠxĢ°lÈ°K°kXm@¦VbkŤJnݤkVÞVVkÈb°y@wkÇ°awƨ@aÞKVnaWwXWkôJ_ČºôVk»óyV£kÑJůlÑk¥Va@wkbmk£¯@wġó»@kÈ¥°akJÆ£ġnkVaĊVkçWUnUaÆLVmnLKU±@m@a¯UbmV¯m@_KUaÅWó¹@UanmWak@@wmI@y@mkJVa@UaIkJ@n@Um±kkxmIkbÇm@°bXnV@°ÈmlÞ¼¯XVº¯LmkWWXLmVVlkn@@lnWÆVxbmnm¯lÝaVÈè@¼VbÆ°ÞUVJkxIxIV¤ÒXxmn'], |
| 'encodeOffsets': [[ |
| 128273, |
| 43330 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '2203', |
| 'properties': { |
| 'name': '四平市', |
| 'cp': [ |
| 124.541, |
| 43.4894 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Ɇn°WzlyÞ£mwX@ƾKǬblaÈIƾ¤ôÞĸVĠxnmmV²wVnwÆaU_@yw@wÞxlkKlwU»È»ŎÅ@mVIUmmĕUU@mWXwIô@bWnnbU`V@Å°ó@wÞW@km@aŎç@m°Ñ°Inm±aXaUn@mƑU¦@ǯaU£aUġ¦ÅÒJōUŻókUÇ@¥¯ak¯mUVak@@aċçÅaUm¦Ý`XbÆ@n`IxĊÞōÞml@Ub@Wl_¯JkÇUÝÆÅb@nllUb¯±a@WĉJġĀ¯Unóm¤xôaVnxôI@xV@bmÆ@lnLmÞ¯ÞxVb¯þ'], |
| 'encodeOffsets': [[ |
| 126293, |
| 45124 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '2204', |
| 'properties': { |
| 'name': '辽源市', |
| 'cp': [ |
| 125.343, |
| 42.7643 |
| ], |
| 'childNum': 3 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@żôŎVIÆÑĢ¥VbV¤°bÈ@V¥ƒÞ£lÇUUUÝlÞ£mţIlUa@¥nlW¯L¯kÇġ¯ğwWmÅk¯UVUbWlXlmnbUx¯xVVknlUbVÇKUb@VnbmlnzUº±bmJUbWÈnèmÒ@X`WL'], |
| 'encodeOffsets': [[ |
| 127879, |
| 44168 |
| ]] |
| } |
| } |
| ], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/util/mapData/geoJson/liao_ning_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [ |
| { |
| 'type': 'Feature', |
| 'id': '2102', |
| 'properties': { |
| 'name': '大连市', |
| 'cp': [ |
| 122.2229, |
| 39.4409 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@IÞmVk@wXWÜbnwlLnU@nLlbXW@awnbl@XLa@Ċ¥@LULnJ@xVnmV@VXXV@VJkn@VÜKXXôJlbxl@IVbnJVLUbnlnVwJVU@XUaUUlwn@°nVKnV°_VJwl@nwlVIXWlIVVnK@IWmkIVaVU@WÈUlmU@UWUalkXġŻ@kI»mmakUmĉUŁV»²ġVĕ@aUU؍IɃ`ȃ@kw@Umwĉ@WķÑIĉÇbÝLkymbIwÇmÛbmbU¯ÜõÈkÆVbŎxnXVÆnǪ¦b¤UxÝnĉÒmĊVȤÈbƼĀÆÆÞźbVVbX°²¤'], |
| 'encodeOffsets': [[ |
| 124786, |
| 41102 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '2113', |
| 'properties': { |
| 'name': '朝阳市', |
| 'cp': [ |
| 120.0696, |
| 41.4899 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@na@UVI@mÑWkaV¥UI@wl@aÈbm@wVak@@K@k@a@UUmUUalmU@KÇUű¯@±kUKVkUaaU@¥m@@¯k@WLUmkn@mmIkm@amU@wVmkU@Klk@UmaXIWWULaULVbmk@UUmUk±_Uym@mbkImaX¯WWxWKzU@WkJWwkV@Um@UbVVVVXb@VWX@W@Vkb@VnUK±aUUlwXÇWKknU@mmUkLUVVUUVUawbkKmwnIkJ@nmb`kmVkLWwUm@UUUK@UmaUa@UUaWK@mU¯Wkk¯VmUUxVXUVmL¯ymXkWUbmXUKVknWx¯JVnkLl@VVxnxlĀVL²WlXl@bÝVUn@bnlÜaXblIVl@@Ȧ@VmbXV@@xVVnUn@`°@VnXU@K@VV@VmbnVn@ln@bx°Ub@bLV`ÅnW@@lUnnWVU@Vbkl@Xl`XxVUblkX@°¦VUVVbUlkV@UbVbkLUxmJkX@bbxVKÆlXXbnnala@Uk@UVVklKVUXKVU°KVan@VUnLKVLWVaU_@mmUXa@mwXwVkVWXkk@k@klm@wXKl@U@KVUUUVaUV@alLxUx@b°°VnnVxlIXJmxLUVlV@bnX@VbaVx@XJ@bn@VVXÈl@llX@lUVô°°@ÞVbn@Vk@VW'], |
| 'encodeOffsets': [[ |
| 123919, |
| 43262 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '2106', |
| 'properties': { |
| 'name': '丹东市', |
| 'cp': [ |
| 124.541, |
| 40.4242 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lzXJU@²x@@V@bUVmKUn°n@lnVKnV@n@VlV°WbXn@VzJ@¦@bkbbUl@bkbJ¯zWULWbklVnb¦VJ@K°Ukl@@WbVn°@Vm²UnX`UÜLXmVXlKVbUVVnUbnX@VUL@lUbWx@²kl`n@Vlb@nUVWVLVU@aV@²bl@ÈmxWXVÈUJVl@laWnXKÈkÈ@Va°bÆm@XV°IVV°UnalVUn@UwVU@@VVJI@bl@XK@wWmXUUVbkJVXnJVI@mknwlKXL@`l@VI@UUaVKÞnaVm@aÇ£XWU@aÇUU@mbkKm£@WWL@@Kk@klUbWKUkUU¯UõÛmUUaVUU@WU_W@kVkJ_WKkV@bUL¯¯±mk¯ġğÑ@UmwKUaka@am¥ÝIUWmk@wmţLKʝbȗKWĢklVbX@VVknÇV@XUVUblJXn@J'], |
| 'encodeOffsets': [[ |
| 126372, |
| 40967 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '2112', |
| 'properties': { |
| 'name': '铁岭市', |
| 'cp': [ |
| 124.2773, |
| 42.7423 |
| ], |
| 'childNum': 7 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@XJm@¯mXUlnVbUJU@bV@UJWL@VXLmJVbkXlJXxVL@b@V@n@b@`Vbk@lxknV@VVV@bUL@bV@@bVK@VXLWLXJ@LV@nbWJ@IUVx@LVJUXVxVx@VV@@LXJWL@VU@@L@VnL@bVVmVX@@VVInJmbnLWVnVULVVU@VVmX@@JVzl@nVVKVXÞ@mk_lmUUWV_nJlUÞÑÞVVUVVLUVJ@IVna@@KV@XwWknwnKlalUwaĉÝwJl_@aUaKUUU@WU@WXUÆ@@UVK@n@UnVVblK@bllb@bbW@Xbl@UlnLl°°b¦nKlVnIV@UWU@WXkw@am@nm@aVw@I@KUaVIm±XÑlknJVnVJaX_VaUaVKmwnkmmn@lU@U@mnaXlKUmUIVmklaUK@UlUVUW@UkVma@UUU@JmUU@@bmbKWV¯XUKm@ka@UVKVk@aUKmLkKUUÝUmbXbÇJ@k@WU_@m@klm@UXKVaUI@KWUXaÇWkaWUkWUL±U@lUU@UJI@V¯JmIm@@aU@Uwa@UV@VkIV¯aUkWkb@bVL@@VVVUXW@Ua@@bÝbUVÝ@LmUkVUbVllLUV@LXWbUXm@U`@kxlnnJlbnIllLXlVlUXmVKnV@L'], |
| 'encodeOffsets': [[ |
| 126720, |
| 43572 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '2101', |
| 'properties': { |
| 'name': '沈阳市', |
| 'cp': [ |
| 123.1238, |
| 42.1216 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ȚĊÜ°bLlÞxUbUn±@ÈnVÆL@xnLlUVbxkImJkn@V±LUxkV@bbKVKnzVl@L°@VaxÞUlbôxVV@@V±bn@llXLöXĶnal@nkVJVI@aU@@aVK@aUUUU@lmkwl@Ua@_@a@m@U@aUKWwkIlWUanIWK@UXKVIU@@aVVIUamVknW°n@WI@KUmULWnkVkUWKkkmJkamIkmlw@V_n@VWXaW@KVUkKUkValUnVK@ÞVUÞa@a@VbX@VWUU@U@UK@ala@IkKmUUa@U@VkkWVwU_@KÜUXbl@V¥XUVmXakÅlUUkIm`UIUJW@UIKmkm@UUJImmU@VUXU`mIUbUK@LJUUl@X@UbJkU@nm@Uam@@aUmLKwmWXUK@kUaÇa@JUIUa@aKVUUXmUy_@lmbkLUKWLX`n@bVL@JXLWX@Vnb@Vm@UbnVmL@V@x@LUbVV@V@LUVl@mb¯U@xU@UVVV@X@VVblJ@bnVKUnx@llnL±¤b@k`VXÆK@kV@¼kl@bWIUl@VmLnbm@@JXXmb'], |
| 'encodeOffsets': [[ |
| 125359, |
| 43139 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '2104', |
| 'properties': { |
| 'name': '抚顺市', |
| 'cp': [ |
| 124.585, |
| 41.8579 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@XVl°bUlJ@UVU@bVxV@@bn@nJ°I@UJIVV@V@k²VVKlXXVblÈXWbXV@LVJUbWL@Vkn@l@nV`@X@lÈIWanaÞVVVlLnKVL@bUlUL@Vlbn@VL°WXULna@aV@nV@IVV@VbUnl@VXnKVa@UUnyWkXaaVk@aabnm@_WKXmWanU@alaUl@XJVLVxX@wnKnVlw@V_@a¯¥@UkKWUaUUanK@IaU@WUaVw@klUVyUUVUUÇ@Iôba@mnUma@kXa@UWak@Wal@a@WULmU@U`mIUU`mUk@@UUK±nkJbUam@kwm@@a@UU@Ua@@K@VK@kmKU_UKUUaĉWmkkL@`LnmlkLkbmK@k@Ulmb@b@xUVIUlmVXXxm@JUUk@WUk@akx±@¯x¯UmbKUUVmUU¯UmVVnWkÆlWbUnWVU¦k@WaÛV@LV`UxXllU@@VVbnVlL@J'], |
| 'encodeOffsets': [[ |
| 126754, |
| 42992 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '2114', |
| 'properties': { |
| 'name': '葫芦岛市', |
| 'cp': [ |
| 120.1575, |
| 40.578 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ll°XnV@XLVb@VVbnb@VLVV@VVnXxlKnUl_na@mlImJnxlLaxVbUVVUVUKVlnnV@lmXLÈWkxVV²bVLm@Ula@UX@XW@UWaUUUUVan@V@lUXxlIXV@yXLwXXW°nblJnan@Vz`l²nVVVl@nUaVKbVKnXVaUaVUynXK@kVK@X@m@mLXaLWU¯w@a@UVw¥°ó¯¯y¯Uǯ»w¯Im¯ÇUUl¯»ţKċÑţķm¯w@mU_ómk¼VnU`±IkbVlnnU¼±Lk`@XWl¦UbmVUxkXVlkbllUVb@bkVmx@XVV@Jb±aULkKWXkWmX¯aUJmIkVm@xU@n'], |
| 'encodeOffsets': [[ |
| 122097, |
| 41575 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '2109', |
| 'properties': { |
| 'name': '阜新市', |
| 'cp': [ |
| 122.0032, |
| 42.2699 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Xnb°lVlnXVJLlVnl@zÆxnK@bblKVLn@@VaVLVK@L@Vl@XVVInVVKVwlUXwlKLVVb@aV@XlUXbVW@nlWnXKV@@V@XUVVLUVV@@bVVV@@ln@VbVUXVIxVanJ@UIVWL@UV@@¤V@nInwWklnIVxlnzUVÇJ¦VVÜLĸUnW@aV_WĊXXaKnkl@nmLa@alUVw²K@UlmnIlJwaVUkmK@wÅKmU@DzVmVaÝwkKaÛ¯șĉķ¥ğ¥@kUWkƏīÝ@@akUK@KWIUm¯nU¯JmwUVmIkJÇLm@UImJUU@aW@U@@nUbJabXVWn@UVmX@V@b@l@L@lUb@xnÇabk@@xVJU¦lbXÒ@nUJ@Vmb'], |
| 'encodeOffsets': [[ |
| 123919, |
| 43262 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '2107', |
| 'properties': { |
| 'name': '锦州市', |
| 'cp': [ |
| 121.6626, |
| 41.4294 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@nJ@nlmVnXKl@@°n@@¦VbVbUlVL²l°@ƲÈV@LVknVbVVnnWVU@XmWUabIVa@mV@X@@bVVnIVJ@nÈKlInJVUnx°IV°mVnXJ@LLlV@b@ÞƐĬXllV@Ġ¦ĸ¦naWW@In@manK@UVkXJ@alk@»lU@ÅLUWl_@a²£Kkm@kwVmULm@akIUa@U@WUUVUaÝ@ğwkmĉ£UW@@bÇL@ma@_mKlXUwKLţÓ@UWw@K@UI@mU@UV¥@°UnJ°@@_KUwW@UnaWUmmI@mķwUaÇLóVĵwÝUUW¯¦Ux@Vb@xV°XKWbK@n@nW@UL@lWLmzUVVbUbmWXXWJbn@Vkl@LlVUn@xnV@bln'], |
| 'encodeOffsets': [[ |
| 123694, |
| 42391 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '2103', |
| 'properties': { |
| 'name': '鞍山市', |
| 'cp': [ |
| 123.0798, |
| 40.6055 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lxĠÞ@bV@@w°Vna@UkV@K@UUUVa@K@w@UnKmUVan@@Uma@UXWWK@IUK@amW_XKVLlKna@kmKVak@VU@VmU@anIÆan@aUVnb@blLV`ÞLlUbnaKn@naVU@¥°IVK@anUUKVaUVak@mJkXUVwkVUUa°U@W@WlkXWlIXUlJlaxIVVXLll@nLV@lLXlKĊz¥maUlkXaVKX°yIla@aVkala@a@¥IUy@WmXa¯kU@U@mmUULkmm@¯VmnLVU@a@U@±w@VWIkymLUUkJWXJkUmxk@xUI¯`mUULm¯m@kxVVbWV@UVIUx@bkVVVxUbVV@V@zJVXUlnk@@lkLlLUU±Jkm@UIUVLUVU@K@UnnV@l@LlaUJ@zn`@nWlIUVUUUV±Ln@nmL@VUVkLVlUxVLVlÅXma@@akLmWUX@JUnVJVkXJ@X@`WXVUVUIlbW@bVUVL@`Un@¦U`@bUV@z@Jm@@XV`LUL¯J@IVKmKÅI@JnWVnLnVxV¤z@bmV@VUV@bUL'], |
| 'encodeOffsets': [[ |
| 125123, |
| 42447 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '2105', |
| 'properties': { |
| 'name': '本溪市', |
| 'cp': [ |
| 124.1455, |
| 41.1987 |
| ], |
| 'childNum': 3 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lb@VnlnVVUb@VJ@nnJ@bmXUx@xVbkbkWLUxnl@Ul@xWx@nUV@¼UllknkK@bmbnlLVJX@VIVJn_lJVVXUmnU°VVVUnVVLna°V°w²@lwbl@XVl@VVIn@wWWnUVkJVUw@@anaVk@@lnLlalKnkmK@_lKnlĊXVbVVLV`nL@lUL@@L@VbV@@V@bn@lxn@VbalI²mVL@Vl@nV_VVnJV_@nVKV@X@bkXbl@XblylUUk@Xa@UVIlK@UUWVULlm@UUUnKWU@K@UXmXVa@U°KVUUWUk@aUVKkaWkKUknaWa@U@m@mk@aUJk@@_WKkLmxl@nUJmIUWlIUaVWVXn@xWLk@@aJUI@U@UVVxm@UVkmb¯VUU¯JWU@Ån¯aUbÇ@ÇlLmWXkbk@UIÇVUXWwÇnk@±aU@@bUVUKUXmV@kaUm@k_±l@XwVa@kVK@UWmVaUmVUUakLUWWnÛKVW_m±VnU¯@Uma@Xk@l¯V'], |
| 'encodeOffsets': [[ |
| 126552, |
| 41839 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '2108', |
| 'properties': { |
| 'name': '营口市', |
| 'cp': [ |
| 122.4316, |
| 40.4297 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ĊĖÆn¤°Ċ¯ŎWô@xXbwnKl@nX@VUVKmL@VU@UxÝ@VlbxU@VUb@bk`IUlVUnV@@UV@@JnXlK@b@nbÆWUkUKVwUklKVU@UnK@mm²KVUVVVUJXk@mm_@yVIbk@K@kmUm@VLV@VUKVUVJn@l²IVVKklK@kl@kmVUWI@y@UUUVawUUUl@akmmVaUKmIUaJk@wkaóIWWÛL@UlmUIU@WW@UnUUm@wmIVK@Kĉ¦@bWKk@max@bWXkamK@mVkKmxÛaWX@xUlÝnJ'], |
| 'encodeOffsets': [[ |
| 124786, |
| 41102 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '2110', |
| 'properties': { |
| 'name': '辽阳市', |
| 'cp': [ |
| 123.4094, |
| 41.1383 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@`VzWnVUVL@bVbVJ@IÈbVb@lVLXWnxLnKVb@n@Vbn@mV@lIVa@@WkVVI@KVLVanJV_VWUV@nnJVIVn@na@alLlmkVk@»VU@mXwwk@@VmkVwXKllaUa@wVwnW@amI@mUI@VaUUkmm@UkaL@UIĉyLWkkKU@mKk@kWKUUJwkbkIWVkJWXkl@X@X¯VVbUVlUxVWlnI@lUbVUbVLmV@bUL¯J@¦UVmbm@LmbakVÝKU_kK@amaVUbm@ÅbmJ@bVUn@UVl@UbnL'], |
| 'encodeOffsets': [[ |
| 125562, |
| 42194 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '2111', |
| 'properties': { |
| 'name': '盘锦市', |
| 'cp': [ |
| 121.9482, |
| 41.0449 |
| ], |
| 'childNum': 3 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Vbĸx@nnJVnXmb@VXVxL@`¯@mI¯V@U¦@VV@nJ@V@LXx@VŤÔKLVxWknL@`b@nÈK@a@VXĊ¤nVK@aVU@UnU@ayU£UwmmKXUm@IÆJnLUL@J°IVKKU_@Wn@@I@yVU@aV_@¥Vm@_UKUV@aXkaVJVUUXW@_@WWIUlUIVm@IVW@IU@@VU@mUVVkJ_l@aVa@UVwka@UÞVwV@@UnKLVU@UmWk@mLxWa@wóUVUIÇÆĉ¦¯¦¯xʟJ'], |
| 'encodeOffsets': [[ |
| 124392, |
| 41822 |
| ]] |
| } |
| } |
| ], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/util/mapData/geoJson/nei_meng_gu_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [ |
| { |
| 'type': 'Feature', |
| 'id': '1507', |
| 'properties': { |
| 'name': '呼伦贝尔市', |
| 'cp': [ |
| 120.8057, |
| 50.2185 |
| ], |
| 'childNum': 13 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@m@Łkklô@£kJ°ýɅķÑó¤ğLĉÅlÇğŁW¯¯ƥóÿlwkţÈéÝƛó°ÞÅxV¤ĉĖWƒ¯lȭţυ̃ɱÿķƅˋğɱřÝţϙȍƧĊţ@¯kWKUKm¹Å@ķJU@ƧÑƧō¥˹Ɔ@L@ÞVLn@VōČWJX¦@JŻbU@ţÞmVU@ȁýóbkWWLůUWġkmó±UŹôV¼ƽ¼ł̥ĖƽǬʉxĉŻȗKΕ̛ʵƨʟÞ˹»Ƨţ»Ǖō˷Ȍ±ȚʊĠUɾɜɨmÜ֞˸ƅȂ¯ǖKˢğÈÒǔnƾŎŐ@Ċbôô̐¼ƒ@ĊôĊÞĀxĖƧL±U°U°ĬƒČ°ÜêɴȂVł°@nxŎèbÈÞȌǸl²IlxĊl²ÒmôĖÈlĵºmÈêVþxɛČʉÇĵVmÒÈɆôƐŰǀĊ°ÆǬĮƾbyĊ@ĠƒXǀċm»ôw°Ûk¥Çm¯çkkÇǫţǕéX_ĶWǖīŎaÆĵĸĊ@ȚȘĊLĢĉVÆĉʊÇĕóaU¥ĉ°mkÅ°ġUĠřk°mÑČÿÛƒWĸ£ʠÆxÈÞŎÞ»ʈ²ĊÇČalÒ°Ť±ĸzĊKȲm¤Ŏ@Ò°¼nyȂUźīǖƳÈē°@ÝĶ@Èkl¥ÇçkxkJXÇUÅ@£k»óƿīÛ@lÅJl¥óý@¯ƽġÆÅanċ°é¯¹'], |
| 'encodeOffsets': [[ |
| 128194, |
| 51014 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '1529', |
| 'properties': { |
| 'name': '阿拉善盟', |
| 'cp': [ |
| 102.019, |
| 40.1001 |
| ], |
| 'childNum': 3 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ƏnǟƨʫŹɆÿ°¯ÆV²ˢżÿ@ÝÆŁȰ¯ȀƳĉó@ğky¹@īwl£Ź¯Ŧé@ÇÇxŋĉƩUUŃōLÇĵóÝnóç@ó@ġƱ¥çWUçÆō@éçťKçȭVһƽ̻aW¥ȁ£ʵNJǓƲɳÞǔlżÞmĠóĬȂɲȮ@ÈĢŮźÔnĶŻǠŎȭгŃċóȭţΗÆƑÞƧÅΫóȘǫɱȁġlÛkÇ°ȁÈnõl¯ôÞɛÝkĢóWĊzÇɼʝ@ÇÈķlUČÅÜķnέƒǓKȮŎŎb°ĢǀŌ@ȼôĬmĠğŰōĖƧbЇƧōx@ķó£Ål±ĀƧīXÝġÆêĉK°Ýʇƅ@ΌʉżÅÒϱʈ@˺ƾ֛।ţશóЈèʞU¤Ґ_Ƒʠɽ̦ÝɜLɛϜóȂJϚÈ@ǟͪaÞ»Ȯź'], |
| 'encodeOffsets': [[ |
| 107764, |
| 42750 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '1525', |
| 'properties': { |
| 'name': '锡林郭勒盟', |
| 'cp': [ |
| 115.6421, |
| 44.176 |
| ], |
| 'childNum': 12 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ʶĬĊIȘƨƨ@ĬÛĢșŤĉĬĀóUÈŚÜènŦƐȤȄłϰUƨťƾÑ܆ğɲƜǔÈèʈƲĊƞƒɆ¯̼V˺Ò˺ȂŤVĢêUÜxĀˌ˘ƨÆ°ѢmÞżU¼ÆlŎ@ĊçŎnÈÒͪŎźĸU°lżwUb°°°V£ÞlĠĉĊLÞɆnźÞn¦ĊaȂīġŃ¯Iĉůl»kÇý¥Ŏ¯én£ġÑÝȭxÇ@Åçķ»óƱŎ¥çWÿmlóa£ÇbyVÅČÇV»ÝU¯KĉýǕċţnġ¯»ÇōUm»ğÑwƏbċÇÅċwˋÈÛÿʉÑ°Łkw@óÇ»ĉw¥VÑŹUmW»ğğljVÿŤÅźī@ř¯ğnõƐ@ÞÅnŁVljóJwĊÑkĕÝw¯nk¥ŏaó¦ĉV¦Å`ğÑÑÝ@mwn¯m±@óƒÛKˍƏǓ±UÝa¯lōșkèĬÞn@ŤġŰk°ċx@ĉ`Ƨĕ°@ţÒĉwmĉ@na¥ķnÞĉVóÆókĉķ@ÝkƧƧÛa°Ç@ÝÈUóbݼ@ÛÒV°@V¼ˋLÞɅŤŹǠVÞȗŤÇĖÅōbȁƜ'], |
| 'encodeOffsets': [[ |
| 113817, |
| 44421 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '1506', |
| 'properties': { |
| 'name': '鄂尔多斯市', |
| 'cp': [ |
| 108.9734, |
| 39.2487 |
| ], |
| 'childNum': 8 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ĶL²ĬVłƑkkl@ȎŘWńÈĬȗ¯ºlz@ĠĊôŦôÒĠ°kÞÜn@¤UĸèĸbŌÈXĸLlÒĢxɲƤÈÛƾJÈÝ°UÅĶ»²VW¯ĸJôbkV@ôlbnĊyÈzVôab@ĸÞUl°yǬ²Ǭm°k±lbn°@È»JXVŎÑÆJ@kLÆl²Ġ²ʊůĊġřóƛÞÅ@mmLUÿóĉƧ@»L@`ČĸmȗÑţů±ĉğl¯ĀwÇçƧŤÛI@±ÜĉǓçō°UwôǫůķƳűbÅ£ÓÇwnÑó@ȁƽ@ÇƧĢón»ŏĕóĊ¯bÅVȯÅImōKULǓ±ÝxċŋV±Āȗ°Źl±Û@WÒȁŚŹНŚÅèŌô¼°ȰɞȂVĊ'], |
| 'encodeOffsets': [[ |
| 109542, |
| 39983 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '1504', |
| 'properties': { |
| 'name': '赤峰市', |
| 'cp': [ |
| 118.6743, |
| 43.2642 |
| ], |
| 'childNum': 10 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ɲŁĢljĊwƾōÞĭ°_ŎŃźȹƒUČÿl»¯ôķVÿǬƽɅġÅÑǫ»̐ʟȣU¯wVWÝÈġW»Þ¹m݃ɛŎÿŎōͩůV¹ōéċóŹÅVVĢǩʈ@Ėċ@ķÛV°¯xÇÅţ¥»°Ûôĉʟ¥WýČ¥wç»±mnÅķ¥ˋVbUÒġ»ÅxğLƧbWĖÅx¦U°ÝVóŰlô²@¥ÜÞÛôV@²±`¦¯Ý@ÅVÒō¼ô¤V²ŹĬÇĊƑţxç¯Lk»ʟlƽýmłÝÆƏ@mö°Ġ@ŚŹĬţÆUĀĠNJĠX¼nźVUÒ¦Ċxȼ@ôlx¯łʊÒÜĀˌÇČxÆČÈƐaxÒĠn¼ŎVȼĢ°ŤmǖČĊþLV°ÞU¼ċÈUÆzÈa¤ôbknXĀè'], |
| 'encodeOffsets': [[ |
| 122232, |
| 46328 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '1508', |
| 'properties': { |
| 'name': '巴彦淖尔市', |
| 'cp': [ |
| 107.5562, |
| 41.3196 |
| ], |
| 'childNum': 7 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@²@Ζǀݴʶհĸƒ¦Ķ̒Uˌ¼ӾÇƾ¼̨UÞĉƧéÝ»ĕĉƐȍōǪakóó¯a@ôţaV¯Þ¯°@²él¥ĵğťwōxó¯k±Vó@aóbUÇyĉzmkaóU@laóķIX°±Uĵ¼Æ¯VÇÞƽIÇÜÅ£ɱġwkÑķKWŋÇķaķçV@£mÛlÝğ¯Ñťóǿƴȯ°Åł@ÞŻĀˡ±ÅU¯°ɅĀźƧʬmǠƐ'], |
| 'encodeOffsets': [[ |
| 107764, |
| 42750 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '1505', |
| 'properties': { |
| 'name': '通辽市', |
| 'cp': [ |
| 121.4758, |
| 43.9673 |
| ], |
| 'childNum': 8 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ôƲĸ¼Æè@ÈȮwƾ»ʠĢ¥VÆ@²¥@»ŎѯĊJŤ£k»ÆÇX¯̼ōī°aX£ôƾȁź¥aôŤĢL°ĸ@Ȯ¼ÈÒʈŚôVXůÆaĠƛÈKķĉôÿ@ğÈĉ»ÇVnĉVwXĠÝ°ČÿĸwV¯¯ǵ±ĉǫÅÅm»²Ż±ƽIm¥ţÈķ@¯ƧJV»ÞUÝç¯UġºU£ţóaÅÅlƧī¯K¯ÞÝğL̑ȍƽ@ōŎōĀƑɜnÞݺX¼ÇĢÞUX°xVʠȤ̏Ǭ¼ÆÒɆĢǫƾUĀóĸ°k¼ċĀƑVŹȺōń¯`ÝĮƽŎĉxġNJɱłō¦'], |
| 'encodeOffsets': [[ |
| 122097, |
| 46379 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '1509', |
| 'properties': { |
| 'name': '乌兰察布市', |
| 'cp': [ |
| 112.5769, |
| 41.77 |
| ], |
| 'childNum': 11 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ʠǠÞĸɲȺƒÒȂƛŎaÆÈĕȘţUÝźǟɆţÝˌKU»@U¯ÜÑ@Þ»ôaVÞÇÈ@¯ÜbƨƨÞlĸ@ĊôlôÅĊUÝĸm¦bmĊ@nĊxŤÑ@¯ƨĖĊ_@Čwl¯ȭLÝ»ƽ¯ķůǓ@ÇǓbċÅÅÆwÿĠÇU£óa¥¯aŎğĠţkw°»¯ůlÝĵkǻݰɱƧǫaóôɱ»Çk¯ŃóʇŐŻĉNJŻĢ¯ÒÈUl°x°nÒĬónĊğ°ÇŚĉ¦ʵV°°ĬÛżÇJȁńʇʹó˂ƽŎÆţ¦'], |
| 'encodeOffsets': [[ |
| 112984, |
| 43763 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '1522', |
| 'properties': { |
| 'name': '兴安盟', |
| 'cp': [ |
| 121.3879, |
| 46.1426 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ÆXnlŎ°@LVLĠþxĊUȮĊnUĠV@żaW¯XIŎġ¥Ý@K@w@K@I˺ŻŎ¦ƨƨÒŎIÆ@X@VºnX°lŎ@ƾĉˤƒȘǷȘÑÝÝÞbVţĸÿŤxÈĖƐêÇKnĸ¥ô@ķÞUnÒl@UÅaīˋ¯ÑƧx@±kXřƐƏÛéVˋ»lō¯ĉÅÇÓǫÞĖġV@ğ»°ĵÇÞǓ¼¯mÛÅŃĉĠÇƾb²çéż¯VğÞml»ōÑVç»V¯¯ĕÆU¯y°k¯¯V»ôÇÑ°a@ŹkġKţóbŹ¦ƽȂóW¤¯bĬ̻ŎW°ÅÈl¼ţ¤ĉI°ōÒ@¼±¦Å@Uġ¦ʟƽ¼ÞĢÒm¤êō°¦Èþlk¼ĊŰ°JĢńȁĬ°żnÇbVݼ@¼óĸţ¤@°Ånl'], |
| 'encodeOffsets': [[ |
| 122412, |
| 48482 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '1502', |
| 'properties': { |
| 'name': '包头市', |
| 'cp': [ |
| 110.3467, |
| 41.4899 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@źxżĀǔÆǬVȘĀŤ¥ÅƾōôˁʈͳȂŃÈIÜŻ¯ī¯ōm¯ɱĖ¯ķÒÝIÝ»ÅVlÅôÑġğVmÞnnWçkWÜXƝÆwU»Șĕ£ĉÑğ±±ÅkK@lÅIōÒUWIǼ¯@mka²l¯ǫnǫ±¯zkÝVķUôl²ô°ŎwŦxĶĠk¦±ê¯@Ý°U°bóŤ@°bôlôǩbŎƏȎĊĖÞ¼êƨÝĊ'], |
| 'encodeOffsets': [[ |
| 112017, |
| 43465 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '1501', |
| 'properties': { |
| 'name': '呼和浩特市', |
| 'cp': [ |
| 111.4124, |
| 40.4901 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ʶUĊ¥ÈřĠ¯ĉômīѯmwk¯ÇV°ÑżġĊljǓɱţǓƝóX¯ɛÒóa@nÝÆôƜŚĉĢʉŰĊÒ¤ȗĖV¼ÅxWƞÛlXXèmÝmUnĠĢóÒkÆÆUÞ¼ÞJĸÑ°ɲĕ°Ŏn'], |
| 'encodeOffsets': [[ |
| 114098, |
| 42312 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '1503', |
| 'properties': { |
| 'name': '乌海市', |
| 'cp': [ |
| 106.886, |
| 39.4739 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Ș°ÇīXŃŗ@ȍlkƒlUŁ±īĵKō¼VÇôXĸ¯@ťê°źk¤x@Ĭ'], |
| 'encodeOffsets': [[ |
| 109317, |
| 40799 |
| ]] |
| } |
| } |
| ], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/util/mapData/geoJson/ning_xia_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [ |
| { |
| 'type': 'Feature', |
| 'id': '6403', |
| 'properties': { |
| 'name': '吴忠市', |
| 'cp': [ |
| 106.853, |
| 37.3755 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@nLV@VLaÞbn@@l@bUVlUVzVx¤kÞVèXn@nm°a@UÑ@VXnV@VaUVKUUU@@U@@KVa@U²@wXkWnk±lLnU@UmmVKnIVWnI@UK@UK@@UVKXkmWLWUXmlkVwUyVa@ww@aVIK@aVÈwKlLVV@LnVVVnUܲ°WÈIUÆ@nÞ¼@¦@UÞUVW@UxUxVnbKb¯ÞU`VbǬV@XXÆVVl°InmnUô°¯anam£WVXKXmkôaVU@Vak@@wman@K@UÛUWKXUÇ@UIb@alW@akLUKV@@Ukw±InL@kmwkWmk@JUIůVmnnU@m@UKVKlkUwknVUKmbkI±KkmVkKb@U@aVkUmn`kIlaUK@UUKmbUIÝUa@mUa@am@UUULUK@bmKkbWI@WXwlkXWa@k@kKLVkkK@L@JUVmzUKlwUUnW£XVlKUwVU@aXI@aWaUw@W@_nam@¯UkWVkUWaU@nwmJkUVkWVUmUkJ@ImbUa@@WÅ_mJknmak@@mXaUV@xU@@VUnkV@Vn@`ULUbWLXVW@kbUJ@XW`@nÅĖWJ@m°@xxbnUaw²lÞ°xŤIVVULÛWbbkVVXÆ`UbVL@kx°LlV@VWbJn@bl¤ULV°@lmL@£U@@aUwmKULVxUVVx@@kU@mK¯LÇa¯@'], |
| 'encodeOffsets': [[ |
| 108124, |
| 38605 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6405', |
| 'properties': { |
| 'name': '中卫市', |
| 'cp': [ |
| 105.4028, |
| 36.9525 |
| ], |
| 'childNum': 3 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@°@Èb°KnL@lV@@UwVUUwVKnLVx@bV@¤@nK@k¯UVKk£@amIXa@UkU¯Klw@UKVaÅ_UWlUaXaÜVKUUţJ¯wݱkxVbmaw@wn¯@XIÆĕm@X_@WVIlaX@WUXKVaVK@_Um@lUVm@U@Vw@VUÛwm@@W@ImKUkU@UaaX@wWaUKkw@UVaUamLUnk@»±`¯@kW@UaykbI@VWJkLWUkJwU@n¤mL¯wm@Um²XVWbnV@bmxVkxUblLUV@kVWKU¼kU@mn@JnV@bUnmJUn@k@XlxLVVnKlLVV@@LkKULVbk`WL@lkXW@kV@UÞUlÇXlkaUbmV¯@@L@V@bkb@xlWbbW@±@UJ@IU@mVkVxV@@lIlln@Vm@VUbl@JLmKÛXmVkUKULU`@LĉwKUXlVUl@VbJX¦̼bÞxŎxɜĖĠŎaô@'], |
| 'encodeOffsets': [[ |
| 108124, |
| 38605 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6404', |
| 'properties': { |
| 'name': '固原市', |
| 'cp': [ |
| 106.1389, |
| 35.9363 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@Vnn@°xnK£mV@xlIXVlKXI@UJlazVbX@l°@²_@¼mlVnKVbUb@VlxVLXb@xWbVbV@VlnL@J@Xn@ÜxbW@nl@nblmnIÆ`@X@Vbna@aVUUWVk@kbWakbU@VwW@_l@nmn@@alVlk@UkmVak@@aUXaL@¯@KVa@axWI@KnkVaVJn_lJ@X@m@nVanUVb@mXLlJVWnLlaVVaVX@KXVVkVKlknKVa@aVU@KXb@klJUknUm@K@_UW@alIUamaU¯kJma@IUK@U@@UW@@aXLVVJVaXIKlaUkUV@ambUUJkIWJ@wUIV@JU@UwV@@Um@nU`@UkUmVUxWUUV@aÅb@aWXkKUUUUaWK@wnm@IVU@aXwm@UmVaUalk@anKUwlUwlkK@wmaUkmmIk@VmkUUbW@UVUnW@kV@xkVmbVnU@UbUV@ak@kkW@kLW¤@nV@VU@W_UVUU`VLUV@IUVõVULU@UUUJ@wmkUJ@WI@l@bkKkbVVbVbUL@UUJ@Vm@@L@xbVVVLVlVwX@Vb@bmUkbk@@JWIUVÅw@Km@UkWKXxWLÅ@UVUnWK@xkVW@KULwWVXVWzXVVKVXkVV@VUbV@UVV@@LXxVL@VbLnKVLVxXVmb@l'], |
| ['@@@J@aU@LWK¯UUxVVn@ĠLUW@UbUUUa@KUX'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| 108023, |
| 37052 |
| ]], |
| [[ |
| 108541, |
| 36299 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6401', |
| 'properties': { |
| 'name': '银川市', |
| 'cp': [ |
| 106.3586, |
| 38.1775 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@UwVK@UVWÞUbwV@knV@@KU_VK@Kn@W_XWlL@Vn@Ċw@Ula@Wanamī@a»ŋó@aÆÅɲÿUaV_°ÝaLaUmVwVwX@VUVÝ@@¥Ý»@mVÅÇJ¯XÛ±VUmUmU@KUUkKLÇxU@bLUJ@bx@xUbVzUxklWnXVKnXWlUL@V@VL@VL@mJUXmJULnn@VmVkK²mlXWlx±@@VUb@L@@VV@VVULVUbU@WmU@Ò@V¯bmn@V@lVnUnVWXVl@¦VVUn@x@XL@¦lXxVb'], |
| 'encodeOffsets': [[ |
| 108563, |
| 39803 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6402', |
| 'properties': { |
| 'name': '石嘴山市', |
| 'cp': [ |
| 106.4795, |
| 39.0015 |
| ], |
| 'childNum': 2 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@U¯ķó±ÇÛ¯ķmbXb@kb@Vĉxm@@UkKWXX`m@@LULV`@L@mU@lUxaÝVUX@VULxVkLWV@JnVLXVlUV@zlVL@V@bn@lU²WVLlLVbUVxUx@xǀLxôÒkK²VaU@wXa@WÈĉUa@bÈkm@¯'], |
| 'encodeOffsets': [[ |
| 109542, |
| 39938 |
| ]] |
| } |
| } |
| ], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/util/mapData/geoJson/qing_hai_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [ |
| { |
| 'type': 'Feature', |
| 'id': '6328', |
| 'properties': { |
| 'name': '海西蒙古族藏族自治州', |
| 'cp': [ |
| 94.9768, |
| 37.1118 |
| ], |
| 'childNum': 7 |
| }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@V£°@laXô±źwô@UlżaÜnKw@Uaa²LmÈLÆÈxlaUawÞmÜbÞUnJ°akôÑkwÝVğwÇ@ÝkkV¯¥@ò»nŤ¥XImw@mVwa@ÅwmLkaWw¥l»kçó»@WÑĉğ@ĉŃUwóřVómĵ»Ý@VǕ¯kÝĊÅk°ÓUklkU±IÇÞk±@ƽJ@UġIk@W¦VÑșÓÅnťKULn¯X@¯mUÛ@WÅmóKknōbxÝ@U@kw@ÿÇLţÝUkmwklċVÅU¦LkUWlÅÑ@a@ÅѱUóġŹ¼ÈĉmŻ@@wkwKl¯Uġ@lÇUÓ¯_Waĉ²Åló¼VbknKÇÅ@ƧĢō°Ý@ğWÅxUUm@ÝXÛWULUè¯@mbUaLbUWġxIUJWza¯by@ōÈóLU`ÇXUlUĉV¯nmÛbǕLklUĉVóaġƏbġKţnkbÝmmnÝWȭÈÝXţWókUÇl¯U¯ġUɅĀ@°¯¯VÆnmJ@ĊķnóJUbÝXUlVkL@lVxnnmb@¤Vz`ÞÞŤ@VnÆJV°bUôJkzlkl@²ó@ÆÇ°kĖÇbÛU@lmbXVkzVɅĀXˢlńĬŹ@éÅ@ĉńÆ°ğbUlɜ_°@xŦkbVbƒKĢŤVŎ°@żÈźlĊôKôb@nôxŦÆ@ôŎL@þÆb@nnWˌbÈxInaŎxlU@Ѳ±ğVUĢƨbɲ@Þ¥ôUUķWVô¯ĊWʶnôaŤˁ@£nmnIôǪK°xUXô@Ŧa°mkXÆÞVŎkĊ°ÞLÈôyVaIlwX°UVwĢÑÜKôw@nV@m°nmnÜɞ£VbmXn°ÜÒ@xx@Vb²UlbkxVnJUnVVĊ°KČm°nxÇnn¤±¦@UXVV@lVbmVVÈVxÒ°IbźaČbVw@VLƾÑ@Ŧô¯ĊkôÑ'], |
| ['@@@@nòVaw²bVxxÜaČVô_ĊJIVmLa°@Ŏ¥XlK@klKVbUb@nUĢnaÈ@lmǬ»Ġ¯nmnƨVyÑǖĠ»ɲIn@@ÅĢƳ@¯°ôVKÈbVIÇ¥¯@Ýó@ÑnīWKkk@¥¯ÅaX±VÅw@±Ġ¯@»nWmw@@¯VUUWçKĉa±VkkV¯wx@UJx@bknÇbmÅ@Uw±U¯¦UKm¯I¯ť¼ğĊ@ÇŹÈ¯@Ý»ÇnˡJbÛèÇnÅK¯ġĠŹW¼Ålm@¤n²Ýb@b¯l¯@ŤW¼nV@x°@Vx@lbUblbX¼WDzlU@¼V¦@bÇlVxUbVxÞbVbm¦VV'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| 100452, |
| 39719 |
| ]], |
| [[ |
| 91980, |
| 35742 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6327', |
| 'properties': { |
| 'name': '玉树藏族自治州', |
| 'cp': [ |
| 93.5925, |
| 33.9368 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ɆÿĢV°°VÈklVôŤXÞWȮÇÞXnmÞnlaŤmĢLƐaĢôbĊUVlkǖKÜan°mĊUVVkÈWV_ôKŎÇ@z°abXyVIJĢwVXaKVbna°@VçVKXÜÞWn@VVÆwXĠÞ@Ŏ¯ƨġÆ@ÈLlmUaô»ÆkĊ±Xb°`ÔVkÈĢ@Vk°Llx@xż@ĊnÇź»ôĢ²VÆÒ@@bÆÒXklVKV¥ÆČUklnxlç¥ċç@±m¥wÅJ@VmÈIléÈa°U¥@kÞVK²ÑW°w²ÑK²ñyÆÝVmw»kkWĉJWUVÅwLmÅ@@mwkn¥VÑ»°°@@»¯LlaJônVUůU@W¯Umѯ¯k@WykU@¯wV¥kVwţk»wWÇĉĶçKÞÇaĉbIlU@kwWXU°w±@UKn£WĉKWxkĕVamwXw@Wmnk@aVkbĉLlImmwUÇWxnÝJn@¥ÆkwaXÜĉ¯ÅV¯¤mkx¯kķܲVWôŹVU@V£¥@°wn@m@¯@UbUôķmn@ÆÛ@ÇýVaUÇĊV@Çlğ¯xÝŤlVÈÈVx¤VxkK@@x@kVĖġ¥kIWbXŎx@nxÅUW`_@±UaLUxK¯WbkVlbbmLÛÆWIUwWkwÝV@kIéUbUUkV¯Km¯k@Umݯm¯mLÞĉÛUmġ£UxkKm°Lwk@kVmKVUk@¯a¯ĢmóKUUxImlÅnÇbXèVVU°@@xXnm@¼ğ°@²ÆxU²WÆb°@¦llXLmĬ@ÒÞô°@ȦUJÇaLóU¯@°ġƴ@Æ@mɱJğ¼ǕÒUzƧmnmğ°ǫ¼knÇ@bġmmV@VaUaLkl@kLWō¦¯@bKUnJĉIó`ċUÛbwUw±axbñUm@@babÇÅXmƒÝÅôVbÞblUÞVÞU°VUx@UV@l`¼nL@ĊLW¤kXķWġXUVVVķUbVb@°kVVxÈa@ȦĊbaźJU@ÈVl@XkôaWĢÞ@laĸUÆb²mÞLĠÞÑôbÒĊaJVbm¦'], |
| 'encodeOffsets': [[ |
| 93285, |
| 37030 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6326', |
| 'properties': { |
| 'name': '果洛藏族自治州', |
| 'cp': [ |
| 99.3823, |
| 34.0466 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ÞVŤÈK@ĀlxV@Þ@wŎalmôLnXÆÜ@nV°@°WmVKŦLÆmȚÔÒUX¥l@ĢJV@ƾI@wW°Ån¥kÅÝVwôÈç@lÑĊĕaJnaÆLVw°kny°UnkÆVČĊll¦Vƾ@@nUźÈÇIn°XwÞKô¦VWV£@£°ókċ±Iam¯Va»ČĉV¥°@mk¥l@Ċm@aUmwX@wÆxmĢ_`VnÆbKVw@@nUVğVmVVöIll@@çÛm£UÇw°@VU¯»m¯JōĖÅLa@»ĉĢ±`U_k`ÇçókXlK@akÝÞ£WċkÝkxJݯÅwxķxmIÅx@k±J@ýŋ¤UkmV°ÅÝxkwmġnÝVU¦ŤlmóXk¤UKç@mVkK@klī£m¯VUbW¯¼ċb¯ĵam¼mVXm@k¤ÇXÇbU¯J¯¯È@bVXVÒ¤V¼kxÝV@lVWxÛ¦W¯mKnlkU@nƑUĉÝ@ǺÛċUĉ¥UÞÅz±òL±Ò¯xX±ÒLÝU@lV¦¯ÇbkêÇJnU@ÆIxn¦@²Čè¦è'], |
| 'encodeOffsets': [[ |
| 99709, |
| 36130 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6325', |
| 'properties': { |
| 'name': '海南藏族自治州', |
| 'cp': [ |
| 100.3711, |
| 35.9418 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Vxń@ĊĠĊXÒ°UƾĕÞm°£nb@@LUUWÛº@nlÆǬĠ£ÞV°UXbVȂǵé@kWanm°@xzK°¯ĠVVkwLnm°kÞxÆa¥@wnĉÆ@_l_VwmĸèŤÅČU@Wn@ÑmKUnğK@°¯UÿV£nmLlUUÛé±óókkmnakV@Ç°óÝXWəÞťIţxmmVÛUVȂÓnWyȁĉkV°WnkĊa¥_K°ÿWna@mU¯wlÝIU¤UXó¥ÝLx¯WmJÇÈŹmV@ƽ@Uk¥ĉkċÅUml¯Vmz¯lUxÅKmbIbĉĖkÒ@ÇèóUxÆÞlm¦Æ¯X@x@²ÝlÈJV²klVl¯ÔlĉÆÞ°lUǖÞ@Ķ¼nUôôŚ'], |
| 'encodeOffsets': [[ |
| 101712, |
| 37632 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6322', |
| 'properties': { |
| 'name': '海北藏族自治州', |
| 'cp': [ |
| 100.3711, |
| 37.9138 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ōmġxƽUm±LǿþġÔ@kxmWb¯I¯mIUx@bbŹVÇkĵblĉI¯¥Um@ƯÈ@aóUlČ»@w»wXaó°ţçÝkUaV¥ÅbÝw¯lmnKlxUğU¯°Lyw¯@mnXbl@êȁǶUWa¯VÝUğ¤ǫkÅ@mܹXVV@K@ma¯¤ÝnƽĖ¯V@¼ôlèk¼¦xXlbnKÆx@bUx@nnxWJţ¦m¼ñ@°¦lUÞlÈ@ĠxÞUlxÒól¯bmIÝVÛaÝnxVbkbÇwÅÇKn±Kbb@VxLmÛŻbkVó@Źxó²Wkb@¯U¤źĊ@lUX°lÆôUlLXaV°wxUb°xÜôÈKVkÈmlwkÈKwKVUŤĉŎ»»Il¥na°LV»²¯Üy@wĢ°ĸwlwĢw°±_lVk@°bƯz@l_@Ģ±lÅVlUaÞLVnKlnÈ°IllČawÞÑ°xUU@wVkmĠLô»KÞýôaÞ¥ôĀÞmÆmUŎV¥Èl°²°a²¥V@@wamm@Ñn@Æ£żVĠ£@W¯Þl@»@Uk@'], |
| 'encodeOffsets': [[ |
| 105087, |
| 37992 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6323', |
| 'properties': { |
| 'name': '黄南藏族自治州', |
| 'cp': [ |
| 101.5686, |
| 35.1178 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ôl²ôÜêVVkKmnU¤VĀ¯°@LmĠVnLÈL@alb@al@n°V_XmWUÈamaVIn@naV£óVWU£°axÈ¥@aĊwȹ@óağbm@kw@maÆw@In¯mm@UkkWÑÅ@@kċÅçVkÝJÅkVykŹl¥@¯ĢUÜX¥òýmmXÝÅlmU@£WlyXW»Åbl@aI»k@klm@UxUUV¼¯XlaUnķI@x@¯KĉUU`ólČ¯ô@¤ÞJk°xVn@mbX¯ĀL`¦ĉbml¯XUlȂĊXzmȁÔUÜVUnnŤwŦJɚÝXÞW¯ô@ÈlUbmln'], |
| 'encodeOffsets': [[ |
| 103984, |
| 36344 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6321', |
| 'properties': { |
| 'name': '海东地区', |
| 'cp': [ |
| 102.3706, |
| 36.2988 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@Òb¤ÆI°ôU¼°UnnWx@b¯L@lUUWbXxWlƨnxVUllXVUnL@lȀý²KVnƾĢwV»@mÞ£nÆÞÑmLKUaVżĕWVk²ÆÝ@Xw°@ô@a°wóUUmIkaVmÞwmkny¹VÿƧnÅm£X»naV±Ýw@ab@am¯ĉVó¦kÝWKUU@WanUb@ôǺĉxb@Ǧw¯bV¤UXôU¤bmm@UJnbÇbXVWn`¯Umk@@bka@bÇK'], |
| 'encodeOffsets': [[ |
| 104108, |
| 37030 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6301', |
| 'properties': { |
| 'name': '西宁市', |
| 'cp': [ |
| 101.4038, |
| 36.8207 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@kmKVUWkVkUmwƧXkWwXaVV@k°K@aXwmmV¯V»¯óÅJ£amX@ċVţÆķçnUx`k`@ÅmĊx@¦U¦blVÞŤèô¯Wbx¼@xċ¼kVôbÇ@Å°@nV°¦ĊJkĶalÈźUa@aVwnJ°°JanXlw@ĢÓ'], |
| 'encodeOffsets': [[ |
| 104356, |
| 38042 |
| ]] |
| } |
| } |
| ], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/util/mapData/geoJson/shang_hai_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [ |
| { |
| 'type': 'Feature', |
| 'id': '310230', |
| 'properties': { |
| 'name': '崇明县', |
| 'cp': [ |
| 121.5637, |
| 31.5383 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@uŏu»GPIV±ÐɃŜ{\\qJmC[W\\t¾ÕjÕpnñÂ|ěÔe`² nZzZ~V|B^IpUbU{bs\\a\\OvQKªsMň£RAhQĤlA`GĂA@ĥWĝO'], |
| 'encodeOffsets': [[ |
| 124908, |
| 32105 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '310119', |
| 'properties': { |
| 'name': '南汇区', |
| 'cp': [ |
| 121.8755, |
| 30.954 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@`yĉNǕDwǏ»ÖLxCdJ`HB@LBTD@CPFXANC@@PGBKNECCBB@EBFHEDDDSNKAUNBDMNqf[HcDCCcF
@EFGLEBa@ACoCCDDD@LGHD@DJFBBJED@BGAEGGFKIGDBDLBAD@FHBEF@RFDMLE@SGANFFJBANPH@@E@FJjRIACDMDOEKLFD@DbDAJI@AP@BGHFBCBGDCC@DCA@CECGH@FKCEHFJGBFDIHACEDNJDCVFBDCRKRLDLITB@CjNJI^DBCfNVDHDFKHAFGDIICDWBIF@@CFAjFJNJBBHD@CJ@AEFJ@@DH@BFBCPDBMFEQGDIFCNDHIP@HDABFACBJFHEBSZC@DP@@JDBƤ~'], |
| 'encodeOffsets': [[ |
| 124854, |
| 31907 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '310120', |
| 'properties': { |
| 'name': '奉贤区', |
| 'cp': [ |
| 121.5747, |
| 30.8475 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@~T~JjZdDbLXDLCB_J@@FHFZJJIAGH@HGR@BENBLID@@LFCDF\\FpDBDb@FAHKFE@dEDDdC\\GreNMACVMLBTMCCFCEGFAA@DAFDLMHA@OD@BMEWDOC@AS@KGAI_DcKwÕísƝåĆctKbMBQ@EGEBEJ@@MBKL@BJB@FIBGKE@ABG@@FMFCPL@AjCD@ZOFCJIDICIlKJHNGJALH@@FPDCTJDGDBNCn'], |
| 'encodeOffsets': [[ |
| 124274, |
| 31722 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '310115', |
| 'properties': { |
| 'name': '浦东新区', |
| 'cp': [ |
| 121.6928, |
| 31.2561 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@EN@JJLNHjLJNR^GRYVBNZJRBV@PDvbLNDN@LGNER@nCNQNuT_TIVFV\\Z\\XnDrI|[Ʉś²ÏJUHOƣ}CA@IO@@CYDATGFIEDAEBBAGCO@GJMCEDCJRHEFANOCADAEG@@CI@FE@BDIC@AGIAIMiEEB@DE@AJCXJDCJEHGBELGCUCeMAD]CIJiM@DSAKJKCLQDQACUECDMIFCBDJGECHAEIWCK@GLMCCGEACNKCEJG@MMBMC@@CIJUINT@JAJSTEPZZCP'], |
| 'encodeOffsets': [[ |
| 124383, |
| 31915 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '310116', |
| 'properties': { |
| 'name': '金山区', |
| 'cp': [ |
| 121.2657, |
| 30.8112 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@L@BIHFN@@EE@@EFBDGDAADVDD@@EF@CA@IIsRE@GDAF@BF@CV@|FBCHBLCNHAFCADBMDCFZXHILBVEEQA@MWFARJJ@DCX@@TEFBLHAAERE@AJABRPBNK\\BrJ\\VHGND@CNADKDADQjGAGNC@GJ@FCFFHC@JF@@dLBDSFADHVG\\DTEPDDHJALIJkJDJCDIPE@YDCBiK@DONE@EH@BAF@HLJA@EIA@ALKNA@@FIFAFHR@NALadsæąyQY@A±DʼnXUVI^BF@FFF@HBJEDFFGFEBSRkVEXGHFBMFIVW@GAEEFOIAIPKABGWEKFSCQLQBSEIBC\\FdBLRR@JGACFDDEF@AWB@LJJYNABBA@CUEGPaO_AIE@MYMFIGAEFECHSAAKAO\\[JEDB@E@MMA@@AGBKMGDFFCDDFEDFJF@NPBAFLHFH@EDDHBADDC@DDCDHHCDDFDABDAD@FEFOBCJ[D@HEDDNJBDDHABJIBBvGLBJAH'], |
| 'encodeOffsets': [[ |
| 123901, |
| 31695 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '310118', |
| 'properties': { |
| 'name': '青浦区', |
| 'cp': [ |
| 121.1751, |
| 31.1909 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@RUNKdOFDJCbRFMLAHPLDN@JGL@@APBWYCKN@TU@SHGCEJIDIJKVIZVNM`iNY@CIE@CA@KBOEGEUFCCSADEIEFCDDDIDDHC@CKIeDCG@IG@DHWFEEGCH@@GO@@O]CNpeEQDBFME[JC]DGF@CKOA@QSB@GB@@GW@@ED@AQIJIAAFE@@DO@CFI@KNG@CDACAFEGKGBEGBDCCAIFCCLIECFI@MBCLDHGNAHSF@DMB@EEKBA@@C]DEICFG@ADBHGFKCDAKKHKD@@FHGAANGEEFCHKCECBCKG@ADKCNE\\[A[I@@mGBDQQEO@BCE@AI[AML@JGACLOAFKEMM@EQKC@CUCBCCBCHEA@FF@@FM@GEAJK@GNF@EXPH@FD@M^@HIADJCFDBER@DK@@DE@CAKFOCCBDHIBCNSB@GFC@GQEEOWFICGDUAEJIDBTAHJHEB@DIF@NE@H|HBDBEH@DKBAHEF@HEEUB@FGFGCCCE@AHOB@NH@PRLVNNFBX@RCPbAvMtBfH@DJF@ELBFA@EH@HNED@FFB@HLC@CJ@@DJ@PIRf@HE@CFF@GPHD@DKE@FFBEFFD@DEFCA@DD@IjCRFBAHFDKD@HF@@PM@H@BlbDJDBFEF@DLXB@HCD@@IFCBIFEJD@FDC@FBALLF@PAACJERACAJCBD@EL@JD'], |
| 'encodeOffsets': [[ |
| 124061, |
| 32028 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '310117', |
| 'properties': { |
| 'name': '松江区', |
| 'cp': [ |
| 121.1984, |
| 31.0268 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@DLDFRN@FNELPBDKHB@INK\\BBJF@ADP@RFCRHA@nJ@B\\[\\MFLDBCH@DLDADFGLEDFFMHBBGH@EC@GLLLCBLDHEAGBCH@DEFJ^C@DB@LAFFA@CNE@GTMBGHKCAD@NEJFDKJDDJEDBCDHAAFLHFHBEBDDCH@LMJ@DEP@@CF@BEJBJIBRC@@FX@@HA@@HTA@RPBDLE@CHD^\\INFAERCfFMo^D@PP@@HG@HDFFXECGH@@JDHfCLJ@DGDCCCJCCEDJFCFTBDDVEHFPFLAB@NBFCFKFC@CHIACNOHWHCAAFIDD@CDAGEI@ACFMF@R@R_@GQED@EGFEQEDE_IAHKAEXCQUOQCUDEN@ZI\\DDmAMHCICDSOC@EG@BKHIGMIBCGOCSF[CUHCGEBCTKA@cE@@IGDEEEDI@@HMDBHiHCRCBCLMB@DMCGH[UqI[AMLOAAQIB@BQFBFGBAKFE@SW@CDI@QIEBNXB@FRUFKAGJYWDENCCADBBEMGKDGAAD{EU@@DAEE@CB@HQFJt@JDBE@@FC@'], |
| 'encodeOffsets': [[ |
| 123933, |
| 31687 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '310114', |
| 'properties': { |
| 'name': '嘉定区', |
| 'cp': [ |
| 121.2437, |
| 31.3625 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@F@LI@IDKJADKIEJICADGACFECCJ@HKCAFOHAJI@aCBEE@ICAEB[GFGCKL@FGEIFADMLCAEJM@ELQECEIG@BE^QKKLQCA@EHBIGQ[GEHOMGGDHKH@JOECFCjCBEFDNCACMBCILGTABDLEEOEIG@GFIMM@CGKFBFCDE@@GEAGEEACIcGaHMFITIHDN[AKF@FS@OA@BK@IHM@KCGOKBENaQIDECcPMLQVFHFB@BFBKLGD@FAJOVGIACQ@A`LPCB@JEF@RU@ANS@@RCL\\HIFpRBFRBBDKLLDADJDGBFDABHBEDNF@DGBBBADKDAHC@\\JJFBDEH[DEFDH\\LX@XLBLbT@DNJLDCEL@VJABJNDHB@HBHYFBAA@GNFB@@AFB@AFABFLFBHFCL@HJBAFBLC@DN@HN'], |
| 'encodeOffsets': [[ |
| 124213, |
| 32254 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '310113', |
| 'properties': { |
| 'name': '宝山区', |
| 'cp': [ |
| 121.4346, |
| 31.4051 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@mÖoÖi½[s[YEUJU`SCIEBCCWJY_LIICDWU@@FaBCJIB[ICH[@@CDKEE@MK@@IMCAEBCH@AMFI@SMGEFGB@FK@BHCAIFJNQD@FEBDFMBKGACG@ECWH@@CDDTOEEBGEK@GC@EE@GPHFR\\JHGA@FDBKRLL]RAFH@FJFDKR@FINBFKDCNEBFJEHK@DLEH\\HFADB@JFFDA@bIJGBEPDBGLI@DDEFBDCHDBIJJFCLIBCL@JKJE@ADHDBHJ@HIBBDFHBBAEIJ@BJFAVL¢'], |
| 'encodeOffsets': [[ |
| 124300, |
| 32302 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '310112', |
| 'properties': { |
| 'name': '闵行区', |
| 'cp': [ |
| 121.4992, |
| 31.0838 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@T@@ELE\\BCMJGJSNEbGdHDJFBJAFIEIFCEWG@@gMENSFCVJFAxR~B@IH@AIiI@GE@FGEAFQPDRiV[\\DFSGMHAXHDOMCJCDETBBNVJJI@DD@ANNNH@FILDDMFBDHNDHKL@XDFGLD@EHGFD@DDB@CDDHCDAEAHG@ABOJ@BIaC@CECLKPFNCDCJBiQEIF@@@OGBMIAEEBMTHF@NKEC@QFEGA@EBCKAACHCLJHEFHHB@AFCAIEACIC@HG@KCCDC[ECEED@KC@KJMAAFQ@GHG@BHIJYIGE@EI@A`KDWCaKcCiY}I}S[CYJM@CFDVPRRVWDFLBBG`JCFRFEFFHC@RF@HQ`Q@E@ENBDJ@HFCB@DCCEJBBGDGXMPBDGJ@DEDELEDMA@DJF@DMZ_jMNYUUJILCJIJDFGH@TSVM@DLXZ'], |
| 'encodeOffsets': [[ |
| 124165, |
| 32010 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '310110', |
| 'properties': { |
| 'name': '杨浦区', |
| 'cp': [ |
| 121.528, |
| 31.2966 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@V@CXJDKJZ`XIDDFADJvSRMDM@mFQHM@KCMKMuaOCU@BDAJSX@HKJGD@PNJCJWAGT@R'], |
| 'encodeOffsets': [[ |
| 124402, |
| 32064 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '310107', |
| 'properties': { |
| 'name': '普陀区', |
| 'cp': [ |
| 121.3879, |
| 31.2602 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@F@@FHDL@HFFAPFCSDC@@XGFDH@BDLHNACEFA@ERCIMJEDBAGL@@EHAFENHHJ\\ONQBQCIBC[MKACKI@GGGH@I_G@CW@[DMHCDIBMTDHN@JNHEH@FJFPKFACSBKHDJNABDMDECAFiDEDFDIPG@GLHCNH'], |
| 'encodeOffsets': [[ |
| 124248, |
| 32045 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '310104', |
| 'properties': { |
| 'name': '徐汇区', |
| 'cp': [ |
| 121.4333, |
| 31.1607 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@RADL\\NCPHFfLJaJ@FWLGMGIK@IFMDOYYFOTSBI@IMSAMSACFIDNDCPWGGBHNET[CU\\QjOCERFBEHF@@HjJBJG@@J'], |
| 'encodeOffsets': [[ |
| 124327, |
| 31941 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '310105', |
| 'properties': { |
| 'name': '长宁区', |
| 'cp': [ |
| 121.3852, |
| 31.2115 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@HFFB@HF@DCAELENSJADCNG\\CX@@D`H@JHGHHJ@BINBFUGEDO[MCKQB}AwQEBUIEDMTNF@hH@FXEDFJEJIB'], |
| 'encodeOffsets': [[ |
| 124250, |
| 31987 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '310108', |
| 'properties': { |
| 'name': '闸北区', |
| 'cp': [ |
| 121.4511, |
| 31.2794 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@CSG@BQGODUPWTOBQAAFMECKBGEMFKEOHADDJARMR[PGI@TEJBNG@ADBFND@JL@@NFFCL@D\\@DG\\JJADI'], |
| 'encodeOffsets': [[ |
| 124385, |
| 32068 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '310109', |
| 'properties': { |
| 'name': '虹口区', |
| 'cp': [ |
| 121.4882, |
| 31.2788 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@bA@E@QHSXBDIMI@OHCLI@GTWBIACQAYIOFGCENBBARSPOXCVHPARH@DT'], |
| 'encodeOffsets': [[ |
| 124385, |
| 32068 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '310101', |
| 'properties': { |
| 'name': '黄浦区', |
| 'cp': [ |
| 121.4868, |
| 31.219 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@NEHFLAFDHDPEAMZUHQQ]IMKJG@EPERABHBGRUCCNGV'], |
| 'encodeOffsets': [[ |
| 124379, |
| 31992 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '310103', |
| 'properties': { |
| 'name': '卢湾区', |
| 'cp': [ |
| 121.4758, |
| 31.2074 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VDHQGABAFQFOH@LIiKKHEXI@IbAFZB'], |
| 'encodeOffsets': [[ |
| 124385, |
| 31974 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '310106', |
| 'properties': { |
| 'name': '静安区', |
| 'cp': [ |
| 121.4484, |
| 31.2286 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@DLLB\\NPGLFHUDMYABEeKEVMAAJ'], |
| 'encodeOffsets': [[ |
| 124343, |
| 31979 |
| ]] |
| } |
| } |
| ], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/util/mapData/geoJson/shan_dong_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [ |
| { |
| 'type': 'Feature', |
| 'id': '3706', |
| 'properties': { |
| 'name': '烟台市', |
| 'cp': [ |
| 120.7397, |
| 37.5128 |
| ], |
| 'childNum': 9 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ŤLLllVń²è°xżĢĠÆlÒŤbV¤ĊXnlĢVĊÒÈ°ĊŰÞèL±@џn»VUźċ²»ÆkôVɆkĊŃ²kŤVVwUUVmUa@KkU@mUmmk@UwUkmW@UVIXa@mw@aKULax@Uk@UbWU@yULmK¯@kXVUwm@@JUUknWKUVLUbU@wWykIa@w@mUI@aUVynIWak@@Wbl@@knmK@wnIl°Kna@V¥ğ@ġUķ»¥@UōJX¯¤k@wmI¯k@mwak@@lX@bUJ@VbknWxkLkxlLVlkLmb@bU@bU@VbU`Vb@nL@mbU@VnUVmnU@mm@kIUWVIUKVkkUJUnmL@VmLUaVWaXamU@U@KUUmVUJUVÇwğnm@mXĉV@l¯xnô'], |
| 'encodeOffsets': [[ |
| 122446, |
| 38042 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3713', |
| 'properties': { |
| 'name': '临沂市', |
| 'cp': [ |
| 118.3118, |
| 35.2936 |
| ], |
| 'childNum': 10 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@bXll@zlV@lXXmkbVVlU@Vn@@Vmb@XKVXWJ@XXl@ÈbVLUl`@XXV@VVUxVbUxVb¦@WnXVJ@bnVUzl@°ÆxUKlU@mUUnUlUVWVUnVV@XX°V@Vll@VkaXVl@Ux@bmbXLlKlb@b@bUJn@@b@n°x°K@an@@UlLVKVbXb@bVVnK°LVa@UVa@XwKVxnLU°@naV@UWUkWULmVwÝKUUla@aó_@mK@aUU@WUkwVm@aVI°W@@IUw@a±¯@¥kUVUm@awkw@K@kVKk@maXalI@alLWXblaVLVUV@LnK@l@waXaLlnUlLmV@n°J@_VmnIVym£UKmI@WnIVm@anUVmÇ_kġIÅWUXÇm@U@ݯÅ@@naWIVW@IkK@klKn@naWImk@abkKkLWnWkLWmk_@UaVUKmLUw@mn£WwUmUaóV@UkUm@UKULUwmJUX@WW@XÒzVblJXWXk@UVWKX¤UL@xU@@VUaU@@XmVkLmWkXUyÝLmKXnV@n@lx@bWLnVVn`knULmxUlWLXVb@VK@z¯x¯¼WxKUn@bk@lVVVz'], |
| 'encodeOffsets': [[ |
| 120241, |
| 36119 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3707', |
| 'properties': { |
| 'name': '潍坊市', |
| 'cp': [ |
| 119.0918, |
| 36.524 |
| ], |
| 'childNum': 9 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@l@@UK@@L@bX@@VlL@JLUVnX@`ÜXn`V²mJ@bU@@nb@l°xnnĸVÆ°@Ċ£Þ@lWnÑnkʶJmó°w@kk»V@»¥k@V@kw@wVmaÅmaô£ŎXI@mlnKla@mV_UK@kUkw@alWIU»m@WUIl±UUÅUbkJ@a@wUKUaVIÆmXIWaka@m@Ul£XKVw@UIJUkmJVkU@aWKImV@UxmL@bX`WXU@U`ÇkUak@@°UblXkmLUKmL@VULóVk@@Vlbn@Ub@ċaUJUbIUlVLUVVbVKXVlVXU@mb¯@VmKUwLWx@Ub@VUb¯KmLUU@aWaUaULkK@Vm@@b¯L¯w@ma@m@UUU@U¦lJUXVmkb@nmXVWkbIVxUV@VUbWLXVLW`Ux@nk@Vn@x@VkJ@V`mXk@VxV@lVI@VULVUIV`°bVXXxV@VWVnL@xVUb'], |
| 'encodeOffsets': [[ |
| 121332, |
| 37840 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3702', |
| 'properties': { |
| 'name': '青岛市', |
| 'cp': [ |
| 120.4651, |
| 36.3373 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@nUJXL@blVUnIVlIVJ@UxWLk¤@V@nlbXbWJÅnUJVbVL@x@blIaÆVVVk²VJ@XnV¼JkX@blxlV@VLU`@nkbLkm@nWJōó¤bnÆbUn@xlxU@l@¦@¼Ul¼ĊUnW@nĠmÈxUVIVnUVV@LV@nVWbXbUVbnK@UnKVmVIllUVLUJVXlJ@nnV@nmVUUm@Vna@K@mUaV_UaV@aV@@aanlKUkKklwlKXwlma@UVI@akW@l@bnxl@°nJxl@°£WŎIUÑn»lamô¹Ŏ¥VaUUkmkġWɱIUUŹ`@kk@ĉƨřV¥_Ç@Ĭ¤ÝL¯m¯£ƽóķwUW±ī¯kōaĉĕkğmó°bW@UKkLUaVmz@V@UxVn'], |
| 'encodeOffsets': [[ |
| 122389, |
| 36580 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3717', |
| 'properties': { |
| 'name': '菏泽市', |
| 'cp': [ |
| 115.6201, |
| 35.2057 |
| ], |
| 'childNum': 9 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@¥IVUÈmÞ»@UlU@Un@VW@UVmkk@aVUUKVÝ@UVknK@UV@VVnIV@wnmwmKXaWaXI@UV@Vy²blkVKkamU@kb@Um@VmUkmKmkXKWwkU@Ul@UnK@UVUUmKXwUVLwKU@@Wl@@wUkV¥@@I@W@_V@VWUw@UUa@aaWa@@_mKUwl¯amzmV@WKnU@kWLķaUKbÝVmV@UWÇbÛ@X°UbW@XmVlk²UJUbmLÇxÅWUzl¯Ll@VkKXUbWJ@bU@¯@kbLmKka@l_WXºVbUz@Jn²V@¤lXnV°Ln`WbXLôVlKVUxXnlXLlU@bVV@XJWLUVnVV@@nl°nnVKÈbVXÆJU°VnXVkV@@xVL@Wlb'], |
| 'encodeOffsets': [[ |
| 118654, |
| 36726 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3708', |
| 'properties': { |
| 'name': '济宁市', |
| 'cp': [ |
| 116.8286, |
| 35.3375 |
| ], |
| 'childNum': 11 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@nam_nKlVLXaIl`_@KVVXI@m@w@@k@Knô@n`VbV@@LL@KVVn@VX@VLJl@VUUU@Uam@UkwKWaXamkJmIUVUÈblaUnV@kVKl@@lXL°kVJ@VÈnVJUX@VLXl@xVLnU@VKV@aIUaV@bĊUxKkVJXUlVUVaI@WUI@KlUnwmWk@WXIWUL@Wna@Um@@UVkUUlanWW@kkU@ykWkaWVUlÝbUU@kJUIU@@JmaókLKÇUUkKWLk@WbkUUabmKn¯°¥V@XwV@VanaVaU_@Wlk@WÈ@VUÈVVÛmaklKȯlLVUX@lK@aX@@kV@VmV@VwnJV_UWUwXam@kW@wVUkKVIUUVmU@UV@IVK@aUL@aV@LmUKmx@ômLkUWJ@nXmlUxUL@VknVUU@VL`Ub±LkV@kUKÇbÛ@UWó_mJ@Wk@@X@VLxUKVWxLVnUV@VmL@Vk@VlVXxWLnlLnVlUnn@@VlaV@nlbULkl±aUzU@@VWJXbWbnLnxm@xUmJUUU@@VmLUl@VUÞVLUV@bllUn@VUXm@@VkV@VݼÇnUVJ@¦nnlnVlL@Þb°KVV'], |
| 'encodeOffsets': [[ |
| 118834, |
| 36844 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3714', |
| 'properties': { |
| 'name': '德州市', |
| 'cp': [ |
| 116.6858, |
| 37.2107 |
| ], |
| 'childNum': 11 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@¤@VmbVXnVVbVJX@ll@zlVInl@@bVxUbĠl@ÈblaIxXVWb@L@nULWVXXWWLnL@`@LUVVL@lVnJU@UUkanVôôb°¼VÞXIÜbČabôWXÞWÈzÆmnLVJ°ÈnlV²lbnW@@UUVmnwmkkKWkla@mVIUKUaaUwmnJU@@amIk@@bVlkX@mmUklUUa@_UaUUV@wwWkXmW@I@WUaÝU@UXaWUU@UUVW@UUUWUn¥nUVa@m@k@alU@wkLWa@UUm@@wnmUwla@anKn_@alK@Ý_@@WUUUmlkaIyU@UwU_Wa¯yU_mWUwkImm@InWWUk@@UVWVkW¯U@VL@b¯b@l±¦@VV@lUbV@kxVnUl¼XV@b@lV@nIWxnb@UULxÅxm¯aUwU@mUÅVÝKULm@bmKUXó@'], |
| 'encodeOffsets': [[ |
| 118542, |
| 37801 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3716', |
| 'properties': { |
| 'name': '滨州市', |
| 'cp': [ |
| 117.8174, |
| 37.4963 |
| ], |
| 'childNum': 7 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Vb@`bVkVlnV@nlWUk@al@nJ@bV@InmVxbVbVLUJ@nkblXlLnlmxnUV@V@mXnlbĸ@nnVxb@lnXV@UJ@nVxxnxVbÆVn¯ƒĕ@@wÈçUÇlķVIb@Çmk@¥k@UkUK@aWakUóJW_UW@wkkWK@U@K@XUUkmUUalKXala@U@kkWlkÈl@kVmVIVmU_awnwVW@wwU@wU£wkJWIyUI±bkVUJ@nmVUklXmx@lnbWkVUkLWxkKUUmUkbJ±LÇxUKmkUmkkWamUaVkJÆ_²KĠ@UW@wU¥nUWwK@aÝUkÅVaVK@akLW¯I@bnbVx¯JWñWbUL@nV@VmbkUUV@IÇak@@bWak@WJUJWL@bXV@@VJlb@zUlUUImnbVmz@°UV@VbV@@V@L@xLmKUnmJVXJ@VkLW@UVUL@b'], |
| 'encodeOffsets': [[ |
| 120083, |
| 38442 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3715', |
| 'properties': { |
| 'name': '聊城市', |
| 'cp': [ |
| 115.9167, |
| 36.4032 |
| ], |
| 'childNum': 8 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ô@VWnLan@VKÞLÆUnVV@xVbn°ÆwwKVV@maXwmJU@@k@aWUk»VUmlw@UVa@kUU@²¥@k°a@aK@UU@mmm@ówѱ¥¯@@wKmwI¥kU¯UmakJmIUaVkKUkm@VUUaU@UaKUK¯@wUVUIUKVwk¥wbV@xn@lWnXxlL@`XlJX¦l°XxW¦@¦Uln@@@Um@@VXVmx@¯bllUnUJ@VULVn@bxVVL@bVlnVVblVÈnVlIVJLôlJ@xl²'], |
| 'encodeOffsets': [[ |
| 118542, |
| 37801 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3705', |
| 'properties': { |
| 'name': '东营市', |
| 'cp': [ |
| 118.7073, |
| 37.5513 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ͬUǪlô@°Uw°ōĠ¯»Ģç»XÇ@wwƑaÇkwVƑ¯@ÅķUmm¯w@ka@mV@@anIU±m_ÛW@_mWVUK@IkK@UW@@a@K@L@Vk@±U@UV@lm@mUU@kLmxV¤@xVx@xUXmxxbV`UnUJnU@lÇkkllX@l@VkbWbkLVbnVVlWV@@L@VXLll@xVXX`ôIlVXb@bVLVll@@¦nlÈ@aUJkĸVÈÇè@x'], |
| 'encodeOffsets': [[ |
| 121005, |
| 39066 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3701', |
| 'properties': { |
| 'name': '济南市', |
| 'cp': [ |
| 117.1582, |
| 36.8701 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@²¦Òôxn@nn@V°VlXUUX@Vl@XVmX@JnnlJVxnXV`°zXbV`VxV@zJlbkVnVV@X@`@ÞkL@bm`mL@bkbxnVm@xn@VV@XbKl@xkV@b@l@nUbmVm¦XVVV@VUXVVV@XVWb@VÞVVb@X@JnXlWXx@xUVV@aVKVUX@lK@UIUWnIVmnLK@w@K@UU@a@UVU@¯nyUmanVJVVk@ykaIU@@WU@aXKIVXIl@Xb@al@Èb@JVUlVna@UmU@VKXaòX°IUwma@aU@UU@wVW@Ñw@aI±`kbUkwUmJ@UkmÇUUkmKknUV@mJUkaWka@KmKkULmyXa¯_@WmImmbLmUkVUbUVJbUkkWJkUlIUmkLlK@knaVmkI@mWaLUKUU@@VmLUVLWK@UUUWUkkVmx@Vl¦'], |
| 'encodeOffsets': [[ |
| 119014, |
| 37041 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3709', |
| 'properties': { |
| 'name': '泰安市', |
| 'cp': [ |
| 117.0264, |
| 36.0516 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@n¼WnxL@x°@¥Uk@nwlUVlXVV@VXLKVUnK@UV@VVLKXb@nlJUnmb@lkLKlVnJklVXIllVaIVUValUnVKannnJ@X°`WbnzKlVnL@LbXlbVlnI@VUU@UmV@U@U¥@VmV@@_Ua@m°@@kmUUm@UVmn@nX@@aanJVUVLmlIVJn@nkVLVa@KVmVLXVVL@@U°bn@VaV@@K@aVkbWaXUVymU@aUImWX@¥UaVwUaVwUUU@WW@k_VUKÇa@nmxkV@LVJ@XJUbVkUWVUIlLwĉVaU@VbJ@bUUL@mVUK@wWkK@UVWUIÇm@UUI¯lWK@kk@UL@lmUVkbÇaUVVnJlInWbXbLxVln@VbV@VUV@kIUK@UWm@UU@LK@KU@Uam_ó@m@L@l@@x@nWJUU@L`k_JWbUKkmLn`mb'], |
| 'encodeOffsets': [[ |
| 118834, |
| 36844 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3710', |
| 'properties': { |
| 'name': '威海市', |
| 'cp': [ |
| 121.9482, |
| 37.1393 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VbUnVVUxĊ¼¼ô@ÞѯWǬLŎUÆW¹UÇō¯ÑÝkţţóġóLł̥Uwm¥kÝmkkKóbÝ@U¦@mb¯LkmJ@xLmn@lk@a@X@lXbmJUzV@bVJ@n@xblJXzxV@VaKVUXLlmVV@In@VxUlW°@nLVK@zXVVal@@VwbVKL@bnx@WbUJ@VnXVlVxl@nnnV@lV@L'], |
| 'encodeOffsets': [[ |
| 124842, |
| 38312 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3711', |
| 'properties': { |
| 'name': '日照市', |
| 'cp': [ |
| 119.2786, |
| 35.5023 |
| ], |
| 'childNum': 3 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@UaVUUKVkJVaVIČb@Vam@ka@Ul@UôVK@UnKVLnKlkWVa@¯l@VbÈlV_V@XWW_@anKVwUmVw@@UnyUVblKVLX@aô¯ó¥mÛĊÿÈ¥Þ¹lUī¯Kĉ¼ʟbÇVUUXmakJUnmV@bUnmJ@XnJVLn¤UzmJUn@`¯ImU@nKVkkmKWbb@xk@mL@KUUVUKkbWaXkK@bkJWbnbl@UL@lL@lxx@bnUVlV@¦²°@bVx@J@¯XUJ@bUnlxVX@VV@bL@nô`@bkbVVÞLxnU'], |
| 'encodeOffsets': [[ |
| 121883, |
| 36895 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3703', |
| 'properties': { |
| 'name': '淄博市', |
| 'cp': [ |
| 118.0371, |
| 36.6064 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@nlKV@nVn@@kVU@²VVaU@wmKXU@UUWwUW¯aU_JUVVK@UJU@kUw@UlnWU_@lI@U@wUml@@mVwX_KWUXKVa@UVUUwJlaXWUn@mlanUVWkIV¥V@VVVI@a@akakLWKna@aVwk@WUbUlk@k@U¯UWWU@mUUVUXkVmVVV@nkVLVÅw¯k@WVXbaUl@bV@@b@xkVVXVxkJ@nk@@VLUlVbVXUVVUzVLVbUbVVWVkLmkJ@n±@UxUVVkV@bx@ÒUX@xVVV@°JXlK@bULUblÆÞV@bLXxmV¦V@xXVğ@±LÅ`IUlVbnbXllVnnlVLÈwK²IlanVVVlLwXlKVlUXma@knwWlkVnU@mVIUl²aVJzXJlI'], |
| 'encodeOffsets': [[ |
| 121129, |
| 37891 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3704', |
| 'properties': { |
| 'name': '枣庄市', |
| 'cp': [ |
| 117.323, |
| 34.8926 |
| ], |
| 'childNum': 2 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@yUUUkl@@aVmLXw°»°w@yL@UUaWXKVknwVKlm_UmmUXK@aw@k@mUWmUL@@@£@KbÝV@akwaULmbUKLUU@lm@°mL@nUJVxVXU`mIUxU@UnU@@lW@@bkLW@UVkKÇ°kLlbnUÜÇUUVÇ@@Xkl@XV`UbmbUbU@WxU@¯¦m°nLaVblVXal@XKlLVVÈLKôlnbI@V@VJI@lVVÞaVkXU'], |
| 'encodeOffsets': [[ |
| 120241, |
| 36119 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3712', |
| 'properties': { |
| 'name': '莱芜市', |
| 'cp': [ |
| 117.6526, |
| 36.2714 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lmnLVlÈVln@VnIVlxVla²_JlUUUVVw²@@mlInlKXUUUVaUaKUVyUUWVUUaVkUK@l@@mlIUwUWlU@w@aU@@LU@Ubm@¯a@V@UKWUUKUn@LUbUKmlm@UIkJnUKUVmIb@b@mWm@Un@VVnnVl@¯@@nVb@`U@Un@¦@V@VUVnV@'], |
| 'encodeOffsets': [[ |
| 120173, |
| 37334 |
| ]] |
| } |
| } |
| ], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/util/mapData/geoJson/shan_xi_1_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [ |
| { |
| 'type': 'Feature', |
| 'id': '6108', |
| 'properties': { |
| 'name': '榆林市', |
| 'cp': [ |
| 109.8743, |
| 38.205 |
| ], |
| 'childNum': 12 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ýVnIW»W@»kUÇLÝU¯¥ÇIUWWÑUWwX¯m@»n@ÜÈķô@a±kȱwÑmwçċmU»ÆkkVyImĉÿ@ݹWnwÇVÅazmmĉ¦ókVmxxU¼VkVm_UlVlk°IVkmJa¦kLmmV@XmKnlUôVXbb@UaÇLğÜÅw£mKnmċwÅ@UkbmaVn@m¯aUJm_k@kWXyl@@kÅamwLUÞmWÅzUKUk±@b@nnKbX¤mzVVxÇn¯@ÒknWVUbkķÈÑWkk@VaU@mUkbÝÅ@Ý¥ÇbkĬXV`kLÇVmalUUanV±nwmkJ@In°KVw¯UnÅ@¥U±bUU±mWbÛKWnUm`UƒVK@bmnmÈż@VL@xxmŤ°n@VmK²VllKkô@êÜV@VXLlm¦UV°Ș¯²ÿ@¥@ÆĊ²ImĶnnb°bKVĸLlÞ@UȮÜ°IVÞÝÞlx@ķĀWUxèÆ@°XnlĊĖ°mnV²V°ÒƦaÞ@zll@bÞĀl¼nKĊ¼óÈb²±IǪÒ¯ĖV@lxnVlkJlaXwŌĉ@VnlÆĕUÆLèŌŤôxÈlU@xlaUċĕXmIWmnkVVVW_@aÈWUUmk@¯çVm»±W¯n¥VmkXw±ÇVw'], |
| 'encodeOffsets': [[ |
| 113592, |
| 39645 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6106', |
| 'properties': { |
| 'name': '延安市', |
| 'cp': [ |
| 109.1052, |
| 36.4252 |
| ], |
| 'childNum': 13 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@kkÇmImUwVkUU²WmVkm@m`mIĢĕUVa@mXÿVVkyUýĕ@l_UmnWKVkţ¥awğ@@aôWakUma¯¯a±£kxmmxUwÝ@xmUb¯KwóÝ@kmm¹Ub@lklVbmnnVUV@xUknƧJUX@LÇWkwLķƧÅwWJkLkþĉxWzJUnÇk@Ɛk¼ÜÔÈKè@°lÈÆk¦ln@l¼@l¯L°UUVÇ°¹`m¼mXkbUaV@U¯x@¦ÇUUmlmUVmnnmlkw@@¦ÅÇLmx¯Ikl@¦mÆ°VUx¯Lm@JInlmxU²mVbkVbUnÈlKU_WlīÈaÞ¦Æ@ÞlanV@VUbl@XlÇÒĸlVaUXlm@Ñ°ÈmUwUnyW£amL@ma²@lVVLÆynXÝVKnxÆb@lk@WzX@lln`IV°b@nmUnbaVlÆ@ČxmnnL¤ÆxĠÛÈKVb@aWaUókVmnL@WUnnKl¥bnIlU¯JlUkVkn`lUUV»wnwlUôĊ¥nnyÆb'], |
| 'encodeOffsets': [[ |
| 113074, |
| 37862 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6107', |
| 'properties': { |
| 'name': '汉中市', |
| 'cp': [ |
| 106.886, |
| 33.0139 |
| ], |
| 'childNum': 11 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lKnb@nlWb°bkxĸwVb@łnlĊ¥L@XlÈVblÈKbakVwôml²`n@nVKlk²xŎ°¦VUJĊw@çnWçÞVkUóÛ@¥kwUmX¯WÑk@UymIUwlUn¥mUk²a°¯V»@ÝVÈÝċÅÅVl»@l@a°±@_kammÅba@m@żKknõĠ@m¯LÅwLVxmb@¼kV@mw¯wVakKW»X±¼¯Vkxb¼W@nx@x±bóakb@ÝmU@ķÓÛLkVUmk¯¤ÝLUlÝ@Ýzx@x°bmX¯aUJW¯k@bÇWwÛwWx@XWlb@VÈUlwLnl°VlUô¦U°¤VUxVXUxlbkVVlI°ÅVlU°m@kÇU¯xUlLUlVL@b°ĠInĠ°ÈnK@xÞa²naUyXUKVkWô¼Èaz°JXUVÇV_JVz@nb'], |
| 'encodeOffsets': [[ |
| 109137, |
| 34392 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6109', |
| 'properties': { |
| 'name': '安康市', |
| 'cp': [ |
| 109.1162, |
| 32.7722 |
| ], |
| 'childNum': 10 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@bĊaƨèwôô¼b°aXVÞVUÞ@aXm¥kImx¯¯V@anU@UÇéğL@¯¥V£m@ÝÈbKX°wČÿb@xÈblxȯĊmÆUVnÈ@ƨÜLĢ¥Źn°VnnKaô_ÈwUaXmnW¯klLXÇō¦ÝaÅVmbğUn¥±wÅéVan¥U»°am¥£Ý@wVw¥nUÑUmmVwmķIÅaóVWxkblb@ból@ğÒĉ¤ċX¯XxkÇ@óÆÅx@xķ_kmÝÇ£kblb@`¯²@bk@k¼ÆUČÆÞÇÞU@U¼¯°±bVlnm¦kVVxnJVz@lÒXW°nVlx@¦ôÜVUlÝXèm@è'], |
| 'encodeOffsets': [[ |
| 110644, |
| 34521 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6110', |
| 'properties': { |
| 'name': '商洛市', |
| 'cp': [ |
| 109.8083, |
| 33.761 |
| ], |
| 'childNum': 7 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@²nlôb°aVwnKÞI`°wXôw°VĊ°@ÅÞÆVzÞK@x@aLÅ@b@nLl@lnmnLVwabVVnbU¼V°blbÈ@ĶŦb@nÇ@amIyUI@ĠVmôUVwkwlanJ¯lwó¥@an°J_@nóƒó@£l¥UwmaÑ@Um±V_J£JUW¥¯@_k¯¼mUVUè¯b@wmL»ğVmağI¯¤ċIUWXKĵ¦ķaJUbIlUóVmk@WÅÅÇ@mUÅVnĉÇ°kwÇa@waċĀ¯xWLÇa@ÞnU¤°¦@ĠKÈê@VmV@bU°°nwlJn¦WbÝ@V'], |
| 'encodeOffsets': [[ |
| 111454, |
| 34628 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6103', |
| 'properties': { |
| 'name': '宝鸡市', |
| 'cp': [ |
| 107.1826, |
| 34.3433 |
| ], |
| 'childNum': 10 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@£@°Ib@¯°ynŹaUlU£Umĵĉ@@ylUÞ@@£kWU¯WaU£¯ÇV¥@kb¯wn¥ÇkUÇnU@¯±kULm@m±_kónUxlbaÇLkUaÇkW@Kĉ¦km@ŁUaķxlw¯aXak@mmakL@mÛ@¼m@lXV`nKU°°@²¤UÈ@VxmôxKlVV²aVwXlaVlx@UVnÇnk°VVLlkIJÇk¯V@knÆn@lznmlVkzVVVx@Uxz@x±¼VxxUlkb@¼ČkVXlĠkôV²wLUKlwJ@aIV¥Þn¯Ün@nkl²kÆ@°aVbnI@Ťn'], |
| 'encodeOffsets': [[ |
| 110408, |
| 35815 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6105', |
| 'properties': { |
| 'name': '渭南市', |
| 'cp': [ |
| 109.7864, |
| 35.0299 |
| ], |
| 'childNum': 11 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@ÈôLxU°Þ@mÈnl¤nUôLwX`@ÞÝLUmLôôbVbnºlnÞ@ôx°LanVwÞ@Vxnwnlw²¤b°°bVnlXbó@bĠ@xb¦ŤVXġ£W¥ƽɽó@ýóƝÝ»£XmƅĊkU@ókťaĵÇ@aka¯UV»maUUabUxmKnkm@kmK@xó@¯n¯KǦ@ôÅèlxkx°nƾ¯KU¯WķL@VÝIUbyWbX¼Ç°'], |
| 'encodeOffsets': [[ |
| 111589, |
| 35657 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6104', |
| 'properties': { |
| 'name': '咸阳市', |
| 'cp': [ |
| 108.4131, |
| 34.8706 |
| ], |
| 'childNum': 14 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@IXyĊwlýKlXIVaķ»a£¯aVU@awÈōaL²»VUln°WȯW»XazVaÞJ@U»@¯Ýbğwly@£kÑţ±WÑ@kaIUn@¯ómţUbU¯lÇIÝb@¤Ý@kV@zĊ@ĶnVV¤kVbmź¯z@°a¯J@¤@bUxb@`xUÔ±ºVXWUnUJLĢ¯ÈKlblmÈXŎ°U°LlkÞK@Èxl_°ĶUÒkbl'], |
| 'encodeOffsets': [[ |
| 111229, |
| 36394 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6101', |
| 'properties': { |
| 'name': '西安市', |
| 'cp': [ |
| 109.1162, |
| 34.2004 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@°²@mVVÈÈl¦m°xla@U¦°ÈV¤XbV°lXÞaÈJ°kVaŤVôn°@mVJlb@XÒŤ²lÒ@¤kzĠxÞa@°¼ĸK°XV°Lƽ¯mlwkwÆç@óÈ¥°L°mô@w@aÆK@b@wÝLyÅUÝÆ@ĉ¯¯UóxW¯x_ÝJmLUx¯bóak±mÝUUW¯ba»óóxƧçĉbaĉxIUV¯¥ō±wl'], |
| 'encodeOffsets': [[ |
| 110206, |
| 34532 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6102', |
| 'properties': { |
| 'name': '铜川市', |
| 'cp': [ |
| 109.0393, |
| 35.1947 |
| ], |
| 'childNum': 2 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ÆxĸƨKlxÈXK@VWƨIlmV@wVUmUnmUalk@kVaUaóaónKVÞK@ÝW_xóKmVk£ÇmnÝ@¯VwóK@ǯXkmVU±¼KbÇŎx@bUV°b¤b¼ĸUb'], |
| 'encodeOffsets': [[ |
| 111477, |
| 36192 |
| ]] |
| } |
| } |
| ], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/util/mapData/geoJson/shan_xi_2_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [ |
| { |
| 'type': 'Feature', |
| 'id': '1409', |
| 'properties': { |
| 'name': '忻州市', |
| 'cp': [ |
| 112.4561, |
| 38.8971 |
| ], |
| 'childNum': 14 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Vx@lnbn¦WlnnUm°²VVVVVnUnºlz@l@J@kXWVXl@La@KULlbnKlLnKLnKÆXn°bVV@bUVl°Un@LnaVJUbW@UX²l@ČwlVVIWnkÆa°anVKn°UW¯@aVUVk@Un@aV@ValwUanmWUk@WVUUanaVwnLVl°@nk@mVU@UVK@wLVKVU@K@UUKVUV@@bnLaVaôlIXmlKX_°KVV@bVV@zV`kblIVUlL@bnV@VĊllVlIXW@kaU²blKVnIlJalbXXlWVn°JnnL@l@XlJlaX@XW²@l_VmnKUblU@mnkVK¯@U@ma@kX¥VmakkLa@a@WIUUVXWWnk@a°a@kkm@kUUmJm@WUUUIk`m@VkaWWkXKmXk¯@WKLkak@±bw@aa@aka@ma¯@LKÇÅkKWbkmġ±ÅULUKVVkm¯LUVVbUwUW¯bmULxWJ@klmkUm@@KnwVkVK@akw@@a¯bKknVUIb¯mmbk@UbmKUL@xUU@klmLUlVXIVVVUVUU`mLXVWbXnW`Ų°xmxU@mĉwU@mbU@UmbkVW¦kJ@X@`¯Im@UlUVVnb@bWJXnmbJUUUUa@UamIkax@@x@b'], |
| 'encodeOffsets': [[ |
| 113614, |
| 39657 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '1411', |
| 'properties': { |
| 'name': '吕梁市', |
| 'cp': [ |
| 111.3574, |
| 37.7325 |
| ], |
| 'childNum': 13 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@a@w@wlbnJVb@VbVVVInaWmXI@aaUmVUVkn@°J@_W@lIX¥lUnaVV@naV@xĊnV@wn¯wƱX_WmXaWUnKV_VVUUUUWJkUVnKlk¯@@kmKUaűKkU@WmI@WUIlUUmVwXw@UlUVwV@LnbW@anU@UaVkô@l»n@naJnUÈLVaÆUUVmVKV²L@mU_lK@UVWkUa@a@U¯aUaÑóÑUbKk@@ak¯mVaUwVÑkWUmK@UUKmXUWÝwUaLUU@aWJUUU@UaÝU@WL@VKVaVI@WnU@alIVK@kImIkJ@m@@@_K@x@kaW@U@Vmn@UK@mIJUXV¤XXWlkKkkK@XmJVakImJU@ó¯LWKUV@nUVLkxmKkLma@kXKmmLabLmK@V@mXVÆUxX@`nLaV@@VmLUVnLlLb@°²nx@bVUxlb@V¯bUV@zVXVĊXVx@lVn@VnnmU@LlJXVz¯VWVXbV@bmnVUVkÇþÅ@XVxmbUlVUlnW@Xl@VLXÒ@bÞJ°¦Lò@nUb@°X@XbmVUVnb@xx'], |
| 'encodeOffsets': [[ |
| 113614, |
| 39657 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '1410', |
| 'properties': { |
| 'name': '临汾市', |
| 'cp': [ |
| 111.4783, |
| 36.1615 |
| ], |
| 'childNum': 17 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@nW@@UnLKabKnnWL@lnblKnLlwKVU@mVUXL°KôV@nIlJUbnI@WlLllLXkWWU£VWInJ@VL@nm@UVX@lb@@wL@`@n@V@lw@nVmVXWmwnUla@_lKwVlUn°xVKVXXWlUVVI@K@Kn°KwlVlU@kna@V_WnmUVm@kXml_@mLlKXw°m@_ôJVUV@Xl@UaV@Va°Ilk»VwUkVmwUmmVn@V¯@KUwmK@U¯wUVÝ@mJUnWK@@UnKVa_lykUmKÛnm@x@UUlwVkXW@a@U@@K@kIVnammVakUl@wX@@k¯@VVbml@°UbULmlVbnbÅK±VKVXUJWa@ULWaUU@@U@aWK@UkxUKLUUUJ±UkL@V±kk@kam@UV@l@LWl@n@VVUxLlUUx@VUVU@aIUlL@°mLUbkUUaWUUaUU@aWKLWJ@bUL@VUVVbU@m@a@kmKmnĉlUKXWUblbxmIkU@xWb@lkVxLXmzVV@bklVVUzm@bk@Vx@xlU@lUbVnl@Wxnl@n@UbVmLmb@`X@lUX@@xlnkLWaUJnnWVVn@l@bULVV@lV@XnJVX'], |
| 'encodeOffsets': [[ |
| 113063, |
| 37784 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '1407', |
| 'properties': { |
| 'name': '晋中市', |
| 'cp': [ |
| 112.7747, |
| 37.37 |
| ], |
| 'childNum': 11 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@lInJlJ@ULkJ@bmV@XUJUbL@UXKV@ÞVbV@VVXI@bVVKVbÞxVXnWVL@VnLVlXÒUVxUb°nl@bl@LVaôÒÒVb°b@VnLnnV@lmn@lbUV@JUVVXkl@lUzmJ@xXklbUnJVUbnUlbV@nlLX@lakV`Ub°@XVJnUL²KlxnI@KV@lbUbVVKnVl@zlm@U@nI@WUaVl@@mVU@XkW@nkVKV_Vwy@knwVa@XalU@Vnml@X@VLKVaÞbnnlJImVKnVVVInVlU@m@mXK@UmyUI@mWUUakamw@wUwmLkakwVmKw@wUam£y@am_W@UU@knmmamU@WUa@knw@UUUUV@nJm@mVUkKVUUUkKmwKULKUImV@lUnnm@mbUK@°bUnmbUmkkWUb@am@UXkK@a±@V@ĉÅVUXVxUVkLWl¯@@bULUlm@@nm`XlWakIkmVUbUL@Vm@kI@@Km@VaXI@W@aU@kUVU_KbJkkÇb@nkKmLwÅW@kVUUVU@WUIJmIXmma@_kyVaUUlkUm@kUx¯Lm@L@LUJUkVWXUWUL¯wVmUkxkL@`bkmVnxXUWUnm@kxU@'], |
| 'encodeOffsets': [[ |
| 114087, |
| 37682 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '1408', |
| 'properties': { |
| 'name': '运城市', |
| 'cp': [ |
| 111.1487, |
| 35.2002 |
| ], |
| 'childNum': 13 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VlnJwkaVaXWVLĊknmnLl@@bnV@UaVU@UVK@aXIKXL@bVVVbXVVblVaVnK@¯KVkJ@bVVU@UVwkVKVwUUm@@Xk@K@kVUn@lbl@²l@UlK²VVIVVKVLlw@VXL@b@VV@VXbVK@XbVIUWLU²ÆLmaUankVKVa¯@nkUaU°@n@@kWaUVaXUW@IXKVw@UWU@W@@UUU@mn@`m@UUULkUmJIU@@UK@U@anak_@wmKUwmakVkmKVk¯bw`kwUIÇx¯»ÇaÅmn@@mmUkV@wkKW@kxmLUkĉLÝkxÝw¯lóVUmV@ĀVVX¦W¤kz@`Vx°²ĸ@Ul@xêĸNJ°¤VVlXLWnXxmV@nUl@'], |
| 'encodeOffsets': [[ |
| 113232, |
| 36597 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '1402', |
| 'properties': { |
| 'name': '大同市', |
| 'cp': [ |
| 113.7854, |
| 39.8035 |
| ], |
| 'childNum': 8 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@²£yl@ČĖ@bĸĢbĸXaKŤnn@ŎôllÈxnVnÞÇV@bnXllL°KbVb@J@b@UxlKXLlKlXk@UlkJlkUVKXUÇVIVm@_nÇLalwVnU@UUwma@aaÝaLmUk@@W@U@@XwVWÝUUUk@@VmLKV»nwUwaUL@`mzJUIVUaUwKUaVIlJôanÑlLVUn@a@VV@@UUwVK°Vn_lJÆLéW@UUUÅ@»lm@aÞIVwXWUUkkm@U@aU@mwU£VWU_kWmXwW_°yUkkK@UÇK@kkUVymóKU@KWIbUak@mJ@bkbmLkUmkVUW¦@lnb@@V°ULml@nkVaVmLUnk`±@XWW@kbǦX¯WxI@xmbmxXlWV@bÅUz@Jb@bÞbU@Wbk@xk@WX¯VÛWÝbÝUkVUU@alI@a@akLWam@U¯UUmÇL@K@aU@¯VUkKmX@`@kJ@nVUb@lbVÆXVWULU`VbkLUV@XWl@bXJ@VbV@Vl'], |
| 'encodeOffsets': [[ |
| 115335, |
| 41209 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '1404', |
| 'properties': { |
| 'name': '长治市', |
| 'cp': [ |
| 112.8625, |
| 36.4746 |
| ], |
| 'childNum': 12 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@UkLky@IJVa@mÞaWy@_W@_WXVlUVw@nw°K@mUVamVkU@mmmnLVUmKXaU@IlKVUnK@UmWkX@WV_V@akU@aKWIXyIUVmUnUa@WaXUVKVmkUWVkULU@@VbKbIUm@mbVLxWUUkn±V¯wbÅJUbmLkbmKÅKbVnUbVKUbKUbmLKmbaKkUm@UnnVnxUVlUxl¼k¯JUbU@Vbk@WU@UVóI@`¯nWxkLK@nk`Wn@lUnVnmXU`@mb@lkV@VnklVVUblz@`nbWnnJIVJ@XUVVUV@lÆXxnKlL@maÈllIaLV`UlVV@@b@XJWUb@n@L@lJn@@UVKVaUlnlJXbkWn_@mn@VkVK@a°@XklKVUUwVWUĊÆ@U²@@blLVWn@@bVaXllVnnaVma@¯VLnan@mVm@knUVJ'], |
| 'encodeOffsets': [[ |
| 116269, |
| 37637 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '1406', |
| 'properties': { |
| 'name': '朔州市', |
| 'cp': [ |
| 113.0713, |
| 39.6991 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@XXWVXVWnnlnn@èƼ@xlVnblVÈUVl@blnLÜĊmUkU@Ua@WI@aXk@WVUlKUaV_VKXWUUÅka@VaU@mlI@@_nWLVl°UV@@b@LÈKVn°V@VnXblK@b@bkJ@bVVlUÞVÞaXÜ°UXWl@wl@XaV@Ýa@aa@IVyÆ@aXUWknwna@wJXw°WÈ¥kI@W@kmKm¯IUmkXWWkabkImJUkL±aVb@lWXkJUkĉk@UmU@aKkVUkJlaU_y@UU@aUU¯LW`kLWnkJóbUbmK@aU@UVVL@VL@UVULK@xUL@VUV@nml¯@UkmKUxmbVbUV@XlXVmnVbkxUbU@bm@@VUlUVb°@VX¯m'], |
| 'encodeOffsets': [[ |
| 114615, |
| 40562 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '1405', |
| 'properties': { |
| 'name': '晋城市', |
| 'cp': [ |
| 112.7856, |
| 35.6342 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lVLbanLnKVaLVaLUVaUmaÆLnLlanKVaÆIa°x²UlmVVXwUKna@VnJaLa@UV@@alUkKVKnkmmVwUkw@@kxWUXW@@mk@aUa@a¯aLkKmwkUm@kL@K@aWIXmVXWkUVakL@UVKw@aUK@UUKmLU@¯nKUwVUIWJUWmka@UXJk@UkmW@kLWKVx@bmI@VUaVU@a¯@UUmVKmX@±`kÝKVxUL±akL@VbLkKmV@XWVUbVXb@lm@@lW@@xklVUbnnmbUlJ@@L@@Vb@WXUlkxVV@wn@ÜmnLlVkz`UbmL@V@XLmVnIÞ@VU°x@VnLxV@LU°'], |
| 'encodeOffsets': [[ |
| 115223, |
| 36895 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '1401', |
| 'properties': { |
| 'name': '太原市', |
| 'cp': [ |
| 112.3352, |
| 37.9413 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@VV@wVKnLVal@na°naVJUlmL°a@b@lx@bULUlmx@Ln@lVknl@XIwKVn°aVXVxUaVU°KnUlUVLKÆV²ĢlnXalLÈÆLKUaVkUanmWUa@WwkUWU¯y¯Ñ@anIl@@aVUmIymULUUVakaU@@LmJkw±LKmVUI@W¯VaU_lkbW@kK@mUkaVmVaUIVmalkW@wnIVy@klkWUUVI@UVkam@knU@mmmK@bblVUX@VkLV`@n±KUULUnVVÅUbÇKmVImbm@k¼ó@Ulb@VmV@bXmaK@UUxkVV@xWUxVnkVVJ@XnJ@XlV²LÆVbnL@l@°'], |
| 'encodeOffsets': [[ |
| 114503, |
| 39134 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '1403', |
| 'properties': { |
| 'name': '阳泉市', |
| 'cp': [ |
| 113.4778, |
| 38.0951 |
| ], |
| 'childNum': 3 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@°@nb@lb@bbb@x²al@lbKXU@mkUWkkmUUVwV@XUW@naVklKXblKnLnLVanImaXKlLaV@U@KUKWalXK@£WKXUV@VUUUVW_V@W@@K@UIWmXUmULnJkImmÝaUbLK@UWk@mnU@kVWb@Ubmx@lzUx`UULml@XWl@UV@nk@UVb@XJm@@Vknyk@zJnUV@bk@mJ@b°Ò°zXVlVXx@bXVmnVbUlVb'], |
| 'encodeOffsets': [[ |
| 115864, |
| 39336 |
| ]] |
| } |
| } |
| ], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/util/mapData/geoJson/si_chuan_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [ |
| { |
| 'type': 'Feature', |
| 'id': '5133', |
| 'properties': { |
| 'name': '甘孜藏族自治州', |
| 'cp': [ |
| 99.9207, |
| 31.0803 |
| ], |
| 'childNum': 18 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@aXam¯wm@±°wUwV@UaVw²KU@UU¥a@£ÞôxKnkmX¥IUÝUwlk°V@ÈKUwlkUyV¹mx²XllÑW»lw°UŎnJl¯°V@wôIVÇnnUllLVÇLô¼XW£@±@¥k_ÇJkUékwXa@Llw²Vxbm¼ÈxlLÈVWÞn¯mÇÑUÝlÛkwlĉmULmwUJç@wkm@ÑlUXÑôġVaUѯ@wķÓkbVmnU@@y¯IķKV@¹aé@kmÞU°¥@a¯@anKlblU¥@óğç@Çw@wklaçݱk¯±@ğÝUÛmݯw@kb±¯akXWÜkXUÆÇU¤X_ƐwV@¤XUbUIUlÇUkġ@aXČmlUlèUV@mVk¦Vx@¦±¯¯¯anlW¯nÅw@w°KVak£m@klKknÇU»óKīlaUaV£@¯@ÆUVÛÝÇXÇlÓlŹ»WUğJ¯£mxLĵôºXVlUll²bllxónn°ÝU¼mJU¯nV@êĉ°Uĸw@m@¯kmXamѯaUwÝKU¥mÅn¥Wmn¹n±ƑƆÇôXê±NJnUôlĖkȂVÒ¯¼VnȮ¯ĀnƆĢ@k°V°¯ĢVlkVxm¼X²Ŏ@VxknWÜ°U¯nÆÝ@`ôݲÒÇznmX@xè°K°ÅUČĬóĖÝó¼ÅêÒbmk@V@Òl@nĉÜêx@ĖmlÅJ¯¦óxȭ°Ým¯LĵèĀ@Æl°żX@xmkV@z@°blnÞ°J@bn@ƼUVUóóL°X°ÝLxUn°Ĭn@lnL@Æ@nKÆxnUnVInĬmÆnxŎ¼ĊIĢóÞ@ĊƨbUmV¥lkwnLmÅÆ¥XwU@wwUÞ@alUUÅUVkkm°aU°Ó°w°Ub°a²K¯ĕ@ÈbÞĊa»XVm°InĬk¼VbaJô£VĊankůnÜU@anKnĮbÈmÆ»nIé£Ġ'], |
| 'encodeOffsets': [[ |
| 103073, |
| 33295 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5132', |
| 'properties': { |
| 'name': '阿坝藏族羌族自治州', |
| 'cp': [ |
| 102.4805, |
| 32.4536 |
| ], |
| 'childNum': 13 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@l@@þ²I@lVL°wnJ°UĸŎèIlwV°¤nĮ¤ÝlèL@@xlè²ôĊ_ĊġVÈôJżīlbXÆÈVkxÇVn°¦Üb@è@nn@@°UÈ¥WÇ_Uala¯¯UÇk»mVwk»k²°VxlL@¤_@x`ÈĖöb@l²alXa@bnK°¦VK@nnWmx@nUnl@@llĉk°l°UXkmW@Un`kÇLWÛÈVxVVlVk@lIXb@ylXÈWĮWŤzy@mI²J@n°@VJ°aÅ@ŎkVÇkaUwKVwV@nkm@±ôkôĊJ¼InÑm±nIÞXÈĊxĊUÈbÜyÈ£Vkw@kVUVm@a»ÜbÈmUXwÝxUn¥@°ġÅaJVkaW¯Û@W¥UŏĶ@¯kUŃ@aI@mmanwÞW@mw°»Uřk¹±WxVx¯¦U°zţWw@°ÇVÑk¯@y°a£@mnl¼aÝÝakwU±aĉImlĵn@m@kkV¯Ñmĸ°xl@XVÞmlÛÝĉUÅ¥mwÅ¥VaUwXġċaVůÛŹlwU¯Uó±xÛV±¯¯n¯mċLmnĊm@_kJWaXmwUĉK»@mwXÝUÇkKÇw»naUw±kxK@WbxlVêlÈIl`@¦@²X¤Wó»KUÈKkkmVmUÈóJ@x¯Uk°Imō¯VxkX¼Òkk±WwnUºVzklVxLÇ@¯UklVxÞVJW¦nmlLówÝ@¤b¦V@VV±LUxVbU@Vx¯x@²n°xnWbb'], |
| 'encodeOffsets': [[ |
| 103073, |
| 33295 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5134', |
| 'properties': { |
| 'name': '凉山彝族自治州', |
| 'cp': [ |
| 101.9641, |
| 27.6746 |
| ], |
| 'childNum': 17 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ĶóKnw°¤ĠIXV¼kźÔkÈWÞÈÜUVÅ°@@U¤VbkbĬôL¼ÈVlmLlkn@l¤Ub¯L@xÆx°mXmk°b°°²@¥Uwl¥nU@VUkçVnkWċbĢ@lÈVVkJVaVW@£UƏxW`£ÈVVÅlWXÛlW°b²la@°xnÞVÜĠÞ²@l°Þ²èkbl@xÈx@Ġènal£nUDz@ÞKnn¤@¼°U¼nVXUbnĠUVbUlV°LX@lVèÜUnK@_yXVyUwmIU»VkÇ¥ÿkkV¯m±n@n¯ÜanVVÆz@bwÜbm@wa@kmk»@a@VUUów@nb°mXmnVbÞVôanwJak£lwLÅnÝ@wl¥IÇÓ@UL¼kVÇÅó¯kVmmw@n_Vn»°LÅ»@éÇçŹīVÇÝ@ÝğUaVݯķlŭġl@óÞÛċ@¯nkUÓm±IVġUwóKUn±¯Kw»KÝVnl@óxUwţ£ĉUmÅÇÝKÝUlmK£UV@ÞÈW¦Ò@Ĭnny@nÒmV¼@°Vbl@VlnUUwl°a@@llnk°lbnKWĀnUVxU²Åm¦ÛÇÅaUVb@¦m`móXUmmxÅ@±Þnè²U¯»mVm@wU@wÝÝmLa@VÇUkl°¯VlkV¦UmxaULUèVx@kIUxmWV¼¯VmȯUnlÈ@m»ÅVWxÅbÅğW@km@kVV¦mlnn@ōl¦ÅÆxk'], |
| 'encodeOffsets': [[ |
| 102466, |
| 28756 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5107', |
| 'properties': { |
| 'name': '绵阳市', |
| 'cp': [ |
| 104.7327, |
| 31.8713 |
| ], |
| 'childNum': 8 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ńlV°@ŐĵVX»ÆUĊÑJw@È»m»£°Kk@ÇnÑÆ@w°JUwnw@wbVb@VlźLUwa»aUklyUUVakwWXwWUxkLmn¥mwkUXlJw@aIk°X¥W²l¥aUIlmkklÈL@m°nlWUaW@V@UaV¥@ak@Çk¹K@aK@kKkÇX@VU@kx±VèkIWwUVUkkKÇ@a@wkml¯@kUWn£WaaVwnaVÝw¯@UaWxnJÅUxUma@L@mbUU±VVnkxUÆVm@kkKW°X@¤ÇUkÆÇnU¦¯kmLVwÅK@UóbÇÆV¦L@±êX¦mVÞkÜÝnWU@k¯wķn°ÒUlln@@ĶmnkĊJ²bVlxÞbÞbk»mn@¤¯bz@l°UÒ¯È@xŤXyV¯°¥Uww²XlºVŚ¯¼nx@XÝmxnb@nJ@b'], |
| 'encodeOffsets': [[ |
| 106448, |
| 33694 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5117', |
| 'properties': { |
| 'name': '达州市', |
| 'cp': [ |
| 107.6111, |
| 31.333 |
| ], |
| 'childNum': 7 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Uxn°bnlUnÒÆnn@n¤LnxlUV@Ælx°XXxl`XVWLè±nÈb°b@²x°Kܼ°ĉV¦lJnU@¦ÞJÞğmLÞ»xUlbVÆannalVÆX@lnŎVmUmaÅXa@aWm@£@wĉJVkkkkmnk@mna@alKJ@ÞwmÅÅ@ambkU@KUġKU@mak¯±a@aĉÑÅaVwXlw±V¥l@@ak@@£mĉÝónWV@nÝÇÇxUmbaVkkk@m@m°ÝýXmakÅī@@mb@@xmnb@mxkWL@¯b@WUXmWWKkbm@kxXmm@LUlxlêóKnUallLlLó°m¯JVUK@xK²Āô¦l°'], |
| 'encodeOffsets': [[ |
| 109519, |
| 31917 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5108', |
| 'properties': { |
| 'name': '广元市', |
| 'cp': [ |
| 105.6885, |
| 32.2284 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ÆLĊx°»Ŧ¦WLÈ@xÞKÜ°ÞnVxÅĀlÒnJ°a@wV¯l@XWknKnwVÈ°XXalX°VI°bWna¥@w°n@yÆ@nkÞ@°¯lJn°IÈlUlXÅ@ķlUV¥VUUÝÞUU@UwJUkĉm@ýlkWUwVwWJk@VUKlUkaVUmLkm@@UIk`@UmlUkV¯ÇXKÝ_mm¯@U`kwml¼±KV¯¯Vk±Vk±kzmaKUnDZbk¦±X¦¯WlJ@bxkIWVlxnm¦nlKVwXWxXlxUbVVkzVlb¼bVxŹKUk@Uaa@xmxVx¯Ix@ÅmÒ@Èl¯L¤n¼'], |
| 'encodeOffsets': [[ |
| 107146, |
| 33452 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5118', |
| 'properties': { |
| 'name': '雅安市', |
| 'cp': [ |
| 102.6672, |
| 29.8938 |
| ], |
| 'childNum': 8 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ln@xèVInxVKnĊklxkÜVÞÒnÈm°nx@¼ĊLVnxWXblI`@nmĉnKČôÅlUÑmUK²¹@ÇÅVÓůVýÞWUVmXÆbnwKUÿ@UmmIUb¯¥Uw¯ÇmçmanUm»UUlk¤a¯bVU_WĕmÇűĢUlUlÛVçkU@W¯KUVkUağVmaVWUmV»¯@»m£mÝL±@ÈmVk¤mb@ô¦kVkamL@b°@b¯¦ÝVn@lêb@ºUĸL°J@zV@nmUlaĸÔ@x°VÒUbóĢÒWkV@Ò'], |
| 'encodeOffsets': [[ |
| 104727, |
| 30797 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5115', |
| 'properties': { |
| 'name': '宜宾市', |
| 'cp': [ |
| 104.6558, |
| 28.548 |
| ], |
| 'childNum': 10 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VlÈnlXnWLX`m²nV@b°xĢçlnVmnn@@°UzlV°nÞÒkxlw`UnVbmL@albÞKÈÛmܼ°@XÇ@wmW@ÅKĊLlVLVŎçÞL²±ğkw@Uy@¹lKXlKVa@wČ@w@aÇU¯n@@wġakaōK@Å»VakUWmķwkbğ¥mLak@ġÞ°¯xVVÞ@VxVVWxXlxU@k²WVÅULmèULVĊklĠVJVx±nů¦mwğ@mlğkkl±@kUk@¯±ÇKkxl¤bImx'], |
| 'encodeOffsets': [[ |
| 106099, |
| 29279 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5111', |
| 'properties': { |
| 'name': '乐山市', |
| 'cp': [ |
| 103.5791, |
| 29.1742 |
| ], |
| 'childNum': 9 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@kVkÆkV²UlºÈIlxLXèÜlUXUmkbVèx°@@¼°Knnn@mÆIUbnJ@bVI°b°±@nK@mVakkKl¯nbmĸèl@VnÈlUUwwmwnm°¥LlLnU@VaImbkmKnk@mbLVJVUUVnkVmb@a¯JUaÆkk¥IW¥KlwÑmÝU¯kVy¯@@mmnUkmġè¯w@aU±mnW_XKWmkÇmUkóbUÝUanmW¯nma@xVôUV@b@l¼n@lb@xnÛaxa@yUÅmUÛbm°@mn²U°llĀȦlUV¼nJVxUzWz@`mL'], |
| 'encodeOffsets': [[ |
| 105480, |
| 29993 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5113', |
| 'properties': { |
| 'name': '南充市', |
| 'cp': [ |
| 106.2048, |
| 31.1517 |
| ], |
| 'childNum': 7 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ȲVmLnblyl²²UUl°U°²L»knlx_V°@nnÞ`WL°ÈUVlnkV@l_JV@n@lnKV£ÇUV¯m@laXUUbVx@VkôJU°Jn@wUk°wnUV_nJmknmm¯Vwk¯ó¥±ÿL@wLVUkUbX¯mykI@a±Kk¦ULmaXVm¯Kz±klUIVbÇJkL¯lUÿUlUkJUmUUkVVklKk@@aU@J²x¦kĬ@¼±ºXnWbxU@xx@lL@bLlº@Èl@bU¦Vb@U@XbVkX¯m@nÇKkllknJV'], |
| 'encodeOffsets': [[ |
| 107989, |
| 32282 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5119', |
| 'properties': { |
| 'name': '巴中市', |
| 'cp': [ |
| 107.0618, |
| 31.9977 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VUlbkVVLUl@XIUxVxXkl@þĊnVlIVx@VVÝVÞUVU¦kV@ĸWÆô²@VÞn@Vaôb²W@K@XUmÑUW°¯°Ina@y_lWn¼lLUbô¼Kla@nkUyôÆx°@n£Ý@¥mVkIU¥Ċ¯Û»¯L±w@¯aÇa²mçKXUWk_Ww¯WwÅk@UkVmwK£@mmmÅmÑkVmamnnlmIU`Vm¯xVlx@m¯IVóIUl@UwVaVWkb@nU°VÈU¤'], |
| 'encodeOffsets': [[ |
| 108957, |
| 32569 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5105', |
| 'properties': { |
| 'name': '泸州市', |
| 'cp': [ |
| 105.4578, |
| 28.493 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VVXwVKnwnVnl@b¯xmKUbVn°°X°@blLènV@Vnl@ULnmmUnaVV_ĶV@wnJl@@kkKVólaUwnJmwUlm@aUaôKVnJWbÞ@VwVLX¥VV_Þ`wWÞŹmmnIn¥W@kWV¯@°kILk¼Ç@k¤±XknmݯUlÅÛKWV¯klUwkLÓ@U@w@ġXVWX@UbVbV_kÇVlU°lnwŎ¦ÞaƯnmm¯Um¥nkVmkl_ó¥¯UÇl¯@Lk`¯ķLUy¯@mw¼ķ°ġ_ÅU°mlnÇVUÞ@_JUnVUXblĢb@x@mV°Èb@xċ@@xUbkLWkL@ºzV@lxĠ±²'], |
| 'encodeOffsets': [[ |
| 107674, |
| 29639 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5101', |
| 'properties': { |
| 'name': '成都市', |
| 'cp': [ |
| 103.9526, |
| 30.7617 |
| ], |
| 'childNum': 11 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@°n°m²°ÜUw²ôV°VkxÜźUŰČbĢlaÈL»@kwVÇ@nÛÆ»ÈUÝ°Kl_V°U`Vbn@VbÈLaVU@ƨ»VnIlUUa±lIk±@VnKmÅ@WaK¦lVōkKÝ@maXÇmw¯IU@kVwUmVIçÿU±Å@¯È@xK@wLUbÇKÅ@mÝ£@yóUóóUxkI@WlIUabaVĀLmxÅaWUnVÝXUþÆ°UÔÈÆ@±ºLnVVÒkóÆ'], |
| 'encodeOffsets': [[ |
| 105492, |
| 31534 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5120', |
| 'properties': { |
| 'name': '资阳市', |
| 'cp': [ |
| 104.9744, |
| 30.1575 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@èUJVnxU@lV°JnxWÈnbÞ@lLŎUk¥LXbÆ@nmLU@zlbXmlnVynLçJVbUnómUnamUan¥lKV_²aValWôn@nbVK°¯VblW@kklUnlV£°W@wUXk°KVwmVkwVyVI@wkmVÅ_Umm@Uÿmbk£xUaVw±V¼V¤kLWxU@UkbyXóm°V@@zÝÒkKn±U@@_VVkÇaVwnLWalm@@kkVVl¦kIV`±n@wKk²aVUUV¤nkxmUkVWVnLUbVb`kUUmLUmX@`ÅbÇXbWLXn'], |
| 'encodeOffsets': [[ |
| 106695, |
| 31062 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5104', |
| 'properties': { |
| 'name': '攀枝花市', |
| 'cp': [ |
| 101.6895, |
| 26.7133 |
| ], |
| 'childNum': 3 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@bKÞnÞ@xV@xnUn°¼V±mç²ÝÆ@wnnVWnôn_@¥UaVbÆÈÜn¥Æ±VUwVmXÿmLkal¯km@k@¯bkVxmVUkk@Ua@¯»UnmÑ@mzm@īÑX¥Ç@ÝxU¦ÅÇUkx@lbUWVXmV@xĵĖ±@@¯xUÆLnÆmx@nXL±lUUVwKWak@WxkbÞĉbUn@@@xó¦Ŏ'], |
| 'encodeOffsets': [[ |
| 103602, |
| 27816 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5114', |
| 'properties': { |
| 'name': '眉山市', |
| 'cp': [ |
| 103.8098, |
| 30.0146 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Vx°¦VanJVn@baVbkJ@XlJVwôôôV@zÞ¤@nÆÈLVaK@xL@w°ÇÆ@²VĀmWXKWaÈÆa@_nWVnKVlV_UaVamKXUWwnmmwÑm£@ynUkWĉUkWVkkV±çkJmkKK¯¦mnnxxVxVÇkUmk@çķnmak°LllUb@nmL@¯²¯aUJ@amIVaÅJnm@mm¯L@»¯@wUçanlVWVÛkWçKkwÇJk¹±VUÅlġV²ÈÆnXĖV`U°ab£lkVVn¼mVnbèÈn°'], |
| 'encodeOffsets': [[ |
| 105683, |
| 30685 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5116', |
| 'properties': { |
| 'name': '广安市', |
| 'cp': [ |
| 106.6333, |
| 30.4376 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VlIVkVĀVk°lKÈIUaVJlk²yLn°UWnbVKl¥²L@blJnzW°alV°Inô¯KkKkkbVmôLkéwVk@KnnWlwn@laXLnXVW@X°a@XKlnw@man@w@na@@wĕġġwUkUWb@mk@¦¥mUÛb±yÅn@bml@kV@lknVbmVnlmbÇk¯bWyk@V_UamJ@I@WaVXamIVWkUkbVaUUx@VnkVU¼bkKUxmK@WxnV@n'], |
| 'encodeOffsets': [[ |
| 108518, |
| 31208 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5106', |
| 'properties': { |
| 'name': '德阳市', |
| 'cp': [ |
| 104.48, |
| 31.1133 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@nUW¥²é@K¥UÈÅôa@VÆLUxnKl°V¥ÈmlÅÈV@£WX¯lLln@UVÅlwUm²UVVna@@KnbVVwÆImXwWkIVwÝĕVUaIèmKUzkmWnka@y@l²kJ²VbVkmJUƧ¼@UVbÇKUam@Ua_¯VUk`¯LVÞÇżmÜ@UÈx@l¼ÇKkbWVxUbƦnxƦĊV'], |
| 'encodeOffsets': [[ |
| 106594, |
| 32457 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5110', |
| 'properties': { |
| 'name': '内江市', |
| 'cp': [ |
| 104.8535, |
| 29.6136 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@²èlUUllXĊVXlmV@zn¤ÒnxmnXxlUnVlwmU£VVUbl±L@x²mU_lJ¥UklU@ln@kXbmKUxÈblUU@`V@²mlLÞÑ@yU@¯ônWzaVlV@XwlKU£»aVaUwm@mwUVUwklVDzLlKVm_@ykUm@mUçkKmxkIUÝ@LUJ@n±kºLXb¼@mmIXa@mamnkWKUx_U`UklwUwmUbV²akbmkn@`UmÒVxUbI`UaÝÈ'], |
| 'encodeOffsets': [[ |
| 106774, |
| 30342 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5109', |
| 'properties': { |
| 'name': '遂宁市', |
| 'cp': [ |
| 105.5347, |
| 30.6683 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ÞĖUxlJXVb°@xUÞmbUxbXbm¤VX@lk°ln@xbÈ@lLVlVUXxlJç²UlwV@@UÈWlLw@wVwXaWm²¹@»lī¥w±I@V@bl@kLUllUVVn@mmUwXċbVb@VUkbmamW@ka@k@laUa@¯b@mmwó@@lkXUa¯°LUamm@ókXUb±bU`kLm¦bnVmbnVmô'], |
| 'encodeOffsets': [[ |
| 107595, |
| 31270 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5103', |
| 'properties': { |
| 'name': '自贡市', |
| 'cp': [ |
| 104.6667, |
| 29.2786 |
| ], |
| 'childNum': 3 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lIÞÇbV_JVaUwnÑV@_lmnlab±UVanVxkxVlV_`wVLlXnmnb@WbnJ@n»WaKl¹²@mVI@KÞVlJnw@aW¯¯¯UmVanL°w@akmmUxmULWxUUÝKōèUKUkĉKL@ÆnX@xWȯ@Û»nÇÜÝLka@bKnUaVm_xkLX¦Jl¦ÅlVb°I@bnaUmlUVUVIUKa@nmlnLlnaJUbV@'], |
| 'encodeOffsets': [[ |
| 106752, |
| 30347 |
| ]] |
| } |
| } |
| ], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/util/mapData/geoJson/tai_wan_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [{ |
| 'type': 'Feature', |
| 'id': '7100', |
| 'properties': { |
| 'name': '台湾', |
| 'cp': [ |
| 121.0295, |
| 23.6082 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@\\s@pS}aekgKSuSsMß`¡CqZ·be@Q^o@gieMp]}}Ľc_Kk
{ùA¡r[uom@ÑĥJiq©mʼnq¯Bq]ÙYgSåk_gwUisTE
ĕiqiUEkue_OSsZaWKo¡qycY£w}ĩĕS§Z©SN¥SyLÑ¡±Ks^IYPdY[UoFp}´\\¬\\j]eÜò¤¡ā a\\bnU㺹Ìs¼j®[cíȈEĝĆ`ļf¶®K|VØDdKGpVnUFjpHF`B[pMºxÖjbpÎxp¬|ΟÜÒC²®ÜApZG~dÞàV¨|¸`|²tx~\\~|dFf^zGĄŚhdL\\hĸ¼OªP®lV`p\\]Xpllæ¤CpQ|oF}fMRiNSon_²qämMNM\\'], |
| 'encodeOffsets': [[ |
| 124853, |
| 25650 |
| ]] |
| } |
| }], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/util/mapData/geoJson/tian_jin_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [ |
| { |
| 'type': 'Feature', |
| 'id': '120225', |
| 'properties': { |
| 'name': '蓟县', |
| 'cp': [ |
| 117.4672, |
| 40.004 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@EUDAEI@WNMNCBFAHFFNACDJDPBD@@GD@DIFFHEFGDBDEQOFG@EI_KG@OcJQM]RMEKBGPG@[LaCIICBWKCEEG@WBQHCDFD@HSLEJI@IHWECFGAAEKCGDBFCBSBIDCKKHEADMJMFABKOKEQAA@IEEG@GIQAEK@OZEESMOLlu@SLUTYFQCMG@@SQUAYKAACA@IB@BDB@B@DC@@BGAEFAA@BEGKJCC@AGAIHA@@JC@QEIP@@A@EGIDC@O@C@@@@CJCWKABFLBBEBSQGBAAMIEM@AKBcJEN@BEBCFMAEFEF@J@BG@BFABECKFG@AFQ@@F@BEB@@A@@AAAKAE@GFGDECEFEECBKIKDELDFEDYH@EIACDCHKBEB@BAAC@ADBHABKJIAIJICEDGDCD@@A@A@DHCHJHDFEFGBKRKBGIK@GIMHSBCH_BOJECCJCFKKMD@DNJEDEGC@OJCJHRUL@HRJ@H[DCNKDZHCTFDHCFFKR`TANVDFZRDLFARB@HPAPG`ILAR@TERNDFNHDLCLDDCXDYbHF@FEB@LDDVE@JPNfXPINCVDJJD@NJPAJHLXHDNANHhB@DPNLRMTBFRBHHr@`NBFEBOCCBIAQJDHCHLHFA@HSDCRLFTB@HEFLNF@PELBDJALFLTC@EPFLLP@tUHQJDfIHGTB^JTCPDLKAIBATFPADIEGECEMJ@JIAIHGECFEAGDI\\SPOXAFCL@BQTQBBTMZECYGAHA@GJAE@HCAEME@IECFKJADDBABLTHHG@ILEAMNDJCDHEBF@@JNFJELDFKTOT@JETBFFHBHEHKI@@IJEJ@XKEOUMS@AF@CEB'], |
| 'encodeOffsets': [[ |
| 120575, |
| 41009 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '120114', |
| 'properties': { |
| 'name': '武清区', |
| 'cp': [ |
| 117.0621, |
| 39.4121 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@FWôµ@IFCLIB@EHNBp]AGEAKAEDMGZKFGBGME@ILGP@HEFB@BXMEAHUGC@IHCLOD@X[NWHWPKAEF[@EKIOL@EKGBNMJ@EIEHKBIC@BAKMIACCFQZCF]DB@ERAKADIHGEIBCGIIECFaGLZO@EFCNGAGDGAKL@BMG@IE@ADSDEH[JGC@CGA@BMDeK@EIACFE@@GG@FIAMM@CCGC@EM@ADE@CFMAAGHBDKIEAJG@DOGCDEKAGIS@KFCHKAEHIE]BeKNO[IFIOELC@A]GMBKVYCDDgGAICARc@MW@AQE@DGI@@AQ@@BKBAIQQYEFW@CEADIGGBCEIiMEMF_LGEKMBBDWEBGRC@E_CHYGCH_IAED@FFBQh@FGJaJ}AHRAREF@bE\\C@CT`FHC@\\BBF@BID@HGDDJ@@FAHKBARECKDAZBJIVNHCTA@EREAMLHDAFFBVFFC@RNRETHD@FOJMACH@CAB@P@DF@@FGDWE@FFSIEMKQDYCCHKb^JADOCIDGNDBdBCFJB@EC\\A@BJEA@JAAAD@HHD@LFBCFF@BERDHNhZQHMBGHOACCEBWEGD@PSJKCGEUD@CINLFGHE@AJK@HDABBHTB@F`DBFLBBHEDARCFG@ABJBAPVFE^FBGLGCFG_BMLEXGAAFE@@JNRVJHFALFBEHQJCTbNDHCF@PlFLJSXCHFHfVBTNJ\\BPJXC^FAVNFCHFB@FFH@JF@\\ABCFD\\BDMCAAJKQBGAILOEGHILECQLWFENJHADC@QxNHFJNLDFA@CBA@DUÂmR@FBL@BD'], |
| 'encodeOffsets': [[ |
| 119959, |
| 40574 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '120115', |
| 'properties': { |
| 'name': '宝坻区', |
| 'cp': [ |
| 117.4274, |
| 39.5913 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@TZbB@JHD@DODCLM@AP@LL@BNH@ETFN@`E@DNG@CHLBCJA@AICFKDDBKA@\\N@AFNAGRBFjFFFL@DHLBLFQPcXAZMJ]GAVHAIZJFNE@JpDRRDCLFDGXA@EFF@CFFPDfEBDB@DCHCFCJDJIJBLI@I@CB@@ADBB@FALADGDC@@H@BB@FZGFCCE@@FMLALJDAFFFEFDFCB@@AHCF@L@@BBB@BB@FC@E@@R@BEL@HEFD@G@AH@AIB@@@FEFEBALDDEFAFO^IF@JCBBFPNJJ@D@PRDCEKBAXL@BIFD@T@JE@BHHJORFDI@@B@JGH@@B@BDDLIFFHCD@D@DEE@BAAAB@DAF@B@H@NGLJLMRDNMfGIEPMI@GDAKK@KIDIJ@GE@CFDN@FE@GFEPGV@TCDFKHBBF@RW@DD@@ID@TJFKIKLI@EP@IGBCLAEKLEN@KSHIGYACSD@SEAMBBMGEBMQBCMIGKFB[D@HDLPHDBC@IFITDLG@IIIFGVBNJDLN@VIRI@YIAIHIC@CLKZCBEE@JECEIHEAKGDGECBGEEM@@DA@CCCBBEGA[GEDBBoNAAH]MKiIAWKQoIIPMFQAEEDMH@FMSUYIeF@EK@BIOEKJEBICFKaKPFAFSE@LWCCFMHDDEKESBOGBKIEIODLG@CCDEQCEDWEMDIEIB@EHGEEDAEAa@@HqDEJGF[AECCFa@WCEIKAAEQB@FCAE^YDERDDJBLNABD@AJGLJF@FNIAMLH@FPKLJ@FE\\BFOLGXMXW\\C@KPGD@JHDGVFBWN@AEAGFO@KH@JNFAHEHYLNHFCLBFBBHo^MAFGA@KJED@Jó¶EX'], |
| 'encodeOffsets': [[ |
| 119959, |
| 40574 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '120223', |
| 'properties': { |
| 'name': '静海县', |
| 'cp': [ |
| 116.9824, |
| 38.8312 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@NGFMDATCNDR@CCbINEHNJA@C\\EEGVE@IhE[wepc¢·²^QEKIEKIgiQDkehY£uSDBMkUDOJDHC@GF@CAFBFEN@CQ@BeP@@G@HD@@MHQKi@[IGCOCESE@GMA_OcCGDu`a@VZzKDkJBLNXGDqKEWE@cFEFA@ISIi@@KMABJGBcMuFEzGVH\\ATSEUBeALCEMG@CEBUHUCGXaBPtUBBFIBFTDFF@DDKBFNGBJPHXDDMDCLJ^mBIHIL@LR\\@LCR[@@z@NFD@LLBNb@RHDBNTPT\\F@BJF@BXCFBHHBDLFB@HODADE@@JHVXCPDHCFTLBBFNCDCCCU@@GAABEHHZHBCAEdEjFDD@GfD@DXFCHF@ERFDLBH@'], |
| 'encodeOffsets': [[ |
| 119688, |
| 40010 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '120221', |
| 'properties': { |
| 'name': '宁河县', |
| 'cp': [ |
| 117.6801, |
| 39.3853 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@BFLBFJXDb@DEFD\\BHEFIrC@Gb@FBCBFFGH@FJAJFNCXFFCRDCFDDH@CKJPJFALPHTALFCFGCENDDKXF@ETEBObLELJDFALIPFAJL@@FfEZJTVENG@CNFFRBNEJOpJLRBXjJNLG^BBpMAAFC\\HHBAFDADDB@@CN@FFAHFDCHLHFBJGFCFUNKJJTD\\XUXF\\^F@DDDQXXBRLRCBDFEVCDLVDpUl@LEDJHAPRFGL@CETGPBTCDDVI@CFF@GFDCCVGLKEK[Y@MECISG@BKNSCGCKWEAaEBEKNGFSECO@GGM@GYI@DÅCMLHPTF@DJHAVVNKEGDETJ^[TJNNd@NOAMFYJ@@GFANDPEJB^aOadSTQSI@MHBDIEOKCG@EEFCKCqXO@@DMFENCDDHCCGJ]AKFoDaGGHYFDHKJiCMFGC@EQ@AEHGAC@IEAATKOHGIC@IXIFEoGE[JCFCDHNmRADFZMF[EEBMO{GU@AOW@@]ZeHBDEHBKEfQkuIWBs@EC@d[@[^EDMTKCEEcI@cDAB@FCBCACmOCG{PYHeBgPwPFDDALFFFCHQGSD@BHFAR[TaFYXMASUiGFL@DQNCJI@@D@PLDN`ETEFIGMCGBCE~CAIFDPEHGEQPHJADFJGHCJLB'], |
| 'encodeOffsets': [[ |
| 120145, |
| 40295 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '120109', |
| 'properties': { |
| 'name': '大港区', |
| 'cp': [ |
| 117.3875, |
| 38.757 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@JFFL°_`ONJKDDFIFZN xlb~yFVNRrdJGzDPVFBCTNND\\UR@E`F@@Ip@IWGUoawOEE@ÏDgK{İEEMFëCb
@KwOCDHHKBDJCDEEEAGHOABFABMCgDLSQ@CFEBMgYIDQINE@AUSwSAdYEHQMEyK[KI@GRMLE@@OqOoBOnpJ@BmEAFHL^FDB[C@BBDVFAHFJENB@sNEjQAMYsUgCSBGDJH@\\LjGR@NC@@G@HO@AfR@DM@EFEADBE@@HGDICCPlVANTC¤vgZlfRChjLJ'], |
| 'encodeOffsets': [[ |
| 120065, |
| 39771 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '120107', |
| 'properties': { |
| 'name': '塘沽区', |
| 'cp': [ |
| 117.6801, |
| 38.9987 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@|ODHnPBDADEDA@CB@ddJFFLDNSFC\\]\\@@cFD@nACOMW@M@ITURBRZNHNWRQoOj½fcqAqeiDÿÍyÓįFL|Ch@ÐFFxPpbHVJXo@@JCTR^BPABQA]^MB@bE@@FQBFVJRH@FXtPNZSBAja@@NDTLJrQTHFXZFB`'], |
| 'encodeOffsets': [[ |
| 120391, |
| 40118 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '120111', |
| 'properties': { |
| 'name': '西青区', |
| 'cp': [ |
| 117.1829, |
| 39.0022 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@LHAHRHATh`LHNHDG`HDGZ`D@FQDAHXFACNAFLVRTBFOfHDCVBFQH@HSXHEPFB@LDBF[bDbLFKJBFLADBDjLvCPEI]FGEIGCBEUSjcFiBIVWfaHCjN^HtwBBFGPBJGjFBEGECGDONMFAP]TDHQOWCMGAMHKIJEIGQ]aDlUG]VGEGDC{PEbBZmE@@GH@BCA@FMQCFMYMJECELCMI_P¯`]R±¡¸odfx\\gF@JUFFH[F@DIBGMMFaJDDQ@MCSDCBENMH'], |
| 'encodeOffsets': [[ |
| 119688, |
| 40010 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '120113', |
| 'properties': { |
| 'name': '北辰区', |
| 'cp': [ |
| 117.1761, |
| 39.2548 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ROHFFGCOJEDB}DFHANDJHFEFSM_KC@O@CJ@DIRM@CEKKA
L
FKACHoLSJSIBETDJaEIIE]E]K[MYUYQILC@GF[MGNKEK@A@BCWECAIFEFYAGFOMI[OFuDiKACBCEKIAELaKaCE\\CA@KEAFOWGGTG@ERUACDeGEPSAUQKHE`FNjNFJADHHCJFB@DEXZFRRBJLA@AR@@BJ@CHF@BRX@@NQdDBBJhHCCZDLUNA^H@BKDPFEJ\\JMPfL^AJFFGLBDGLET@HJLBCFHDCPH@BIJFCLGABHNBDEF@BCN@@FHDDDN@BNEJH@@HF@DEJB@FfLNC@AHB@DHD\\IFGTCBCF@@JNH@ALKHBHCHBDMFEP@KYbHDEJF'], |
| 'encodeOffsets': [[ |
| 120139, |
| 40273 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '120110', |
| 'properties': { |
| 'name': '东丽区', |
| 'cp': [ |
| 117.4013, |
| 39.1223 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ZV\\N^L^FJFFJIbSCAFTJTIpKDGLBEKLBjHTVNBZWbE\\SBQGE@ATCRHDGEEKECBECxOhOfAZGA_YEEWSGqRKISC@Mb@BiTAMYsOEWG@IQEURA@EF@@acUOXQRYCUDCHDTEF[SUEgAYDcVGJM`iAWDWLQRMHUHgDsDBLHJFCFDFGHBFFVEAGHCJN@RJFPIhBD\\FENCPWA@LFBAFHBEJUEARCDIAEDQBRNa^'], |
| 'encodeOffsets': [[ |
| 120048, |
| 40134 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '120108', |
| 'properties': { |
| 'name': '汉沽区', |
| 'cp': [ |
| 117.8888, |
| 39.2191 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@LMEI\\MTABKN@FCDMH@COAcH[AoēAM¡Wa[MeqpQRMXMGQYQASV@J@NNXDPmBAtJXlveRLFGACFGAYf@^X@BPV@|HNPFA\\FNEEYBCnQGMDCDE\\IHFpEFWJ@JJDGHLPBSFB@JBDGHBFR@@FHDNEjDLICGZEHGbHpCLE^BHIDDCGDCFMNE@CP@rWLDEDFFH@'], |
| 'encodeOffsets': [[ |
| 120859, |
| 40235 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '120112', |
| 'properties': { |
| 'name': '津南区', |
| 'cp': [ |
| 117.3958, |
| 38.9603 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@TLv@CNHFFBHGZFETNPhCVGNGRQXKXCjBN_HIdUZChBVF\\TFECSDGVCZDRQPWdVNA^]RBBAAOQ]DSE@F_Q@[VMCSMADUECOHycIqMQEU}zkawENRDENB@ADG@@HF@YnaAOF|CDFHUHH^kVbCR^JHIFLJNGHBDNPXGRSCO^EBMNCPDHHFAFiEIHOAEH'], |
| 'encodeOffsets': [[ |
| 120045, |
| 39982 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '120103', |
| 'properties': { |
| 'name': '河西区', |
| 'cp': [ |
| 117.2365, |
| 39.0804 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@d@hZNFdcLYXKRCtCMOFSYEGHEAGEDMu@SKAAsx]GMTGt'], |
| 'encodeOffsets': [[ |
| 119992, |
| 40041 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '120102', |
| 'properties': { |
| 'name': '河东区', |
| 'cp': [ |
| 117.2571, |
| 39.1209 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ZBVFFIGABEEA@KXBDOFM[EACJgOIE@QIMGDBHUFEEGAEHECEDGIAKQDWLKZcdQPEP@FOFBJTJ@HNORJf@DBCN'], |
| 'encodeOffsets': [[ |
| 120063, |
| 40098 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '120104', |
| 'properties': { |
| 'name': '南开区', |
| 'cp': [ |
| 117.1527, |
| 39.1065 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@NMVDCG\\E^B@HlB@YEDS@C
HsNSiMGDebUXAJEjidVTAFHDFJ'], |
| 'encodeOffsets': [[ |
| 119940, |
| 40093 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '120105', |
| 'properties': { |
| 'name': '河北区', |
| 'cp': [ |
| 117.2145, |
| 39.1615 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@DBXFADB@L@LFHM\\NHED@JKZRb]QMRAFCJBDCBQYADMCAe@QIMP@GSIAIPE@E[EGH@ZEF]^HJAXK@KF'], |
| 'encodeOffsets': [[ |
| 119980, |
| 40125 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '120106', |
| 'properties': { |
| 'name': '红桥区', |
| 'cp': [ |
| 117.1596, |
| 39.1663 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@J\\PNHEZBFEJELEL@BWGI^]FEkA@G]A[FDHUCMNEHJ^'], |
| 'encodeOffsets': [[ |
| 119942, |
| 40112 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '120101', |
| 'properties': { |
| 'name': '和平区', |
| 'cp': [ |
| 117.2008, |
| 39.1189 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@DT@FCHG\\FFOROMEgYc@'], |
| 'encodeOffsets': [[ |
| 119992, |
| 40041 |
| ]] |
| } |
| } |
| ], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/util/mapData/geoJson/world_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'offset': { |
| 'x': 170, |
| 'y': 90 |
| }, |
| 'features': [ |
| { |
| 'type': 'Feature', |
| 'id': 'AFG', |
| 'properties': { 'name': 'Afghanistan' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ࡪ͇وŐǬϠڐŶӂʮǚڦ۾njƀ̚ІɣʪҴMوǯʲĹ،˒˰Nj˖ϪԈiżŬĘͺβ̈Ҕȏĝʱʪ¡ý۷ͪ˟̊ǰώĊԼϖׂ×ࢀAƬʋӧĥяƹ७ĭࣗǭӫλȤΣĪллΛ͑ɳ̡ߛͦ։ɅΥԕ²ԋ͡ɿ̳þٝŋğɻسDҵӇ܍થΓבôǝȁԇņűටіހހåզُƚßՔ˟ڢάҢιŮɲؒਸ'], |
| 'encodeOffsets': [[ |
| 62680, |
| 36506 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'AGO', |
| 'properties': { 'name': 'Angola' }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@ȸصʌԋȘ˕͐ѯ֊æˤŠҬşŲɀɂӨԶ®ƤіHñ̡৴RfՉǞ͕ūԑÖԫ˪̷ৃȼüκsԴŴϦ¹ĘʹĩСƨϿů̿î́ყZᦵ֤ۋպԽŠЖ₭ŵÏԃϞկ~ԉƝЙDžÿՈŜ݊̂ޒªΰ˚ݶȨΆӘռːϐĘج«ӊʣ̜ɡԚȵԎ®Ǩʶͬʭǣ֚сՐĄǎΌŔʒg̎ĸៜ['], |
| ['@@ɉėɣلͼδʪƘ̀˽̩ǯƍɍλ'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| 16719, |
| -6018 |
| ]], |
| [[ |
| 12736, |
| -5820 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'ALB', |
| 'properties': { 'name': 'Albania' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Ń˷ŢέΒȳiə˗ŧ»˙ϷСƛÐgȂү˰ñАîֶŖʼƗƂÉˌθаÂƿɨôǴɥȪďȨ̂'], |
| 'encodeOffsets': [[ |
| 21085, |
| 42860 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'ARE', |
| 'properties': { 'name': 'United Arab Emirates' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Ƭ¤ɱڂƂ۞uԖ{ֺ֪ظՠՎԮdž˹ŖڑѕGçճƪŝϝǑE΅ʓΏuͷǝDZᡋъ͏࡚Ț'], |
| 'encodeOffsets': [[ |
| 52818, |
| 24828 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'ARG', |
| 'properties': { 'name': 'Argentina' }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@ߗ§ѓ̔ԑx࣑@Aሞ͒ϵрؿનԋ୲ȿϙп'], |
| ['@@Ӵ؇͠ڰॠƊǷോۊŷਆاࡾ͡Ŧχࠡ౧ࡒɭ़ŷڔƈނ٢ƎݐжLjфӝiڣۻҩ֟ॅࠃ૭ଧȽڥɣࡹT࠷ǽȇÝիËѫ੨ܙŗ׃Հν§Ч߯ઁఛ҉။ǩउĎǰԅǣػƺщԋ̏ࡱř̪͕߱ɗŜ࠳֨ʧҠˆʢѧޛʻڭԹūࡋȣ҇ߏEڃљʋؿؙࠞߦǝ˿ݭӃձটލͧ΅Ͽ˔ࢍ֔ӡΟ¨ީƀ᎓ŒΑӪhؾ֓Ą̃̏óࢺ٤φˈՒĭьѾܔ̬ěӲξDŽę̈́ϵǚˢΜϛ͈ȝॺǢƙȠࡲɤݢԊ̨ʭࠐEޚَոo۰ӒࠎDޜɓƶϭฐԬࡺÿࠀ̜ބռ߂צԺʥ͢Ǭ˔ඔࣶд̀ࢎĹɂ۬ݺશȱ'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| -67072, |
| -56524 |
| ]], |
| [[ |
| -66524, |
| -22605 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'ARM', |
| 'properties': { 'name': 'Armenia' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ƀǨə͌ƣǛɁ҄˽ʁˋΦɫϘƏḷ}ӢHżχCʝɤǩuͧʖرȼĄФƛ̒'], |
| 'encodeOffsets': [[ |
| 44629, |
| 42079 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'ATF', |
| 'properties': { 'name': 'French Southern and Antarctic Lands' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ը˃ߐĿDžɽϣಇÃq҂ŮΎÊǢ'], |
| 'encodeOffsets': [[ |
| 70590, |
| -49792 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'AUS', |
| 'properties': { 'name': 'Australia' }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@ߺ́ҜŘپNJԎÉÐঽ˽́ēگ̉ɰבǧ®ԫԭܘŗֈӝܸtϬռõ'], |
| ['@@̢ڇբ̈́˦ΡЖ͟đϋǴܛŸнɄĹɬܕąѥ˖֭࣬ѭצЋ֞λŋȯӔՃࣧ͜ͲȂ;ηȴźƢࢹԩϸ͋ڀڹʀڭtӏËԳА܋µݓơϵɩݡjӕǕχއثЭ̫ٱ˫гʝܧ͕нɅػʼnׁªˇӕ̇वޡ·ϫ͙ԕέ۟ψԥƪżѬҝǃ݁؉ܩɪӉƄӑÔ߿ʐիԮƻْțьЭ;߱ĸˢРȯزЧݝƷѮҬŶӞ͘ЬãجہܑԿ˽͏ڛٽΊ~ҀԿ،ѹ̀ǂȘઃԚןz߯Цຓāછ̝ख़˫ߡÈࢻљܯȗljѱ̳Ϳ܉qՅõݑƶğֽԁ҃ʕуʁЗˋ֛ؕBࢽ՜ҋDŽlӖкŘƚȒ̠ĺאģӼѻࡖƏӒӎͭնsʚϋͰĽڄӓڔřΪτε˳ެиʑʞ͗aјеڎă˄țʦĠӠǢȸŘрęӮΎÚٕ׀ۀˬЦΪٜ̰ϤàɴĻڎ̺ԚĤŶȀɞüҬoࢨʖҚώɊ҆ӲѐͲvҘטΠܩΦǚ̗Ј˂ТψǻĸٖҠаȮͨцƜ`ɼτĭdɂτŦОŔبϫҲӽՂMՖÿDZҦДڪϜɘſȾκӒԘ̒јıۺǂeі؛ˢ҂Ū֎ȻҀ·ۼɋʈĐԶʵӬʊ͂ñȠNJϬеɡ͉҇ͻ˿Įͱʙп̗ЭÔʁڜҫ٨ˏѠ́؈ӻʂBѰɍŶʷߤ˵ֈ˼ǐҊǠόľҤʰڞŝОÔʔīӔŌنLjǠŽˬȮѾdžҦtʈ̸̾ʂЩÎՃȾķΛ̨ёÚӇ̥'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| 148888, |
| -41771 |
| ]], |
| [[ |
| 147008, |
| -14093 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'AUT', |
| 'properties': { 'name': 'Austria' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ÛӁCǎǻ˧էLJƗܽsщȏۛÞயɐȉ̊ࠧƣĭDžԗŢѕxϝƶźȴƬʪ²ьɹŤɜݎƮЖ}ˀǣþƜšո̠ń̒ϰز˓ӀΆ̐ÚٶʱЂªϰǁãŃČ̅'], |
| 'encodeOffsets': [[ |
| 17388, |
| 49279 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'AZE', |
| 'properties': { 'name': 'Azerbaijan' }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@ʞɣψDGŻ΄ӡֽŒщϰƃ͆Ǫv'], |
| ['@@ϊËƞɈԈͺѴѵђϺʸɧۗãƣٵƟ̭̍ȝvзȽ¥ԻѲ̂дʝʚ̿×যإkϗƐΥɬʂˌ҃˾ǜɂ͋ƤǧɚȶƎضʍҐ¹ŘIJбҔɔŚʀ
׀ԙ'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| 46083, |
| 40694 |
| ]], |
| [[ |
| 48511, |
| 42210 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'BDI', |
| 'properties': { 'name': 'Burundi' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Á০ɃϢԜßʲӎҀŸͧǸȏT˗ȹǭ͛ѫ̧̥'], |
| 'encodeOffsets': [[ |
| 30045, |
| -4607 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'BEL', |
| 'properties': { 'name': 'Belgium' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@áުǪՐοҦȝħ֧ɕĝһܿϦћßדІϷͶϷ`ũ̒ڪǔ'], |
| 'encodeOffsets': [[ |
| 3395, |
| 52579 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'BEN', |
| 'properties': { 'name': 'Benin' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ۛįȹ׆ኞǛǦЮ̇̌ʱʞņѶ̀ĨǠξЪĀȀʤˮʘ̠F٘ә˩ȎӽǓͷĘɧСԳʵʳǁՉtµണ'], |
| 'encodeOffsets': [[ |
| 2757, |
| 6410 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'BFA', |
| 'properties': { 'name': 'Burkina Faso' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ֹɐϽ̍Ƀϗǰƥ˦ϙǾÅӦɮΤo˴ښۢŬּɲȴОœΚǢŘɎٴϖdžˀΒҦŢɀLJՠJáСŔϣӀչНॺȏmֻǿʣЩÿǟν˿ħ݁lϳâ˓ƉωÖร¡qӉŘم'], |
| 'encodeOffsets': [[ |
| -2895, |
| 9874 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'BGD', |
| 'properties': { 'name': 'Bangladesh' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ỉŶÆگʉѬµєDžКΕӨޟü˃ҳΧǠũƵʃĠ͗øŽۖ̅لƜԒԫɤȆ̪Հ̼Ѽ֮̔ږεВ£ôߞřު^Ӟƛϯ܅ϕµʷӍҢѥƎ՞ɶFѶ೯'], |
| 'encodeOffsets': [[ |
| 94897, |
| 22571 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'BGR', |
| 'properties': { 'name': 'Bulgaria' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ʎΉ͚Ö٦ſ«иɌবȜ̩ؒӴĕѥΏ̫˔ӏܣŒࡥ˃Uлޅÿס̊ڧɱة|Ñ֊сːƒŢĝĴƘˌ͌ˀСδ÷̬ȸȐ'], |
| 'encodeOffsets': [[ |
| 23201, |
| 45297 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'BHS', |
| 'properties': { 'name': 'The Bahamas' }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@ȵ£ɇӜ̿ʐǾՔʨۣ̎Jӥ'], |
| ['@@ࣷƅÏ̴Ђäֈ{~ɕ'], |
| ['@@ƟׯƷņ`ѮϓͪCĪڐϗ'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| -79395, |
| 24330 |
| ]], |
| [[ |
| -79687, |
| 27218 |
| ]], |
| [[ |
| -78848, |
| 27229 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'BIH', |
| 'properties': { 'name': 'Bosnia and Herzegovina' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@̦FȿσМ͓ūЃȡƽû˙țūҥݓ͈ͅΘ͋Ȅϭ̾ǻʺЩϾǬΒ̞ȕǼǨϾnܠƓ\\Ϟȅ'], |
| 'encodeOffsets': [[ |
| 19462, |
| 45937 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'BLR', |
| 'properties': { 'name': 'Belarus' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Mࣰ̈́ȚӄېːÿϔԜƚ͖ࣘࢮɁŢȻѲĴࠒȧĊЁǷɧՄսƳ»Ʊ֦Ʃʎɡ͝ǿڳljÿȠ˧ȸ՝ܝ¹ʵȁÃхͭĆݷ¡əȞ̿ƥ́ŨڍjफȬࡕàٱmҡɩГeϐʷϴԌǢLͰɷ͌ϊ'], |
| 'encodeOffsets': [[ |
| 24048, |
| 55207 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'BLZ', |
| 'properties': { 'name': 'Belize' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@OŮĸƴı̞ԔDŽZHūDŽGaɭƋεôŻĕ̝ÀăīщǓɟƱǓ̅ʣ@àॆPژ'], |
| 'encodeOffsets': [[ |
| -91282, |
| 18236 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'BMU', |
| 'properties': { 'name': 'Bermuda' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@OEMA]NOGNG\\Q^McMOI_OK@CQSGa@WNLVWHFLJXVFGJ`ZRTDLeeWKIHGIK@@[MQNi`]VDTBHCJAPBJLVFjT^LV\\RJZRn^RH`TfJjZHHOTTFJP_NOX[EYQQKMEJOLANJH@HQHAARF@ZEPS[U_IcRQXE@EEKKOCGGCQCOGISKYGUC'], |
| 'encodeOffsets': [[ |
| -66334, |
| 33083 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'BOL', |
| 'properties': { 'name': 'Bolivia' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@य़͟گӳ؈વȲ۫ݹŗ͡ҋऺˆ߾ѳŏ؆ЫֲՌαۺȖ˰ƭ̶͠рh¤נǸ˶ܩഠزíѠnȈʪ݀;Ѷ͂સƚęؽļ͓ãࣰ֛ݫऴƑ̻ͦ֨ǕΐʑՈTӦʟӟǐʕZγʓa͒এྖūӟĜͧҞɽȤԹƫڋɯρĄӏʿǥaʶјޭ^ัʓЕsҋͥƉǸ'], |
| 'encodeOffsets': [[ |
| -64354, |
| -22563 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'BRA', |
| 'properties': { 'name': 'Brazil' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@૮ନॆࠄ֠ۼҪjڤуӞеLJǒӜŖӼBҦ̡ƴ̿Ƌ̻į͔ýޔƿʤ֥ɪǏࢱLjÈଜʝҴˀǦăӐɰςƬڌȣԺҝɾěͨŬӠྕ͑ঐʔbYδǏʖӠӥʠՇSΏʒ֧ǖ̼ͥळƒ࣯ݬä֜Ļ͔Ěؾષƙѵ́ܿͽȇʩџmرîӃƟϡĪÈ౨ۏӷݏv҄ͅ֏¶DzΰұԞΓݴɜƶAԖʎċҔɊ̈Ôϼ०ֲێNJŔŴݴϚᘰpθſӔύ̬LؐӀƒǚē͐ӯĔYՀ࿖k˦̂ɸˉǐӷǂļҨѻٸÆnjʲشȞΊƐĮΤʆ¯Ǯ܅ðśՊ֞ϓɒǀþجŅڜȿʐȤžल̮͎̾ŏʂѪȜȗʼnσ̀ŵȖϷɷ̏ƅɌыÔϳԬϿЮ¥ĢǒˆϠƦ˚ɢҬíȲҚçøǢƗǘĎʐͺõЈĒӔDZξǥʺɪȊŘɿДÒ͒͊ʴؤӼޒ˺¢ȺҫҼ҈ƑxׅمەʾʩƁࡃٔր̟ඊԡШӱƏҫʶ࿐ѹఴఔव٪ʏܖ̦˅˸੭Ɣԗͯ൹ёշஅୡՙोثܯȿgɻءÒ༽ɹಓęօˇͧƫ૱࡛ƛࢁڹηȟԋ࣯Fೕ͓סύवʗڝ܅ũطƔҫƽࡓȏЧחҥट๕݉ڗ֯Ͻϥߛ։ӑɷӈψЊӟֲڇҬࡹՠ̹{ࡅٰձę'], |
| 'encodeOffsets': [[ |
| -59008, |
| -30941 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'BRN', |
| 'properties': { 'name': 'Brunei' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ͬ̾ҢЯ·՛Бǭ˹ϥѦ'], |
| 'encodeOffsets': [[ |
| 116945, |
| 4635 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'BTN', |
| 'properties': { 'name': 'Bhutan' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ˍÏԩۇ{ۿÈՇſޅ͊kǚزҒɈșѺqπɥ'], |
| 'encodeOffsets': [[ |
| 93898, |
| 28439 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'BWA', |
| 'properties': { 'name': 'Botswana' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ǜƭ˄ӡॎइήĝD̑ʚՑٰŹ՚ϝأݭع˩֓ʧ́ҙãƧГďʽ՝țہ¤БɾΟĸХșȵГЉʧпϑđȇ̐üԠӽߚɧŲAរࠤ|Ჾشಖ͎̎՜ͤʮDӂȎưÙ͔ڣ'], |
| 'encodeOffsets': [[ |
| 26265, |
| -18980 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'CAF', |
| 'properties': { 'name': 'Central African Republic' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ۜÚƺɎƔgȾȏ͐Τ͠Ѭ̌ĉ̐ʂüߺ½߆ϴ؊ࣺю;ՐƜĪΫӜԿFƋΓÄʻ̆ʍٖοҢͻT˗֠ѫΖεɆԋغͩƊˉˣęաpكĘ̹ïųȱ˕}ͧDzधнϥĎŗÝʥԕطǐؙĊ̴ۓ˸҉˓͛яùדգ²֩ƘԅѻѯޱėʐϦϧ˔̳Ѡï̠ЇѮæʢċΞÞٴȬƴц'], |
| 'encodeOffsets': [[ |
| 15647, |
| 7601 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'CAN', |
| 'properties': { 'name': 'Canada' }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@؎œުxЯ΅̵ÅΦȿˬ͆ʸ̎С'], |
| ['@@Хcઝ˂ޯІ̄îɁΗ|Ʒ'], |
| ['@@хŝൡϢʥ̘ݩ̌Ưʈࡻư͕ҜðȚࢨǿԨŵ߄ė˺̃дЋ࠼Όҩ'], |
| ['@@։ܿո˴֠ǵ̏̉ݚɱϰȴ࠼ʵʹ؛טƞņѿʼԷΝ݉ϝփǂǾیɻńইܯԅצЂ߫Ȳࣙ¹࿅~ŹʠԼ̐λɬ۸ԒࢄԶӎܲ̂϶Njɫ҅Չ'], |
| ['@@@@@@@@߰äʥ॓ܶگͯDԑϪ̵ϮчʾƻτºˎЂŋ'], |
| ['@@͡ѳχîəʢ Î͖ʦΆkɈǣ'], |
| ['@@ঝҧץnǿɪزϲ଼SiǍ'], |
| ['@@ƼυјżӨɗं˽४ʽöЍؤÞ˥ݙ˃ಳȬҽϚ࠭ҁѣ˿Ӯଗăܴдņڌ˺ޔ؈å'], |
| ['@@ष¥ȿЪΦҼޖŜپɷXέħřձʛ'], |
| ['@@Է̍ଉʬۃğଫϘ݊ʼטζࢼʃԎƯʦDžԠ͍'], |
| ['@@G૰ڄեʡح߾֥࢚؈ؖܨ°ईஞÝఔūૼй¼зس҃פ҇ŃУחୡŻࢃʨʣуߵ۽ʓοই֩ளÇڏΡÇձĿਉڻ࣭ु͙ڏ±উంƕϜϼّ୲ǔ༞εࡀ͋ЅɳࢸΟ൶µࣴąƍܫʼࡋ،ळనߗ٨˚ҔࡺѭೢףѶഎЀ॒לҮהç֭֘܌৷لলࢤνݾ˫ಾגȘɫࡸć۠ɚ˵ਚӣʮ͙ຄÛ}۷˪ਜ਼ގſ،ӵҰߦऔϸٺݣબੳघ͵ՅӁݰӓംɏբˍͬ܃ټŏͶͅÖऻ؍́̏൯̗ۑƋᅛǮుPࢇÍ۱ੳωॵޡ܌Ɛഘૄᄈ۪సČݔЫߍ֟ˊࣟ˜هતп൸ŨࡆीÎ؍ժ̥ਣսᇷԁͽयٓÖ܆ฤ۞णĹջӆBନύʐ֛ƛ˧ɚٙىʱٹ̕ϡΥŽˏ¥čȹAMϛƷࢵĿßˍ͝ޗBࠛGϛƅƊǑøʯeďષлࡽſউ҅Ɂ@˷ƂĥŦnĔȂ̎ЂҦʘӺǙܴǵނЂľƬūĺɳ@ǛƆ¥ȤǍēɥ¾ĊȡĊćɚٵːڹ˪ࠑ͘߁̨ݧʃ˝SਕɔڻʼnࠁʺƆו¾ʻƜƫҤ˳IE͓BᮝA᭯@ᡃ@ᠿ@៙@ᢡ@ࠛ@᠁@ᛷ@őFࠜδຽΐҳݖŤԨΨƧڴ৭؎iѠҲКwՌෙॠՁޑϚ֣ΈѿѢࡇ˕ࠇҹݛւדπࠋɸࠟ|JⷎNᷲ༬ȭЙ࢘û݆ΖৰˀఢĹ఼τ൘Ⱦ־ΑظȠȊЄęෆݫ૦֬ŖّਔƐ͆ʖৰ·౼Λዸ̭ୄƛࠖÄଊэзຶǷᗘIJܒƦࣆԋࣴьࡩΦժ˼৾ڦĎڴȩࡊҗरäϛಬƄ௬oĭԺݞƦದ˵KߑՖڠڰuϞࡊ࣑কͺäघশ؎ૌƇࡘχଞॅݗЭ༠ǝ'], |
| ['@@нϿሎʬୠщॊіސ˟یࠛфΒࡰ݊Ŭ࠲ƇशՆࠉʼץථеະЉĝσൡã՚͓˱ູ̯Ƃฃɪঋ»ཅ˷ᒃűāҕІଫɮݙģਛږ֔ĚಘƜஈરƦྷȞᅗãjѷ̴ዎͲಗ[ืɚ۶ـגͮᖬԠNj'], |
| ['@@݉ևಹך˸Şٔȁ'], |
| ['@@öɵࢿ|ࣟjࣿőʑ¼ऍѾ̠ИÈነěชң'], |
| ['@@ڎԽޤڴᒆΈࢅůջဒʒߒͮሀыୄЏŊν༚Ȑ࢘᎐ܸͩߐϹጘչೲȁீޙೖÇʽכ้ঋਗά߲ઙĿŁӕࢪӥଜϯΌɟմࠩ́ɪᑏڨஎܣԕƎ̉ᗱͲᅩӤ৳Ц̌ʂయќТ`ʑᝡƅ܃˾ֆؤdႸņ˫̜̊оચࠊɳϊ͕˾౿Рၳ˺՞ɆࢷԺ´ڏ˸҇ʛŅᵝȈᄫʚഹŴۥ̐࢞ϦHˉ࡚٦ݨࡺ΄ᓪɢأի'], |
| ['@@ǯຄńɖʑЕαƱݳ൝͗߳ê͎ᐡٮjˎ႖ĽएռসР'], |
| ['@@࣓عय़Խ݆`кѮΨ࠰ɮცྈȱళݟǍ'], |
| ['@@ᕍЙѷςኹѺήΤؘܰւࠑԦᭊƀǧᒰ±ࠄʑࣖΝ੍ɃᏝןਫי@ν'], |
| ['@@ҙ͙Øৱɖ҂Ϛீɨܼ̬̍ˇ'], |
| ['@@ٞϵљϣس൱đࣗƈjӬ൝ÝÁٮࣜౌ˺ஂµÜŎ'], |
| ['@@̙͢ݠƘࢢƪЩԝЋ᭗Žᑯη౩mŅ˜პϊ④ij୯Ʈପࠐ߈ɾᛄ˳ӻฺÛறߨޔ̪ࢄĭ˲Џ'], |
| ['@@ढ˓ကFܨˡȑ́८ȍՔȧଊ௬ëǼႊðീÏ࣒ͅȊԽɟభǷĸᜱŻႫcഫļᖁ˔̃ҦĹжࡇξĺঅʼ͂ΈႾÁ'], |
| ['@@ŗ٣٩̇£༝ΫŹଗǼ@@ුؼႮծಆ[ସŬ'], |
| ['@@ϣy༽Âɡɼၜ]מƻĵĩ'], |
| ['@@༩ʋఝ˔ڼˎ௮Đஈſ˩ʥ'], |
| ['@@৽ǏඉBbŤࡴʦҌદǝ'], |
| ['@@కǥۃȚέ͂áΎજӪÅ̇ɫ̣'], |
| ['@@͜Ε൏Ĥ൩˘ሏߺʠ৫ȮÕ͐ŕᗢ̫ٞЍ'], |
| ['@@০˕ଽʟ༇كÓდņࣗ΄^̦ڔɢOए˨ՑϠώʲࡴÎοȖዜ¨੶҅මǵ൞ǃڒև'], |
| ['@@ᖢßᅮŅɫɡᏅη᎙ǟݻȉᆬJጡԙേʃ෯ۇႿƓՙǡᡷěୈĿׇƭ۞бߙ˽ಛʃЋ͡୫ʣŞȏ෬lȳᖟԋᔧɴឿŻధĸཟªĿЖ༊Ȑб؆ԢÐᖤγբഹLjڼ͘Ȩʄ̊͠ΥѠᘞڒĝ಼̪ቃĬ᰽Á˸۩ͼগʘȁ˺దLjঘƌం̺ਬ©ࣤɽٔҒૐƈບĢᢲҀĝƚᆔÁᆒÁ'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| -65192, |
| 47668 |
| ]], |
| [[ |
| -63289, |
| 50284 |
| ]], |
| [[ |
| -126474, |
| 49675 |
| ]], |
| [[ |
| -57481, |
| 51904 |
| ]], |
| [[ |
| -135895, |
| 55337 |
| ]], |
| [[ |
| -81168, |
| 63651 |
| ]], |
| [[ |
| -83863, |
| 64216 |
| ]], |
| [[ |
| -87205, |
| 67234 |
| ]], |
| [[ |
| -77686, |
| 68761 |
| ]], |
| [[ |
| -97943, |
| 70767 |
| ]], |
| [[ |
| -92720, |
| 71166 |
| ]], |
| [[ |
| -116907, |
| 74877 |
| ]], |
| [[ |
| -107008, |
| 75183 |
| ]], |
| [[ |
| -78172, |
| 74858 |
| ]], |
| [[ |
| -88639, |
| 74914 |
| ]], |
| [[ |
| -102764, |
| 75617 |
| ]], |
| [[ |
| -95433, |
| 74519 |
| ]], |
| [[ |
| -123351, |
| 73097 |
| ]], |
| [[ |
| -95859, |
| 76780 |
| ]], |
| [[ |
| -100864, |
| 78562 |
| ]], |
| [[ |
| -110808, |
| 78031 |
| ]], |
| [[ |
| -96956, |
| 78949 |
| ]], |
| [[ |
| -118987, |
| 79509 |
| ]], |
| [[ |
| -96092, |
| 79381 |
| ]], |
| [[ |
| -112831, |
| 79562 |
| ]], |
| [[ |
| -112295, |
| 80489 |
| ]], |
| [[ |
| -98130, |
| 79931 |
| ]], |
| [[ |
| -102461, |
| 80205 |
| ]], |
| [[ |
| -89108, |
| 81572 |
| ]], |
| [[ |
| -70144, |
| 85101 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'CHE', |
| 'properties': { 'name': 'Switzerland' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ƫŹȳϞƵіwá΅χƙةŀǻЏơƄһ˵Л¡αǶ˽ςБſ^ϠؚҾɈϤûɲƞMǦǼ࣒ʱ'], |
| 'encodeOffsets': [[ |
| 9825, |
| 48666 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'CHL', |
| 'properties': { 'name': 'Chile' }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@Bም࣒@Ԓw˧ͻܛʻЭӻä؏ʨ࢟ŨੑҸҎୃशۘǭ̟֗ѢϬ˘ֺޠΎװı'], |
| ['@@͢؆ŘĺɁ˿ࢍࣵгඓǫ˓ʦ͡ץԹջ߁̛ރĀ߿ԫࡹϮฏɔƵCޛӑࠍpۯٍշFޙʮࠏԉ̧ɣݡȟࡱƚͷǡȞॹϜ͇ˡΛ϶ǙĚ̓νǃĜӱ̫ѽܓĮыˇՑ٣υôࢹ̧̐֔ÄgؽΒө᎔őުſݝPЙȷݷ̣ƉΣoॅ˚१ג@@ਲ਼ӔˁՒʄӰх֒ŅΦ߰ࢴٰౣʔߞݒ˸ඊत̏Ѯგ֝ɠʿՉŠ˂ல˺༒ϮָʍࠎéूΠԨപഎΤబȗ఼ʤۚĵਞӮਆưྺ˒ნˀሤÕ൘ǩќɌɦњЬֱŐѴΡ˅߽Ҍह'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| -70281, |
| -53899 |
| ]], |
| [[ |
| -69857, |
| -22010 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'CHN', |
| 'properties': { 'name': 'China' }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| [ |
| '@@ԑഓΫۏѷ܂ĩخӶࠜڦَϨʡƣԓ', |
| '@@ܩЗۏʺyܢаϠࣾɾӚoȊ͍σσșӟ' |
| ], |
| ['@@ฬˍׯͼ߃౨Cܰͨ൸ʜѳݱ͙̭˽ः֡ࠇ৵ƪܝ̑ɜܙťѕwLяթӺͯһಙαƀѹܩЍ˂ֽऑҋۃա୭ʑأϽࣝɭ҂ϴǭ͞ږ֠ѹѲܷ̓ॉԫթ࠙¡ѓϻѸ֩یƏϕڔʕसݚ͝լuƌѱஓɻϻҏࠇућיࣜҥͦࠝԞޓ֮٥_دՅɯȪ҃ӶʻŻۃɇڗҷ÷ؗࣧڹિޭোିޡୟۻृĩԣύ̃˘Ӈй୭сࢵŹ˻ࢱҭ·ə؎Ȧ͘ૻːЇƍࡍɔЏƄӜޏƶЙܑ̀҃ࠇīڡJ҉ȳѥūŶ॥҃x÷Ȣ}Ύ؝ʓεƸر͂ʔۤՏǎȧޜࢱƓĴাߔۮۚ{٠νȨ˭ӶӭÙࣟŲ˴ΜϿԺ׳Ν۵ȸॷއسڳĿοɦѹrȚґɇرëڌԟǭওĈोȖڿτٵǔ˯ЖҽŦࡓոکʴΑȩଢ଼טࠛՒɽऐőіͭјĐۆࣙঠ൧ͼʝ٦ةϼƫʌųӎ͜ԛȔ˟ďɇިʈȔśȠߤЈǐࢸő͆՜ંIJͮ̚ҔŠȐãӐּɔݱฦဘͲјȈ؆ຒဠˡҲϞ¢ࡆۦĀٖ֔͢èɚו۸ѽப̿׆ڱ͕ঙ̢ηূƝଆŝ৪ԻԲġϤޟӲӿऒnჄȉŜࠦůఔԛ৮BόʽঐҌബ̈ాঘ̒҈ך˰Ƌˤˍ͔ѴըӀùࡺǝ࠸Ѿ͚؞֊נʆŐڐĥĠ̘ݿזګː٥̳ࠣžӇŃɏΆר࠾Цو̓ஆՎQτݸࢾҲːWҪңȦۜмਰƲvసʡ݈̱ࡏ̀α̊ԩ̶ࠕ'] |
| ], |
| 'encodeOffsets': [ |
| [ |
| [ |
| 124701, |
| 24980 |
| ], |
| [ |
| 112988, |
| 19127 |
| ] |
| ], |
| [[ |
| 130722, |
| 50955 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'CIV', |
| 'properties': { 'name': 'Ivory Coast' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ϣUוǒ՟Wহƥʍ̯ࠫNjvÞۖĄŀ}ͨΣΚˉÈʕɲǾώčО ʔƄB¸ξÝnjĄŜ̸ĶȹڨȗΎæ˸ǘÞŊúɸųٮOƸʖƢgʎĦžΫȞłΌŰϚǽƦ˥Ϙǯ̎ɄϾֺɏɠΟ۷ɕेθܣͧ'], |
| 'encodeOffsets': [[ |
| -2924, |
| 5115 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'CMR', |
| 'properties': { 'name': 'Cameroon' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Ľ°ӻŇԝŒЋÅnŬڒ͟֊ϧƚǟϖɋŦXɶɎתЎ߸ʒRԄӮ͈bҾΉ־˲ĀΔȌͺžь҆ΊǞךDzȊŢѨɜ՚۾ٲ¬˨ĠƲͫͰˌʂ¶ͮ՟Ê֏֏ҜޅҷTʁÏϥČǻЅӸөμƛŠΏˆ׃ſɩх࡛ȫƳÝٳČΝåʡЈѭð̴̟џϨ˓ϥĘʏÓґڛȤڷɜ'], |
| 'encodeOffsets': [[ |
| 13390, |
| 2322 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'COD', |
| 'properties': { 'name': 'Democratic Republic of the Congo' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@»ঙͶŕˑ̗͓ɟ͍ѫǯϷ±ګț͍OهʍɹԃŗÝýҟɄϡÂưޝċѧǘӣӤҹҒͥĒ૿ƙɣĵʇՙȊχƫষĻࡇɨƫט͝ɲƴìٟࣟR·Ҧ̳ΨٟŠȋѰԣ˅ڧŞ˫ϢՕüϽqµʾ́rϥºԳųιtȻû®ৄ˩̸ÕԬŬԒǝ͖eՊ৳Qò̢ѕGƣԵɁӧűȿҫŠˣş։å͏Ѱȗ˖ʋԌȷض៛\\̍ķʑhœşʼɊĘμƎɎ̪ǰɚđ˼͐ҜSÄʃ̼ƩӶՄӨШɆː۔θࠆϬўքМĪˌt̰Ǝ̆«ӊŀݖǐԾʦ҈¸Ԕúה͜ѐҊ˔۔˷ؚ̳ĉظǏʦԖŘÞϦčनоͨDZ˖~ŴȲ̺ðلėբoˤĚԘۙϘķɤƖϲÅҶDzȦΫ݊֏'], |
| 'encodeOffsets': [[ |
| 31574, |
| 3594 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'COG', |
| 'properties': { 'name': 'Republic of the Congo' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@̿˾ʩƗͻγۏࢸٖҪ̓˾ɂ֦ĺäό҆ЗݐʴЈł֒ĝڀЉӺζȽǘسçɻѢÔξڸɛڜȣÔҒѰԆѼ֪Ɨդ±·ԓʥ҇ǏԽĿݕ¬Ӊƍ̅s̯ĩˋփЛϫѝηࠅۓɅˏӧЧӵՃ̻ƪÃʄқT˻͏əĒ'], |
| 'encodeOffsets': [[ |
| 13308, |
| -4895 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'COL', |
| 'properties': { 'name': 'Colombia' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ΫȤЭ˨ʅƅ܉Ŝȱΰƽ_Ӓŕʺ̼ÚтȢ̦иÊΞՆ͐Ѵ̳ȦDŽӦȏސǸɚƃ܄ͻ҄ņТ˔ÑǂʠțӶĺŬѢـהΌĚT˦ƺ܂ӖϸՊfäǪڂéڌъ͞ȊОК̖»ɚɛǍ˱գƕɇп͗ʋʓ̷ĹɷӭѢÇņϭȄȁâij̵ǫȸéȨ̉ઊĄӦŃעܡͼĚӐĪ̔ƟƱҍȇ˯ßǜ֑ʆʟȉэл̨ȃɠ̋ʰ࠹ǁĻǏӸɷˊ˥́࿕lZԿӰē
͏ǙĔҿƑK؏ώ̫ƀӓoηϙᘯп҂ʣpժࡤٟϾԍị̈ƤҧɝصŀӵࢤϳɐˍІ֑Њɡā'], |
| 'encodeOffsets': [[ |
| -77182, |
| -155 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'CRI', |
| 'properties': { 'name': 'Costa Rica' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@җȆǟǮĬƤȄɷȪͥǔ́ņÅʖəƮÄʑǗȩȓɸˑĊŗǞLʮŎˆʁŠȖnjŴňֆɝȖŊˊéƔǥʜÇȪDzɈҙ͖ͷЂΩ͗õLͷǪűűıƱëǟ©Ǖ'], |
| 'encodeOffsets': [[ |
| -84956, |
| 8423 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'CUB', |
| 'properties': { 'name': 'Cuba' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ܨÑڊW߄˹̭ͮĨ̔ȡ܈ԳԺϛˢ\\ԆǟÕʁئٌ΅ıȟ֑Ń֡¥׃âளą֜ҶɔէÈ̃ʐȥӎӃɦʥǬભž̋ǐ̀ɀࠗ¨ѧΏ[ťȳеğΫĂѺʸǼ̤ϞȈіǎَĄȰĢ'], |
| 'encodeOffsets': [[ |
| -84242, |
| 23746 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '-99', |
| 'properties': { 'name': 'Northern Cyprus' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ÐJŨȮYކʢ֧ΧÔƿęLJÙűj¥iĎѾNjVɫïƿ¬'], |
| 'encodeOffsets': [[ |
| 33518, |
| 35984 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'CYP', |
| 'properties': { 'name': 'Cyprus' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ãࡱͿЩŊȟͶЎǀ«ɬðnjUÒ½jč¦ŲiLjÚĚ'], |
| 'encodeOffsets': [[ |
| 34789, |
| 35900 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'CZE', |
| 'properties': { 'name': 'Czech Republic' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ϯǂЁ©ٵʲ̏Ùҿ΅ر˔ӃΰѕȬėΠƧʠؒǾ̸ȾǎɂdžɜīϒĖЊ˓ؼñ¿ɳҘǧŲɒּĥĄʿز»ϮЯʡCŽƯȕÅȑLJ¡wý˹ēϋbšȁ'], |
| 'encodeOffsets': [[ |
| 17368, |
| 49764 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'DEU', |
| 'properties': { 'name': 'Germany' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@d͗ࡔțS̗ࡢǂҾɰॊͧІˋȞёɹɣ̨̙Ⱥ҅ß́Έ՛ϑĕɛĬɁDžǍ̷ȽؑǽƨʟĘΟіȫӄί̑ϯ̟ŃŢշýƛʿǤЕ~ƭݍţɛыɺʩ±࣑ʲǥǻ܍Nń״ьֺƸЇɘ´ςǗȐĨ֨ƗࢢԎ@Ɉ͂Ⱦޔƿ˴ǐDz۰°Ƽȃ֮вȓ̀ӈٌōՠŸ'], |
| 'encodeOffsets': [[ |
| 10161, |
| 56303 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'DJI', |
| 'properties': { 'name': 'Djibouti' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ȤʹΑӏȩήɯ̱҇ȅƬȭÏҷb_ʮßɶ˴Ѐ̐ϊήñʪȴ'], |
| 'encodeOffsets': [[ |
| 44116, |
| 13005 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'DNK', |
| 'properties': { 'name': 'Denmark' }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@ԋڹ࢟ӄŝΒ˨ˎу'], |
| ['@@ȵ̓ʡĞɮХ՟ŷًŎͽҲ}ƔɪʌʦÀ̐ɴڮʂѝʟ˙ĶɽҘŵ'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| 12995, |
| 56945 |
| ]], |
| [[ |
| 11175, |
| 57814 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'DOM', |
| 'properties': { 'name': 'Dominican Republic' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ŀƞپIӾɏɜtƴ̕ҠhʡϐЮ̷̯ͿЍǼϫˡ¢ƱƵ͑½ŷȲˣťͳֻɏƆ§ʎjɬɍʦȲƚÞ͒óҜ'], |
| 'encodeOffsets': [[ |
| -73433, |
| 20188 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'DZA', |
| 'properties': { 'name': 'Algeria' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ᮩཽᝩஇϑटćUϵƌԹʊȧЀᬻᆴᬻᆴṕᎠfnj@ÊQബب࠼Ÿێɦ͎тচͪجӢòϞ̶સƚƸ͜ɛDz̃ࢲ¹Ԟ́ՠ߰ҠࣦƢՌΎ߶ʰƬർæшůߊͨ࣌Pȝֺ¾ǟћƄߟȡۙԭҵôمۊԃRȯԮΪຝ˖ݏ°ϵƧۇÔϥŃҟòՇͫΗӺؓέ̘ҵϼƸڒϷςՃ'], |
| 'encodeOffsets': [[ |
| 12288, |
| 24035 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'ECU', |
| 'properties': { 'name': 'Ecuador' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@҂غǻξ͍ϵԉςǞʀƙބ̎ŴƺԼ͆զÍ΄ҢǸ׀Ͱࡀӑƾ`Ȳί܊śʆƆЮ˧άȣŞٓʽճࣷ࢟য়ͧԥܵǃ֣ӅΙъͻĞáw̮ʈȨıΔ'], |
| 'encodeOffsets': [[ |
| -82229, |
| -3486 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'EGY', |
| 'properties': { 'name': 'Egypt' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ɽͷǹىɫѩȝƥ˩˔ϛϒஸđùΐࢯԪࡋٌವ̴ҙ˒ӃݮछǗƣճݭƨǣΏ@Ὁ@@@ᶶ@ᲴʥڲɐŻά̤Ж૦b߲ɝ࠲ʛϴſ٨ˊΌʊݎêװŃɮеȜ˜ڨȣټ³аɄւ'], |
| 'encodeOffsets': [[ |
| 35761, |
| 30210 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'ERI', |
| 'properties': { 'name': 'Eritrea' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@˻˖ΉӰϋ˒ɏܷ̄ͶֻXȭǬӯȡԛϢʽطǬęʹβఀĊ֒ˆʴؤƐьӒӦঃɴޗҢУବߏҲӍҖӝˀ˿аʧʩȳέò'], |
| 'encodeOffsets': [[ |
| 43368, |
| 12844 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'ESP', |
| 'properties': { 'name': 'Spain' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@¦״θஒ؆ਊƱ૾NࣂƝۦªമͰ͛ϡ̨ǺीϝআŊ®ӥߓ֓ઁǯõ˱ԩү͕ہ͞ӑӟϑǹճىǗש٥੧_ߟhՃ͍̓ͅЩê̵˴ʃӚžé˦̶̀Śɬ̃ʢɶրͳԌδèЈƎŬZپϲɪɻфөƝŁӹCɁЬū̥ɇ'], |
| 'encodeOffsets': [[ |
| -9251, |
| 42886 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'EST', |
| 'properties': { 'name': 'Estonia' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ĮӸ̱ŁՓ̘ñӘਫ਼ɼŨ࣮Ƒࢂ|ŴƣׯӝʞΫˉۙDܡ̸ρļƩ'], |
| 'encodeOffsets': [[ |
| 24897, |
| 59181 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'ETH', |
| 'properties': { 'name': 'Ethiopia' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ԜϡӰȢȮǫּWܸ͵ɐ̃όˑΊӯ˼˕̏ω˳Ͽàɵ`ʭҸaȮÐȆƫǽ̴̕ҧ̴Й̛͎ᩨঽۺNᛛᡃફݟףաeɯ˅ַB˴ލΙʝΓ֕àȃĬȟwˇT܌ב@˹ˢ@ҾѧƘӻࣴϥȚƧʹэЦԧÒ˸ӐҀrŲʰ[ݲʞࢠЊɾĎ΄ήٜԔиࠠƆܠǫʾظ'], |
| 'encodeOffsets': [[ |
| 38816, |
| 15319 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'FIN', |
| 'properties': { 'name': 'Finland' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ūיಀ֓ޡىख़֡ܛݴس΅յఘֻ́ѓޭӟᅡੵໃá๑̯ൃǯӡҞ߿ˠȈࠢСݶАӪނՆ࣮֖ǬēୟЈ˳͜uಒֲ૩ЪԊɞतѻલ¦ࣘȭߠϊЬ؞ಬ˶ͯΡכ'], |
| 'encodeOffsets': [[ |
| 29279, |
| 70723 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'FJI', |
| 'properties': { 'name': 'Fiji' }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@̂ʍƓѭԳŗҩļąτ͖̀ϤĻȼƐ'], |
| ['@@՛ǯŅ̼оǤˊ°Ӱˀ@ЧՕȷ'], |
| ['@@é@ШǨĽЗ'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| 182655, |
| -17756 |
| ]], |
| [[ |
| 183669, |
| -17204 |
| ]], |
| [[ |
| -184235, |
| -16897 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'FLK', |
| 'properties': { 'name': 'Falkland Islands' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ԌȿԌʹڦϙʥ̋ଋʥϙ̌܋ϙпϚ'], |
| 'encodeOffsets': [[ |
| -62668, |
| -53094 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'FRA', |
| 'properties': { 'name': 'France' }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@ˣ٭ϡǠș֢ǜ̺ը͎Ɯܛ'], |
| ['@@הЅќà݀ϥȊñʎjЈɗெƷыֹŃ׳ɱƝϣüɇؙҽ]ϟВƀ˾ρʁʚ̿̅ʯɐٱҖŃĩηݿӅစɬ௧˗ĩԑঅʼnिϞ̧ǹϢͯ͜ѢԎdžူࢁࢤإю౹͒čؖઠǾථɏˇॎߌέዠپʨێܾǞŪ̑ϸ_ϸ͵'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| 9790, |
| 43165 |
| ]], |
| [[ |
| 3675, |
| 51589 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'GAB', |
| 'properties': { 'name': 'Gabon' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ࡹࡔ։ۚԙࢄ˨ǾˎȲؔǜخ˴¶SOৠЌÆԞőӼňľ¯ÓνɼѡشèȾǗεঃЊӹĞٿŁ֑ʳЇݏ҅Иãϋ֥Ĺ˽Ɂٕ̈́ҩ'], |
| 'encodeOffsets': [[ |
| 11361, |
| -4074 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'GBR', |
| 'properties': { 'name': 'United Kingdom' }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@҉ֽًǦԱ[ǦҊǥ҈۴ࣔԳ'], |
| ['@@࣋ࣧࡦŘऄIɕۅݯݩࢄÃäĕݠֺƇԬढ़ʈͧৰDžķ՝ѓʗͲѣݱѯRෝɱϻǒ։ϿޥĪם͍ҁǘࢨݪǺOBಽƔʃͰ࢜ʺҡҐdžռఢ÷D@ŮӤ֛Ԯ_\\৵ƨȧɬ̨ϒˡɴҍЇ·߶щє̨ࢆٶھڤá০ì'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| -5797, |
| 55864 |
| ]], |
| [[ |
| -3077, |
| 60043 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'GEO', |
| 'properties': { 'name': 'Georgia' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Ųάȿִӟ̲ҭĬ̯ʴĺIJ܄ƝఆƋଦЕƦƻԚƂǭʴ·Նșɓřвғŗıҏºصʎȵƍଢ଼ſ߳Юࣅ¡'], |
| 'encodeOffsets': [[ |
| 42552, |
| 42533 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'GHA', |
| 'properties': { 'name': 'Ghana' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ӯҳ˽ݳʑݡʆͨηܤɖैΠ۸ɟŗنrӊฤ¢ϊÕ˔ƊϴáÕʿΖџC؍Ąڍɂ̫ȅݳäйɢՓȈ̍'], |
| 'encodeOffsets': [[ |
| 1086, |
| 6072 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'GIN', |
| 'properties': { 'name': 'Guinea' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ʃtǡͷʁJǏǴÈͶΗԨɕħǵmɳ³V̮ƇɘʔǻΜɹ̜ڥDțǁɵoƝǷīɹ҅σρӼ͛͢ɋŊȿǖħϊūȂʓƐώЦʮeɖƘȄDƄŎï˨ĢĖd˶МUȱȄlÚĤҜáŨ´¶̭ƆBɖŒƔɸɇάãɲǺ˖ŒȬŠǚuȈȁĴɳΆΙǣɏ˙ǴĊŀį«ʡʲʍǗÝå˷ȘȺڧ̷ĵăśÞNj·νƃA'], |
| 'encodeOffsets': [[ |
| -8641, |
| 7871 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'GMB', |
| 'properties': { 'name': 'Gambia' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ņόࣶzȎȦˊ`ͨȷʼIˢƚǞʏεȋιdέǰ̷ȗƭQȫŝއl'], |
| 'encodeOffsets': [[ |
| -17245, |
| 13468 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'GNB', |
| 'properties': { 'name': 'Guinea Bissau' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@҅ΘΝÈȕʀLŸʯǴÁǶѼƌ˦ɦĨ༈c˵ġĕð˧ƃōȃCɕƗʭfύХ'], |
| 'encodeOffsets': [[ |
| -15493, |
| 11306 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'GNQ', |
| 'properties': { 'name': 'Equatorial Guinea' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ƿŴ़̀െmPয়T˳µ'], |
| 'encodeOffsets': [[ |
| 9721, |
| 1035 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'GRC', |
| 'properties': { 'name': 'Greece' }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@Ҡ˱ٺ¶شÑqƣҜĶĿʛíTƒਁǎƺΦ'], |
| ['@@ʹՁȥĥԟ|ѫĀৱɓҿяƋҳAѻўƿȁȊԅрЁ̓ǿҴϯжʑ^ӅޥɠʜѕՓĕ͈ݏ֏Yۍμ̿ڦƧ֒͝ϮљӐÉʆϸТ¼˚˘Ũjɚռö͌ȀҖgƒƦdžت{ڨɲע̉ކĀVмЦɝ'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| 24269, |
| 36562 |
| ]], |
| [[ |
| 27243, |
| 42560 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'GRL', |
| 'properties': { 'name': 'Greenland' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ᬜԆ᱒ੴ̴ᲈĄ䀦Ŀ㉊ڗ༅͕ộ⭏ćшƫᲐĠᡚ́࿈ʴۦ̝इӧᒞ̺✘͚ᠼNjҾΫ⃝ױӃȕ᧑ơወ¡ছؕگկधշಽ൧ˇ༂ѽȢ܋࣍ýઞܡህÑঈ˟̑இŽE֩\\Ϗပΐћɣଌȿ઼ԣ͈ڱກlj٫͖ਣӘ˼֭উѵᕖ¯ᖯܵᗿڏឧ́ओIࢅ͓ୟࢱᅵכׅ૧ȷȝܛԱ[כыտോڧͺٿϗљࠍஅ½ۈဿLࠁҢ֕ࠐฝਲэոŗݮޢ̢ئ֗̒ࠪচొ̺ͨΘǬڀॡ̕қůݯţਏ˜Éְ͢҂ެ\\႔ɟՔݩ˾࠷ş۫ȼमԝ̺ڗৡࢼ੯͚XΚᖷӮᄻÖᖟᏅ×ইˌวՈᕂ˄ၚ¬≹ɖ΄Ś͜ẊИᶎИ̪͘ᗗ̠ܺͰ᯲זĚΓϘጲɜᣚƂᣖRࣺʽᕺҨፘ̽áპ˙ፅҐŘή'], |
| 'encodeOffsets': [[ |
| -47886, |
| 84612 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'GTM', |
| 'properties': { 'name': 'Guatemala' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ћƦԻfϩǖҍΌrʖĮȠšƾКۆFt˸Ƌ¾ġǺ̵Ț̹ˬϜDBӂBަUOڗßॅʤ@˚ƱòŰʘŃϥ͍ЉɻÏljâǑǧɇȟ½¬ıƿġ˽Ƀ}ŭ'], |
| 'encodeOffsets': [[ |
| -92257, |
| 14065 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'GUF', |
| 'properties': { 'name': 'French Guiana' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@͉͑ГÑŗʀȉʹɩνǦɈΪòϤƢή͛ӸáֺѪܠ˸ğؤȥࢸۿƔ·ӻޑʳأ'], |
| 'encodeOffsets': [[ |
| -53817, |
| 2565 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'GUY', |
| 'properties': { 'name': 'Guyana' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ր̯Դյzџ̈́o҈Чͪ̇Ƈݱԛɕ°ȣƹџϊ؏ːAŎӃԢܳȱҫî˙ɡϟƥ˅ġǑЭ¦ԫЀÓϴɋьƆܐɸ̐ȕϸ˿ŶŊτțȘѩْ֩ɬɲiϲԬƊȾƾ˽̸ô̬ږӲ'], |
| 'encodeOffsets': [[ |
| -61192, |
| 8568 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'HND', |
| 'properties': { 'name': 'Honduras' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ơˀʭòÐʹŗĞǣÒσijŔʩƈǷǚʛìǨɈáǒÐNJЊɼϦ͎ĔȂƨʊ\\þ垦ϸùϲv˒ĢİĦˎ©ȪÉɘnǖòϨśƄkʲƿʐį̏Źɜɳ˽jśŕ̇ŋɃAȅŃǙƛźĕ{ŇȩăRaǥ̉ɳƹıđĽʛǞǹɣǫPȟqlЭūQĿȓʽ'], |
| 'encodeOffsets': [[ |
| -89412, |
| 13297 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'HRV', |
| 'properties': { 'name': 'Croatia' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Ȳ͗ˊʇ͓̓ϝȆׇ[ܟƔϽmǻǧ̝ȖǫΑЪϽǼʹϮ̽͌ȃ͆Ηݔ͇ġƛ߃̶ӣ̢ޑʠ۹ؤǞØϥΞe˲եƄʱγʝˮn̆bג
Ƹƚ˸ƍͤgGɼ̈ĒĈͺڞɠˊĻؼέۜlj̼Ų'], |
| 'encodeOffsets': [[ |
| 19282, |
| 47011 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'HTI', |
| 'properties': { 'name': 'Haiti' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ԢܰƁôқÝ͑ȱƙɎʥiɫ֏ƜЅÍԡÔϽƿ҉ʾö˔ޜśيã̢ȈϧθP͎ՋžȌɶ'], |
| 'encodeOffsets': [[ |
| -74946, |
| 20394 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'HUN', |
| 'properties': { 'name': 'Hungary' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@˨ըǍǼӂDÜ΄ђɋ̲ğ۸ļäǚͮ~ЦžĜÃЂŀȠȢˠ¼࣒ʭǴĒҲɭÎɣԡǭЉ֫ԕ֭کǁԽ١ə̻űۛNJػήˉļǍ˴ƗV'], |
| 'encodeOffsets': [[ |
| 16592, |
| 47977 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'IDN', |
| 'properties': { 'name': 'Indonesia' }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@ΛeךǒѴʭ̎ʭ»ɩ'], |
| ['@@ܙȁijĶø˸ΰԢࠨͬĐǓfʫշع'], |
| ['@@̢ɣԲèȼΥॿǛőҍP̀ӚҤPɤ̖'], |
| ['@@ūұʅૣľE̬ښǪՂʥ֔Üݬ̮'], |
| ['@@ྔċȂΌ༘З̪կీƵਐӿय़͋ऍݻwࢍØưঅ͎؝ČΓŁ໕ΌƣΰޑØּߤ৶·ڴ͡ΒÛŘ̗'], |
| ['@@ѝֱćنƬ̠Ǭ˴ȒʗCЏ'], |
| ['@@̿˥ׅƸǏΰࡘ¢Ⱦˣ'], |
| ['@@̨ٝۿΌۯìӃÅׇȦҦਠऎʕ'], |
| ['@@ɼയ࢈ԉ۰ࢼ८ԔݜBܘ̉خ̛ࣘLJbᩑbᩑݟېǜȷʇ}ΦۂՈɺɕࣲЕ۸࿃܆ۗêృަʛУ͑óȏ̮GκٛЮ̢ࣞ״gëɠ௵DͩԄݥƺΡдଈȰњ˜ഘ·Ƃ̹'], |
| ['@@ڭ࠭كlj߱ǐඓ¥ܽŧţٍݪݛҒϠ༪˸çϯλŪιӯ͙݉ߒƵ˿ݲॻQտ҅ʙ̐͡Мی࠙͗ȻɶŊ͖ӲØࠌ֕ʭîওறՓũίʚʌޜŽ߸ΛPʻֺΎվŤښфǮΎذپʛśॴࠨ؎Ʀȉ'], |
| ['@@©ܽџĈŷԝΌѷɽĵՒʟǚڤ˨̨ÔҝӸóĀ'], |
| ['@@सާহį˫ֵݿַ߱u࠷͕౻ŭ̚ॕϙͫԤ׳´лːৃ̟̩Оս¯ۗĬŹૺнɺЕܘŝ݀ĮުԂƖָ֗ӅըǠ՜ÑӪъЖôߒɽۆǶњୠ͔̈̆क़ॲ@ܰƙӍݷآߓơϭ'], |
| ['@@छkۻ۰અۊέԚٍۄзؾٕ୴۪݅ʙܠ̳ڀݵՊѭܘمҺऒóђզಢNjݔࠓٮ֫ҪΓߔࣙࡢ_ۺֹӠ۳٘ϥͳۉӖ̞̅sƜו̊ҵؠõФՏɁಟ'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| 123613, |
| -10485 |
| ]], |
| [[ |
| 127423, |
| -10383 |
| ]], |
| [[ |
| 120730, |
| -8289 |
| ]], |
| [[ |
| 125854, |
| -8288 |
| ]], |
| [[ |
| 111231, |
| -6940 |
| ]], |
| [[ |
| 137959, |
| -6363 |
| ]], |
| [[ |
| 130304, |
| -3542 |
| ]], |
| [[ |
| 133603, |
| -3168 |
| ]], |
| [[ |
| 137363, |
| -1179 |
| ]], |
| [[ |
| 128247, |
| 1454 |
| ]], |
| [[ |
| 131777, |
| 1160 |
| ]], |
| [[ |
| 120705, |
| 1872 |
| ]], |
| [[ |
| 108358, |
| -5992 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'IND', |
| 'properties': { 'name': 'India' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ࣚটďۅͮїѕŒɾएࠜՑחՑϟ͛ࠀͅߊЭરһସʼnӜёٮāৠȝ۪bĪͪŋՖÞβԠǮìڋlǙކ͉Ոƀ܀Çۈ|ÐԪˎڴŀވشॸ۶ȷ״ΞЀԹ˳Λ࣠űÜ͇̍ƷèԫƲછׅ~ӓҩ۵§ХϏۗځȒࢇȏ˹ĚΣгȥѵɵEƍ՝ҡѦʸӎϖ¶ϰ܆ӝƜީ]ߝŚóאБ¤ڕζ֭̓؆ѻԿ̻ȅ̩Ԭɣƛԑ̆كžەţֱ̫Zਛǩ´ك҃ӻ֡ळكՋ࠷ջCϭлȹݳ̝Ͻ«ʥٙǪધ®ۡΣߙIѣ¡ϣٙʰˣދʃ˱֯͵ʍߑϳ୴͑ࡒ̍Јѿ߰ȻੂơՀޅ଼Α࿀ʣHৰǍԉףĶ৲И̤ʝͤড܊֖֔ᇜCǗܞҽюĩ٨ջϘऒࢢঊÙ࢞ࢢՄ࡞ࠄࡈ_״ܒӠڳд֪݂̇̕ЬβȱपŰߺ۸'], |
| 'encodeOffsets': [[ |
| 79706, |
| 36346 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'IRL', |
| 'properties': { 'name': 'Ireland' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ƒًݣӹŶڼ࢚ѭࡢତڄٌϼǦ҇ǥ҉Բ\\ٌǥ'], |
| 'encodeOffsets': [[ |
| -6346, |
| 55161 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'IRN', |
| 'properties': { 'name': 'Iran' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@݈njװӔ֚{τƾװýघэڤğ।ݓظòۻɱؑκŭΫҡˠڡàՓِƙæեݿݿжѵԓߦυx݉ДƋêϯѡ̓উཌྷʪࣷȖेŊΧਐЕƪ٣ƭࡑНਇ˦ࡑ٦߳ʈ֗ߘا૪ҍƋՕ˦̻͝ҭѴS҂ˍ@Ɛ،ѝٔҢߜȜپц̂ÙӬտʨխҟڨǐʼʿ६ּʈƄͅъϯ־ő̤~রئ̀Øʞʙ́гԼѱȾ¦ˈإߖǩуƟಾɞĄȞ'], |
| 'encodeOffsets': [[ |
| 55216, |
| 38092 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'IRQ', |
| 'properties': { 'name': 'Iraq' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@րʧÚӫх́țٽߛҡўٓƏ؋ˎ@TҁҮѳӿ¤֟ê؝߭༟äᛍၖఫךৡɪ৾ᇶ͆৬āؘҢȺјԾΰžŇ̐ɉЖƚծ'], |
| 'encodeOffsets': [[ |
| 46511, |
| 36842 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'ISL', |
| 'properties': { 'name': 'Iceland' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@șիॊֵથٙᝓֹܣƵૉŮᚑˈࠠψᆧЪǎʘᄋȜ֨նౠŰಸ֭౨Ҝʃൌ҄ආÑ'], |
| 'encodeOffsets': [[ |
| -14856, |
| 68051 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'ISR', |
| 'properties': { 'name': 'Israel' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ƥ˅̣Ŝǫ֓ɂĥɋřɛЄŖp͛нഉցʔˢ˶ɞϼǠيŤɆzVˬCþƦɤ\\`·ŕŵhM'], |
| 'encodeOffsets': [[ |
| 36578, |
| 33495 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'ITA', |
| 'properties': { 'name': 'Italy' }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@̟ڋŲʹǭѝٝ̈́ёĞ୩ѐŞќজûࡪĠْò'], |
| ['@@ԌşϣÂ˫͇ɞ২ȓӒҨ¥рʼ'], |
| ['@@ரɏĝЯȬΧڝŪہ̗²зĻʇˠё߀чцۛदڱچLȲȃɽǗݪ̥ؠʩܜѫĔƿƽ̛үϼܳƐΝի؈̷ıѫΗ¹҅ܛΕÝHʲǢҊǼǶ͝ӤʱшΑŀʛδգƴεͶثÆٿϜޑմ֯ӜʿࠪйĮہˤϯŕӝϵΓÕĪθҕńɏٲ̆ʰʙ̀ʂβǵМ¢Ҽ˶ƢƃАǼͺتĿψƚâΆԘšĮdžࠨƤȊ̉'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| 15893, |
| 39149 |
| ]], |
| [[ |
| 9432, |
| 42200 |
| ]], |
| [[ |
| 12674, |
| 47890 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'JAM', |
| 'properties': { 'name': 'Jamaica' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@֢÷ҀȫƔɯןeʭƗҹƊӑ̪ĶȔΜÎȒ'], |
| 'encodeOffsets': [[ |
| -79431, |
| 18935 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'JOR', |
| 'properties': { 'name': 'Jordan' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Ʀˆपͫࣆͺ৽Džų၅у࠸ˣƛƑ˭ٙřȩ̡εʵधƆŨоഊo͜Ůʚ@Ԥ'], |
| 'encodeOffsets': [[ |
| 36399, |
| 33172 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'JPN', |
| 'properties': { 'name': 'Japan' }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@ņ˽ҿԕΉːљțɝӭշʈRЊҬԆӌīΊΜؠǹ'], |
| ['@@́ڡƤсѩףЃ๏½ணॡ͔֡غษȃষЃঝe࡞أ֗իΝН͜ȶݶՏʒͿ־ߐʶѲՈࡌѢ؞ָာʤ࣎ǣࢠ֔Бࡀӌ͜ՈਈƟाՎࣀƸҞୗ}ڻޥࡍbࢁ'], |
| ['@@נǵרΤȈहఝɯ݁࠱ָқँण]ř࠴д٨࣌²ʖʜټন٤˯'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| 137870, |
| 34969 |
| ]], |
| [[ |
| 144360, |
| 38034 |
| ]], |
| [[ |
| 147365, |
| 45235 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'KAZ', |
| 'properties': { 'name': 'Kazakhstan' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ӕƹ્דο̹KɱЊ੫ǡێХNÚࡆؘßডũߣݶۋ͆ಥƽðᓗӹᶽљ£יچ֧ɼॕǩχ˧±ȲȶΖDž̊অ˺ϛݮҩɆ
˜ࠊāؘƎܼűƲࠎƭԲ£܍ȴঃσǭяƌĐўՙ֘دw܉֬ӞِʕǢڢऊࡺӣŀؘჄࣴಾtᇢͻࢼΠjѥʔʠɂЊഷ׀߮Цƿɮ߮ɔֺϬ˼Ḯ̈ШȺᑆ̴ݰΒຢǹ˄ࢉ࢚Ȳઆ˹éҝ߮´ᑌߎ̭ˁ੶٭ሠᒑ҄ѰୄӛீɎҪƯКӟטNjΨΥŒѾԣٕ֓ۥÿ¡ࡅұϝဟˢຑїȇဗͱݲลֻɓäӏԭŬу̠ఝĖඃx̧ġΞӉǧŽӹ൩̂փşȉρ'], |
| 'encodeOffsets': [[ |
| 72666, |
| 43281 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'KEN', |
| 'properties': { 'name': 'Kenya' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ӾۙיͱȹΕ̿ÕšףˑǏ֑ͷ˥ࡀËӤᵁႌƙĢSࢺʊ;а̨ؔσ॰įтЉԬԈ֬ֆѨƗ@ҽ˺ˡג@܋ˈSȠxȄī֖ßʞΔގΚͺ˳ָAܽ॑Xᵣ'], |
| 'encodeOffsets': [[ |
| 41977, |
| -878 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'KGZ', |
| 'properties': { 'name': 'Kyrgyzstan' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ȊςքŠ൪́žӺӊǨΝ̨Ģwఞĕф̟Ԯūşȏғ̙ͭઁıͅ՛ࢷŒׇǏߣЇŜȟʇȓཟŵਡ˘࣫ÝĂӜࣴƕ̮ʸٖĉѸױȽإ͂۶ծʟĊ'], |
| 'encodeOffsets': [[ |
| 72666, |
| 43281 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'KHM', |
| 'properties': { 'name': 'Cambodia' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Ѭыࢄȣ২ՠۨઘdž߀ťۚ͡Ϟׄݖ̱Ȝ֕Ļඳ٧τԙࢥÓܫͷ۱Ū'], |
| 'encodeOffsets': [[ |
| 105982, |
| 10888 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'KOR', |
| 'properties': { 'name': 'South Korea' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ܨযȺխPॷ̓ҥݽljڥΏݳïĥҚƼـχذƚֻܘÂúϒ͞Ϝצ¢ΨÈŨȮ'], |
| 'encodeOffsets': [[ |
| 131431, |
| 39539 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'CS-KM', |
| 'properties': { 'name': 'Kosovo' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ǣŃPĘ́ȩĐdzɦƾȌȪÒŜ˨ư²Ţşƾ¿ŌƅƒǎƻŢLĥȳijij×ȉӹŻ'], |
| 'encodeOffsets': [[ |
| 21261, |
| 43062 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'KWT', |
| 'properties': { 'name': 'Kuwait' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Ǭχõȓ˔هשuȽАݟĆ؞߮֠é'], |
| 'encodeOffsets': [[ |
| 49126, |
| 30696 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'LAO', |
| 'properties': { 'name': 'Laos' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@˚Ϝ܆ڹܸ¿ٕࠦھٍÎǛ̉ӯyʣƨࢯԅoݬȸࢮ֧³ԎηʸǴ̲ܐնøȡ҄wŵ०ѦŬӮڏϖޅਚO͚ܹ՝ɗʉ̟ԉۦՌَɄץƵݕ̲ϝ׃ۙ͢'], |
| 'encodeOffsets': [[ |
| 107745, |
| 14616 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'LBN', |
| 'properties': { 'name': 'Lebanon' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ɣ[ýƥ˫D̘ۄмעfϘ§Ɛͣқ̓ȷҟ'], |
| 'encodeOffsets': [[ |
| 36681, |
| 34077 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'LBR', |
| 'properties': { 'name': 'Liberia' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ɗQࡽАޅٖҢ֣ըȪː¬ʔϜҘϺϺǶnɖĨΘԧÇ͵ǐdzʂIǢʄsʓĎНǽύʖɱˊÇΤΙ~ͧăĿÝە'], |
| 'encodeOffsets': [[ |
| -7897, |
| 4470 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'LBY', |
| 'properties': { 'name': 'Libya' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ק̷ҿҤ೧βρՄڑϸϻƷ̗ҶήӹؔͬΘñՈńҠÓϦƨۈ¯϶˕ݐШȜðΠėΒ־͔ʶːЦʌ´٦দ́ΜðۮƓϓЀݛݮǍஆΙࣆйЦɔЖϮț٠˂ФЀׂŘǣ˺ϑ̺Iˌƛ࠴ıȲˣ̣ЕżΫɏԯʦڱ@Ჳ@ᶵ@့ॱGYΙ‧ྐ‧ྒࡓҟ'], |
| 'encodeOffsets': [[ |
| 15208, |
| 23412 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'LKA', |
| 'properties': { 'name': 'Sri Lanka' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ųΙʇܵȓЍڜƫீϠ഼׆ұϺסО'], |
| 'encodeOffsets': [[ |
| 83751, |
| 7704 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'LSO', |
| 'properties': { 'name': 'Lesotho' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@̆ʩʳУƛ˛ҳſƹˍ̛ċؿ٨҄ՐҖ͢ϼǠξʵ'], |
| 'encodeOffsets': [[ |
| 29674, |
| -29650 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'LTU', |
| 'properties': { 'name': 'Lithuania' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ãɊĚɲχƄࢡƨDZ۸२ʴඬÁࠜĊŞǩ҂Ã߲СĀϓۏˏșӃ࣯̓NȫʶљĜ'], |
| 'encodeOffsets': [[ |
| 23277, |
| 55632 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'LUX', |
| 'properties': { 'name': 'Luxembourg' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ǘȏ³ρʍiȉòĞҼɖ'], |
| 'encodeOffsets': [[ |
| 6189, |
| 51332 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'LVA', |
| 'properties': { 'name': 'Latvia' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@نЮՆߊ˼ڜعڪhNJ٤ܐƪςĻܢ̷ۚCКȕîС˒ӷ͕ࣗԛƙ߱ТҁÄŝǪࠛĉණÂ१ʳ'], |
| 'encodeOffsets': [[ |
| 21562, |
| 57376 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'MAR', |
| 'properties': { 'name': 'Morocco' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ԒΥߜÎࢊȃκU͂՟ºԝ̄ࢱɜDZƷ͛ષƙϝ̵ӡñثঙ͍ͩсۍɥ࠻ŷഫاRহŷ@@@p҉Ա˓ȑϡ@̥Ŋ۹ě˛ٻʿÕЁୟ࣡ˣୋ΅ϗĵ̡ቅãaD ϶͒ɮ˞ѪÃ˶̀פҴՖ˲ƊɞӬp҂̤Բ̪֔Ւf\\ц͔ްĢڎָтɠۮۮȿਸ਼͊ܢŔѶդ֨ࡈϦخΐ֘࢈˄ԪؤI'], |
| 'encodeOffsets': [[ |
| -5318, |
| 36614 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'MDA', |
| 'properties': { 'name': 'Moldova' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ȨŮ֒ĊؤʽΊϞɥÑ˵̪ƏŨΗ̊ɇÏűƾčɝ×ӷ|ĉŜǫãÒƭɱˍƥ˽ɁĝƯϦĘΪςӝԂˉΠʹʠʯĈ'], |
| 'encodeOffsets': [[ |
| 27259, |
| 49379 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'MDG', |
| 'properties': { 'name': 'Madagascar' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ɠΥȺ։Ɗঢ়ɒϽĉЗƩʙ˷ӰǁʝLjثõΥɵȗ¿܅ͧওбԯཧ͑ୟϛইہȣܻΡӛɊڙ̜ɳѺÇݘ̑ڠùƮϰƢD˪Дِø՚șЈǃՌãޠ̊ҺŔՒмҶǤ̶Ʋτ\\ӐӎۖԮʦцŗάΦĵҪfԐ˦ϔ̊ί'], |
| 'encodeOffsets': [[ |
| 50733, |
| -12769 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'MEX', |
| 'properties': { 'name': 'Mexico' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@͙݅ƥÕąЧƤқʺЧǚٳ֎سȞӏ͢бࢾɝΐΙ݄ɾٚĎؼưՊƠՖȨӬè۸Ƣʖ֬ɚࢶȚݔԚîȬDZ
ЙҋԁȥԝƸƥűγɁٽɅɎǭcǃY̝ԓƳIJķPŭޥVAAӁϛC̺˫̶șĢǹƌ½s˷ઃEЙۅŢƽĭȟqʕ्ࣞџ˘ۇɖҷÓګ́чĉץɜؿDŽϬؿŠ्ϸ۱ВɃɤҹºˈΓϦࣗӊсՌȧЦ˪ĈđʈȖɔJ̄˱Ϙùͮ˭ъ࠴ࡋڀУԼܝ΄ƷȴŸԲѓȞӹФȽהҍæӣѸϿФˀҍو̓٠^͔؇ͬ˫ӑɴƇͿƔЕĆف̀خׁƒȡŸÓŎ˽Ƭ\\ǜթʮɇǴ̕Նё˨ޯʠρɸϿ²ѷКͶϡ̨ϑqƭΝ̱ƫJɛԞջӎРїɈؚŵҖЏʺֿϒŏŇɃɖԭȰӷӦÖÚΊ³̸̼Ϝ٩ӱɶ̱Հ̷վϳڦͿݲॖÞ੪ĞÿǑСኀףဪPژ@DΌผ@̪̕јˇԀσ˨ѭȾҥѢʩۤʥՊڒۊhפͱфֹ̄ӯӸӏȂחɾЃپʹȁ͞|'], |
| 'encodeOffsets': [[ |
| -99471, |
| 26491 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'MKD', |
| 'properties': { 'name': 'Macedonia' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ńOǤӺżȊ˺¶ϴbтˏÒ։DžƑƥҕh͋ǿջõΑȴšήń˸'], |
| 'encodeOffsets': [[ |
| 21085, |
| 42860 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'MLI', |
| 'properties': { 'name': 'Mali' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@˰ƶƘӶˊpזɻӄǖ͖ÇŴȈ⁚^ȈךƣļЛ⋈Л⋆౾dᬼᆳᬼᆳȨϿԺʉ϶ƋVठĈFካҟ֗íԭݛƃï̳̗ա՟IȿLjҥšΑDžʿٳϕŗɍΙǡНŔɱȳūֻڙۡp˳ɭΣÆӥůȝŁŽάʍĥơhƷʕ٭PɷŴʼnùʱʎ¬ʢĿİdzĉ˚Ǥɐ΅ΚijɴȇȂǙvȫş˕őɱǹΫäɷɈƓɕőƅAµ̮ʾí̽͘ʀǓӔԺ'], |
| 'encodeOffsets': [[ |
| -12462, |
| 14968 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'MMR', |
| 'properties': { 'name': 'Myanmar' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ӫηץϥࣥΟƳО݅ՔؗΈօ̭ܵ̃ƹȪу֖ڙĪҷ_ϵ͠ދңСࡷăذʴ٠˯ӼæࣸͽѤ˛Ʊਗ਼εۢօуॕ׳ҽöԳȠ̂ਪǫڅॺļ̢ӭņۆÅڰ̊ŵjдȦęΤȐ˺࢈ڂȑϐۘ¨ЦҪ۶}Ӕજ׆ƱçԬ̎ƸÛ͈ӮÚˮӵξȧ|ٟۙߓۭijঽࢲƔȨޛՐǍʓۣز́ζƷ؞ʔ~յdẕӓȗ'], |
| 'encodeOffsets': [[ |
| 101933, |
| 20672 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'MNE', |
| 'properties': { 'name': 'Montenegro' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ÁǀηЯÊˋǫÞɽ˞εǖĢƜŬҦ˚ȜƾüɠƟŬśˠě͌ǧçïƽȋɧó'], |
| 'encodeOffsets': [[ |
| 20277, |
| 43521 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'MNG', |
| 'properties': { 'name': 'Mongolia' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ࢮƢ྄ܤ౬Єܴʳ࢚]֘Ͻ࠼ௐɁࠈגͿӶࢊࢊशނįনɍLjؿஜΛߐƺਫ਼ŌࡆōࠖЗԚѕެTƋޜȼૈƒ௸פԌĝѰ˭ৌêХهק࠽ɐ΅ӈńࠤŽ٦̴ڬˏހוğ̗ڏĦŏןʅ؝։͙࠷ѽࡹǞҿúѳէˎ͓ƌˣי˯҇গ̑ఽഫ̇এҋϋʾ৭AఓԜࠥŰૣśჃȊऑmӱԀϣޠԱĢ৩ԼଅŞুƞ̡θ͖চׅڲன̀۷Ѿəז'], |
| 'encodeOffsets': [[ |
| 89858, |
| 50481 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'MOZ', |
| 'properties': { 'name': 'Mozambique' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@لæʁɖńגt̚ʦԌaऀ͜ڞӤƊϕ࠷ľ݅ಿƨЫʣ͙Եޏ͉ृСॉ͓ࣕƵוׯȗí׳ЌُǔӱZʣƪ¦{ࠗƋϷȤƝűΓΗ̗ۗ˳য়ҕρ̳ðΟɊÉíѵّRïϊůϖí̠ƬपɓװГஂࢬ॔ɜ؆ŶúĨӶƉʞغǐEѥ˒ЏÔǹȼϳǰ۫gÅ̼āװᢈۘӚЕɴüͨɅ¸͵ǯϷØסոԱʲζǰíઊΙ؈̣˖̅]ɽદɾٔ'], |
| 'encodeOffsets': [[ |
| 35390, |
| -11796 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'MRT', |
| 'properties': { 'name': 'Mauritania' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@և־ԗؤ֍ɞГʚҵUЧǽйð˽ˏïҐɺаŀߊģࠨĵкČмɑЎѵδǾˬᾔMǃȴќ߀øᒸ᪂©FṖ౽cМ⋅М⋇ƤĻȇי⁙]ųȇ͕ÈӃǕוɼˉoƗӵ˯Ƶ'], |
| 'encodeOffsets': [[ |
| -12462, |
| 14968 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'MWI', |
| 'properties': { 'name': 'Malawi' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ɽٓɾથ̆^̤˕Κ؇îઉεǯʱշԲ×עǰϸ·ͶͧɆɳûәЖѵɔʮޮ˄̈LJۢǚڼƞɪɉ܌Ѕϐ࠘ƽǜɵ˶Ϲɾଡ'], |
| 'encodeOffsets': [[ |
| 35390, |
| -11796 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'MYS', |
| 'properties': { 'name': 'Malaysia' }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@àћֈĶ˞ΈȘýӸԓΜ֛¶֣ęϡĆ˿Öӻ̒ɵͤݑe˳Éߑخښįђӟ֚ś̡۠ҜĠؔȃΤƤƮۈρ'], |
| ['@@أ˹ܯƚॱ@̅ॗ͓̇љୟۅǵߑɾЕóөщ՛Òէǟַӆƕ֘˽ٮǀǜ܆άǂǺڔЬՐϦѥǮ˺В¸՜а٪אшڀͼHќыιֆɻ۬ʧÑ֝͡¥ƮЧ'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| 103502, |
| 6354 |
| ]], |
| [[ |
| 121466, |
| 4586 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'NAM', |
| 'properties': { 'name': 'Namibia' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@رٌؖ͡ȃࠊȷ،˯ಒmŅҞ͛ΌѡۜѳǽՆۃࠐ»٢КdžԊƞհ}ԄϝŶÐ₮ЕşیȒհµͨȍPéӁȍʭC՛͍ͣΎಕ̍س{ᲽࠣBយA᷋ݣѕҋÕՇDŽϗÔƗάͩɰГг'], |
| 'encodeOffsets': [[ |
| 16738, |
| -29262 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'NCL', |
| 'properties': { 'name': 'New Caledonia' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ېԵѨϭ͉ȫҥɪϚէѼ։פś˶β[Һ˹φ˷ˎɻ'], |
| 'encodeOffsets': [[ |
| 169759, |
| -21585 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'NER', |
| 'properties': { 'name': 'Niger' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@nּॹȐОҿպœϤâТբ̴̘ପðݜƄîԮҠ֘Eኬஈϒᝪ᮪ཾ೨αӀңר̸ȸಯ̾ɓ`ˋΔ˽ǻί͕ၻ«ધੳߋγૉΔ̵CեբmčЃʁµˋƻm֩ंȟځҷٱʔҍ¸ʏşӯ~ӷΧѓq৯ѢЉȵѓb̿͆ࡅ̼ࣗıɕǻşӗʋÍݣٗӚ̟E˭ʗ'], |
| 'encodeOffsets': [[ |
| 2207, |
| 12227 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'NGA', |
| 'properties': { 'name': 'Nigeria' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ࢍ̡͉¬͓ȉڥl҇Ղˡ؊שֆكYݍB¶തsǂՊʶʴТԴėɨǔȍӾ˪ÎݤʌͺŠӘɖǼࣘIJࡆ̻̀ͅєaЊȶৰѡєrӸΨӰ}ʐŠҎ·ٲʓڂҸȠ֪ँƼnͬͯğƱ«˧۽ٱɛՙšѧDZȉǝי҅ΉŽыȋÿΓֽ˱ҽΊ͇aԃӭʑQЍ߷ɍש'], |
| 'encodeOffsets': [[ |
| 8705, |
| 4887 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'NIC', |
| 'properties': { 'name': 'Nicaragua' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@̃ˆϽͺȁ˲Ο˄сϜĤžƒŵÚÒʾŀȔŬRkЮȠrǬOǺɤʜǝĒľƺIJ̊ɴbǦĄQňȪĖ|ƜŹǚȆńɄB̈ŌŜŖ˾iïă§ȉĐ̫ȗ˹ěͷυ®ɏtϙŹĉýΫÌɛǣɋ ɩźƏȩDZʛÈƓǦˉêȕʼnօɞųŇ'], |
| 'encodeOffsets': [[ |
| -87769, |
| 11355 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'NLD', |
| 'properties': { 'name': 'Netherlands' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ۦyǀ˳Ƚޓɇ́ԍ@ƘࢡҥȞՏπީǩ؛âѠɲ݀ఆଲΘ'], |
| 'encodeOffsets': [[ |
| 6220, |
| 54795 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'NOR', |
| 'properties': { 'name': 'Norway' }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@᥆ؙઍɣऄՅෛ͵ڵûלઃͰಫ˵Ы؝ߟωࣗȮ¥णѼԉɝԷūփནƊɝҵ߭Hևױझಫ̨˹̇ͫbձ¾՞э˥ধֻۧυӛ֝Ԫဋঁ૫ȟє̛ࣚˇޞզᕠ۶ဌࢂ୦፺ྴඦلᘼᇎπ൪౮ۢ໖ພǘ'], |
| ['@@ም΅Ȝ׆ɐԕˎეǚͮ̿ொȍ'], |
| ['@@᪖صᑟͥұأ݅ǁЍۡৣᅵԢނ̘ఽʐ࿕܂ٷڄᘎ̜Ң̋\\͊˼̋'], |
| ['@@̏ఝҍı៙ƖƫɴஹdँϬᣴɼȫࡘʤᑺȽ'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| 28842, |
| 72894 |
| ]], |
| [[ |
| 25318, |
| 79723 |
| ]], |
| [[ |
| 18690, |
| 81615 |
| ]], |
| [[ |
| 26059, |
| 82338 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'NPL', |
| 'properties': { 'name': 'Nepal' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ÝαŌՕĩͩ۩aয়Ȟ٭ĂӛђଷŊયҼ߉Ю߿͆͜ՒϠΒȪڪʳࡔշҾť˰ЕٶǓۀσौȕঔć'], |
| 'encodeOffsets': [[ |
| 90236, |
| 28546 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'NZL', |
| 'properties': { 'name': 'New Zealand' }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@Ȓװ;ʐΡBΝ̹ϳչإїͷ̴З٭Yܗ̓ɣջӋࡗڇϓнʇޝlխˢࣱÐƗ̰Ҍذࠦժǀ͌ܜѰԎѦώظ͈ɆŰҶלϴȆΧ'], |
| ['@@،ࢫlָϜɯŲًڰ˛֨ãӒ͎юĭȯݗʯӫٛjɡʭþαūƻͅҏзֹ٭ͯƟɘΕŨӞ۔˟ҨࣛͲz̦؈̌ƚ٨լͻ֜vƪБΎڋݔΗת̸àҚұٺɑʂݡ'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| 177173, |
| -41901 |
| ]], |
| [[ |
| 178803, |
| -37024 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'OMN', |
| 'properties': { 'name': 'Oman' }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@ֹ̻ϟªǩȧƉэļ֗ÿĻϯFԽ̻ćХȓǯԹP͡ɃJͻПɷҩĂ֗˳ϱ³˝טٿ൴ᠾ࠾֖၂ϩתvʔΐFΆϞǒƩŞèմіHϖֵҸ̧؞ŋӼƳϜӕɨ˧̞ŃCȉ̩ԃƅɽΟˏ'], |
| ['@@ʼnƳDž˺ʔ˺ľñā'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| 60274, |
| 21621 |
| ]], |
| [[ |
| 57745, |
| 26518 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'PAK', |
| 'properties': { 'name': 'Pakistan' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@تϻʞ٥൨ͻ߹۷ऩůౣȲЫα̖݁̈֩ڴгܑӟ`׳ࠃࡇՃ࢝ࢡউÚऑࢡռϗĪ٧ҾэǘܝᇛD֓֕؛Ɇʣ٭٘ǁിeஃŝ̈́ঊொѢéϰГƌw݊ߥφͷԔеѶඨѕࡀŲԈŅǞȂגóદΔҶӈشCĠɼٞŌ̴ý͢ʀ±ԌΦԖɆͥ֊ߜɴ̢͒мΜĩмȣΤӬμࣘǮ८ĮѐƺӨĦ'], |
| 'encodeOffsets': [[ |
| 76962, |
| 38025 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'PAN', |
| 'properties': { 'name': 'Panama' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@˫ʎǵҒȺɢɅÎƿˤлɸοÁǝ̇ͻɁǽĉǩВҗɯŅŧŭϷ©ơԈŋƛˡ¸ǝ·ÈɓİέCǻĩŶªǖìǠƲŲIJǩŲK͘ö̠̝iDZͲĀæɴȵЮÔΨɄԜǞ˺ʤҬ·ĉҶ
ώơ˜ʧ̈́ɵĹūȜӵǁʟ˓ÒŅС'], |
| 'encodeOffsets': [[ |
| -79750, |
| 7398 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'PER', |
| 'properties': { 'name': 'Peru' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ɥљћɋࡅӘñΈရࡊທࣾ٫ΏۜƐʎ܅ાࠣ༄ߍီ΅Ϥ˃ؤٷպױͼ˖ϒПߢʼךڢՎIJΓʇȧx̭ΎâͼĝΚщӆΌDŽ֤ԦܶৠͨࣸࢠʾմŝٔɢĂ֒ЉˎЅϴɏӶࢣضĿҨɞ̤ƣԎð٠Ͻթࡣʤoрҁݳ œųۍlj॥ֱÓϻɉ̇ČғԕʍBΡɛƵΔݳҲԝDZίµ͆҃ݐuېӸÇ౧ϢĩӄƠܪടǷ˵£ןg܍͟пƮ̵ȕ˯β۹Ջ࣡'], |
| 'encodeOffsets': [[ |
| -71260, |
| -18001 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'PHL', |
| 'properties': { 'name': 'Philippines' }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@Đ֏ºҽ˹ޑ̫ࡨϽэˎإʉϿӦɿ؊ʰЎՑЈˁΑЃثҵƑʖ͢۾ՌʀҜ̈́̔ϝٔɰƎϒרv·ٰڼЋêхÐ̱'], |
| ['@@̟ˡˁՍ˃ʝԫǦɤɂɾĢԸҨ¸Ɖ֣جߺāߡ'], |
| ['@@ૣߕЬט؈ԎѰ࠲Ʈۅևҧѳֿ'], |
| ['@@ԎʹBgΗϳΣՕʧϸÒєŽА'], |
| ['@@ʀभ٫ɞj˭ȶԯЍȋעʧªƁԘӶãY͈ԣٜ߮mɴ̻'], |
| ['@@ɟܩέоѓ٘ܚ̡̈'], |
| ['@@ԮʉʶɖüɇƍΑ˼ɛۥӷ˥ƁڳȊڝѾġϊIJਾүăҙ˜ȫēϯٻЮ̵Ѵɍ̯ԊރůлȆ¨ΎˀɊʣȘŇ̡бӚűμߨͺˡĔೄ˜ހԘA'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| 129410, |
| 8617 |
| ]], |
| [[ |
| 126959, |
| 10526 |
| ]], |
| [[ |
| 121349, |
| 9540 |
| ]], |
| [[ |
| 124809, |
| 12178 |
| ]], |
| [[ |
| 128515, |
| 12455 |
| ]], |
| [[ |
| 124445, |
| 13384 |
| ]], |
| [[ |
| 124234, |
| 18949 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'PNG', |
| 'properties': { 'name': 'Papua New Guinea' }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@ɽčε͔ρՔǷ٘ŜĆĜʡʬȏРՑЈ˵ŝɽ'], |
| ['@@ѯçƃɽҟȱћȟѽBۏʔӑɺêʺݬũҠàŶЖŦrĆѽӐÜʂ˼Ҹ̚ġӸԌfǜƏgү˯ԡ'], |
| ['@@ݤտղࢻӖω٬ƛʥǁࣀΝġʏÏȷɔܟĦࡕŴٷ՚ӉҦѧ݀ભπ܇ʇԡˣńإڇ˿һƖࢅaᩒaᩒภ׃༊ӓׄїҴхŸӵඔԱȲѽޛěȄ֕'], |
| ['@@ʿɡǁӸȝ͘ϝ˞ӍΪ؇ʚɺȮҒɻ˸ȁΜȫʹΛ͊ˏĶѧ'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| 159622, |
| -6983 |
| ]], |
| [[ |
| 155631, |
| -5609 |
| ]], |
| [[ |
| 150725, |
| -7565 |
| ]], |
| [[ |
| 156816, |
| -4607 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'POL', |
| 'properties': { 'name': 'Poland' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@·՜à̂ȹ̧҆̚ɺɤȝђָʘ಼ϴ˴࠼ƙÚȱ߸Yਚħ^њěȬʵωɸ͋KͯԋǡʸϳfϏцܻěɽзįރۥɒϗǿ¶ߙ͔šЇĒӹǵч̖Ήŕ³¼ϭаر¼ăˀֻĦűɑҗǨÀɴػòЉ˔'], |
| 'encodeOffsets': [[ |
| 15378, |
| 52334 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'PRI', |
| 'properties': { 'name': 'Puerto Rico' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@јõưǕɋɃمLӫ·άŢŬیK'], |
| 'encodeOffsets': [[ |
| -67873, |
| 18960 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'PRK', |
| 'properties': { 'name': 'North Korea' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Şƥ͉ºη˵ʣ˷ѣȅƫƧ̓ʝ֓ƏηɥηįġͰƋӈσŧȭΧÇץ¡͝ϛϑÁùСdžĵƿʙéǀɑüɥƆɰφȤİõƶɆҒÅƎөĠЇɤۄբऒҌ־ЎˁܪſѺಚβͰҼժӹ'], |
| 'encodeOffsets': [[ |
| 133776, |
| 43413 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'PRT', |
| 'properties': { 'name': 'Portugal' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@̦Ɉ΄ŬɂЫӺDƞłӪɼуϱɩYٽƍūЇγçʹԋɵտ̄ʡřɫ̵̿ê˥ͷɓѷŠџġŸڂÿԬϓþȩ͈äռͰ̨ÒͼǪԎkΤǙ̠˲'], |
| 'encodeOffsets': [[ |
| -9251, |
| 42886 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'PRY', |
| 'properties': { 'name': 'Paraguay' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ͦtҌЖาʔޮ]їbʵʞҳÇଛࢲLJ΄ǐ֦ɩǀʣþޓİ͓̼̀ƌ̢ƳAҥŕӻǑӛƍݏށ١ړƇऻŸࡑɮࠢ౨ťψࡽ͢ਅبۉŸൌ'], |
| 'encodeOffsets': [[ |
| -64189, |
| -22783 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'QAT', |
| 'properties': { 'name': 'Qatar' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ÇؔɨѲɰĜʬˁdӯǽӳɵÑʫǖ'], |
| 'encodeOffsets': [[ |
| 52030, |
| 25349 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'ROU', |
| 'properties': { 'name': 'Romania' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@δǶԴġՠGϸȳ˺źبĄɄȠΠ@ʰćʺʟˊΟӞԁρėΩưϥϒƹЂƊϠƟpɏПǹʯĀɻӳĖ̪ؑফțзɋ¬٥ƀ͙ÕʍΊƵƦȚƘȷŀ˃ȋөʔßΌԟȢĥˌҕͤڪǂԖ֮Њ֬ԢǮ'], |
| 'encodeOffsets': [[ |
| 23256, |
| 49032 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'RUS', |
| 'properties': { 'name': 'Russia' }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@ࡌకˤԫ்ࠌࡳyוُԒսٱƻ۸ĤࠊħȚٌӯࠜôରަϮͭϴϐŠɔ։̆ߵuࠟΎࡑ'], |
| ['@@]ਙĨȒτ˚ࢢƧψƃęɱäɉ'], |
| ['@@֦Ƚțؐᗸű࠭λ൛ēsࠑͳǩ~ٗ̊ૣʖȉθƎॗʼnҗ̎Ǽ̸ȥϚЃӉΣ@„Ꮪٛᔺ࠳ïԷ'], |
| ['@@ः©ƭˌੲΖ@ַ'], |
| ['@@ળ»@ָň܈Eʉïŗࡽȩ'], |
| ['@@ౡMႣĤƧ¬ߘͪੀþஞ͏ĸə'], |
| ['@@ॿͩഉø༛ͨȪ˖༨ųᑔɗ'], |
| ['@@ډرᶽzඃȣမղҎ׀ǂᕞᴬѽ'], |
| ['@@ӹóᩣŊɟώູɦūҒǶ
Ҟသܒޙĺ፨݆ɩϢሤѺ᪪բǀ෴̸࿐Ŋאͩ֟ʻᲗзЏᤙߝఫࠍ߱Ǡۥྎۏ'], |
| ['@@ɨгސȲឤYቈЧڬ̿ȽѧङʝᕅүفʟਬşఖɃݴDŽєաτɔഊƂ᧪ƑȴϽ↲ů´ٜᄼƥഄLബѷϮ՝ӹΙੌڋͿ߸ࢦഖϙɦྼʵؤʀൖşޮૐζ䢀ձܐӿᔲٛ₎DŽာƑ۪ĹؙਜʇǤvཚǑཪĢะݛਪˎڷ՞ϐώᧆɻფºᝂБ୲ν@”MKઇσઝÖݶҁԄەϲɧĮΏɑɝ༧Ǿمݛĭ౽ןԧ̱ϣயᔗڇϣ̸ߵΫ૱Ř˓ց߽ͻड़ȋőޭΫ۱Δαѕ̅ॡభȳʥேׂ̳έ௬ҵለИ܀ԆªϾರȊຊคࡺຢڢڮஆ৷ëԍۗᒉइۍਖᓧ˷ᑃටۚԧሙɕಝēÔ؊ಯŶЭᢵƠʟᨩủጝŁаՃࠄȅ՞оईÃௌऍ܍ځ࠽ë্ϛഉ్˯ׇଙଇॻթӹ૩ӱՉYՇФૻؙſ˩ŝƦKѐіxŦɛܚܞ̒৶Ʃ֢ࠈ˾ऄ͚̮Ѵݲ൷ʛܯͧ౧Dͻ߄হװหˎ̵ࠖ̉Ԫ̿βԯࡐ̲݇షʢuਯƱۛлҤȥXҩұˑݷࢻRσஅՍ̈́োéѯˮԋĞ௷ףેƑޛȻੑƌޫSԙіࠕИࡅŎŋߏƹΜLJـধɎށİवΎࢉࢉӵࠇבɂ࠻֗Ͼ࢙^ܳʴ౫Ѓྃܣࢭơ͡çѽԤઍőΧΦחnjЙӠҩưிɍୃӜ҃ѯሟᒒੵٮ̮˂ᑋߍ߭³êҞઅ˺࢙ȱ˃ࢊມǺݯΑᑅ̳Чȹḭ̇ϫ˻؆ֹ߭ɓǀɭ߭ХസֿɁЉʓʟѦ೯iࢻΟহͼᇡಽsჃࣳĿؗࡹӤڡउʖǡӝُ܊֫ذx՚֗ďѝѐƋϥӽ߿Ƒ࠳ࢁކߕĉ֣ࣼফԇƝɇωÌֿԚɿՅȚʳΈǮԙƁƥƼଥЖఅƌ܃ƞĹıੱ܂य़̈́ܩӴؒƈۤ۰ҹͪఌ΄uȀݯƉώѠɼÖƄ˪ȅҪѰWʚఉ˚ӭUԯЀ١ƃ੩̐lǒ̗θڟ¤éʼɀǞ՝ӈࢋąʭ¦Ƀȑ̽ȷ՞ȟ˨NJĀڴ͞Ȁʍɢ֥ƪ¼ƲƴՃվǸɨĉЂࠑȨѱijšȼࢭɂˑӸíТЙȖάˊʝװӞųƤक़ҬࢡЎᅢ੶ޮӠ͂єగּΆնݳش֢ܜग़ޢي౿֔ŬךڶüොͶࢀ̈൦ԕᘨȧṺो٤ЋÆ֓टѳ൏ɡ⏷ٔ؟Ńൌ؛ÂϵÆઌʯڂɓňРԑΰ͈᎖Թ۾Ȳ֣ዦࠖޢµ̋Ӫ׀۫ԄЪԊءԶᚠˑӔҹĻNҳڌ˽ಜǼȶ՚ჶАᰪܞي£ࠣԙਬĕ˼༾xఢΐफ़ԏॖࢡӢѪˤ២ʫʿᴾॣ֚ѰࡡѺ{ǴৣĈˢЌ҅ټ}ː༄ݾրކزǒᕮɛǬұߕڽԺˋ˒חȏଵऒԧέ֕०ŭ̢ͮऎɎɞжܮЎөӌϼֈࣿêȫҲڢࡈણۆຒ֦șװмnѴүͧ߷࣐Ƶϥඤͦლ¬༈ӏݛ۪ċࣆศǞᆘŌہѮংւॲx࿎иᕠŐ˪ɲᕂþیȋሴҀaɶδߤΨጤΈ˗ଥȷበŹ'], |
| ['@@ⵙ͕ໞીےĦقÃᒈӋʟͿ'], |
| ['@@૽ōݱÛśƏঙƑ࣫ȦӐʾል~ƶ౨XǢɧӘȬߊƐఞǿ͗ŷ'], |
| ['@@ᆳĿᚉʎඅ͎٣ǔᔆָᆎȎ࿌чኬȹݯ'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| 147096, |
| 51966 |
| ]], |
| [[ |
| 23277, |
| 55632 |
| ]], |
| [[ |
| -179214, |
| 68183 |
| ]], |
| [[ |
| 184320, |
| 72533 |
| ]], |
| [[ |
| -182982, |
| 72595 |
| ]], |
| [[ |
| 147051, |
| 74970 |
| ]], |
| [[ |
| 154350, |
| 76887 |
| ]], |
| [[ |
| 148569, |
| 77377 |
| ]], |
| [[ |
| 58917, |
| 72418 |
| ]], |
| [[ |
| 109538, |
| 78822 |
| ]], |
| [[ |
| 107598, |
| 80187 |
| ]], |
| [[ |
| 52364, |
| 82481 |
| ]], |
| [[ |
| 102339, |
| 80775 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'RWA', |
| 'properties': { 'name': 'Rwanda' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ͬӃµӵʏŁѿÆʱӍԛàþҠŘÞԄʎɺȰďԈʸ'], |
| 'encodeOffsets': [[ |
| 31150, |
| -1161 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'ESH', |
| 'properties': { 'name': 'Western Sahara' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@oҊŸ@@ÉeNjEౝ᪁ªᒷ÷ȳћDŽ்ᾓNǽ˫bCቆäĶ̢ΆϘˤୌୠЂˀÖ˜ټۺĜ̦ʼnϢ@˔ȒԲ'], |
| 'encodeOffsets': [[ |
| -9005, |
| 27772 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'SAU', |
| 'properties': { 'name': 'Saudi Arabia' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ʼnΪʩʨÝͲѡ̞҃۴ʁۆׇ׀ϑƐߠīאӾӕञϿ͠ґǨˡӖ°ȎɹѦʕȊ͝زԟڴѓ־лIžҦ̌ļͲनƅζʶȪ̢ٚŚƒˮˤƜ࠷ࡀ၆фdžŴৢɩబיᛎၕ༠ãݠąȾЏתv͠ܥаȓƠִ̏Λ¼ċ˩ł˯ʎɽŐ˟ŲȵʬǕɶÒdž͍ș࡙͐ᡌщǞDzϪש֕၁ᠽ࠽ᝑ͑ϙࢥϹƕɁˬ͏§ĎƷČॹmɫùΉɔɝЭĒΟρˋ'], |
| 'encodeOffsets': [[ |
| 43807, |
| 16741 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'SDN', |
| 'properties': { 'name': 'Sudan' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@śhdмĵ̀џͨĵĶبϳÌÍȇԍ©Ȭʕðԍңңлџđ۹Ӫͅǥđʓџǃ
ǥ࠵@řǦ̡ƝɳîѝӬƟɲŗɱϵɏݣ˿ǁʳğå ̅ʎÃʼƌΔE΄ӛՀĩάZȰ̱ʜUӦǭ͖̍µĎ̰ɒΖħΐˢʴǫȞɞϨئܦÏ¥ ZΚॲH@း@Ὂ@ῼ@˔ࠗȁƳŪࡻ্̰͌ȷҠ̳ыӑأƏ˅ʳĉ֑αĚͳƅܟͿࠟԓзέٛčЉɽʝ࢟Dij'], |
| 'encodeOffsets': [[ |
| 34779, |
| 9692 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'SDS', |
| 'properties': { 'name': 'South Sudan' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Xٽűʯѿq˷ӏԨÑюХƨͳϦșӼࣳ֫օԫԇԫϭסFگȟՕȊɭ݉ȥάҵDZϱÆɣƕϗĸԗۚƉˊعͪɅԌΕζ֟ѬS˘ҡͼ֯͠ʴĠ̀ǂɐݤɲ϶ŘƠɱўӫɴí̢ƞ
Śǥ࠶@ǦѠDŽĒʔ͆ǦۺөѠĒм؆ҤҤïԎȫʖԎªÎȈϴËĵاĶѠͧĶ˿cлŜg'], |
| 'encodeOffsets': [[ |
| 34779, |
| 9692 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'SEN', |
| 'properties': { 'name': 'Senegal' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ٺн̚φDŽРמȦќ˾ːкïШǾҶVДʙ֎ɝԘأֈֽԹǔӓ̾ɿî͗ʽŧ³қâÙģȃkȲЛV༇ɥħ˥ѻƋƏ٢ވkȬŞƮR̸ȘήǯκcζȌǝʐˡƙʻJͧȸˉ_ȍȥࣵy'], |
| 'encodeOffsets': [[ |
| -17114, |
| 13922 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'SLB', |
| 'properties': { 'name': 'Solomon Islands' }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@ɾ˿חN͉ԬԈȯǜ'], |
| ['@@͝mԧĎǫżÀͮֈƁ˜ǭƎə'], |
| ['@@ųƹحܰǫԈ˺@̠ڥʹЗ'], |
| ['@@ǛڅΦҟ̠̿˪ŰĐϮȫېϭȢˉ'], |
| ['@@Ǘ³οȒ·Ί¨ƖԈΡͰ˛'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| 166010, |
| -10734 |
| ]], |
| [[ |
| 164713, |
| -10109 |
| ]], |
| [[ |
| 165561, |
| -9830 |
| ]], |
| [[ |
| 163713, |
| -8537 |
| ]], |
| [[ |
| 161320, |
| -7524 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'SLE', |
| 'properties': { 'name': 'Sierra Leone' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ɧØͺѩ҈Ƨ̬Ĺت҆τĬɺƞǸɶpȜǂڦCɺ̛ǼΛʓƈɗṶɴ´ϹϹϛҗ«ʓȩˏ'], |
| 'encodeOffsets': [[ |
| -11713, |
| 6949 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'SLV', |
| 'properties': { 'name': 'El Salvador' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ġȡӡ^̡ĄǘұÀʃǶ~Ů˾ɄǀĢ«IJȠ¾ʜëǸǙʪƇœτĴǤÑŘĝÏͳ'], |
| 'encodeOffsets': [[ |
| -89900, |
| 13706 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '-99', |
| 'properties': { 'name': 'Somaliland' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ϛԩד۫۹Mᩧা͍̜̳К̳ҨǾ̖̲҈˚ƹǒΏϜΗкGߊɌࣴĴʼиÆ̚ƶӎKaEAࡑ@ѫ'], |
| 'encodeOffsets': [[ |
| 50113, |
| 9679 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'SOM', |
| 'properties': { 'name': 'Somalia' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ѼĎЊ˾͈FpɵýӧHѳǯ̣ʁࣥЙयԱܝ௷ܓवধࡁڹషٕँৱȗѷȍȣӽۚWᵤܾ॒ɰˆբfݠפબᛜᡄה۬ϜԪ@ѬBࡒFΌLbːhϰŰ'], |
| 'encodeOffsets': [[ |
| 50923, |
| 11857 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'SRB', |
| 'properties': { 'name': 'Republic of Serbia' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ԠȡàӪʓ˄ȌȸĿșƗƶƥȷȏø̫Тγ͋ʿƗˋĞijƑšϳa˹µØĴĴĦȴšKǍƼƑ ŋƆƽÀšŠƯ±ś˧ȩÑèð͋Ǩ˟ĜūŜɟƠȢŬЄЛ͔ɀτ̥Ë͔́ˉʈȱ͘٢ɚԾҖͣĦˋ'], |
| 'encodeOffsets': [[ |
| 21376, |
| 46507 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'SUR', |
| 'properties': { 'name': 'Suriname' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ǙĞưڶÔࣚɥѩܟâֹͤӽƥίóϩɉΛӓDzЇđöčʏƘǗ÷ǡҙèԡܴōӄˏBωؐƺѠ¯ȤԜɖƈݲ'], |
| 'encodeOffsets': [[ |
| -58518, |
| 6117 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'SVK', |
| 'properties': { 'name': 'Slovakia' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@´»ΊŖш̕ӺǶЈđŢߚ͓ɷɓǏdzđ࣑ʮ˟»ȟȡЁĿěÄХŽͭ}ãǙ۷Ļ̱ĠёɌċ̆äńŢȂόa˺ĔxþLj¢ÆȒȖžưʢD'], |
| 'encodeOffsets': [[ |
| 19306, |
| 50685 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'SVN', |
| 'properties': { 'name': 'Slovenia' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ۜÝъȐܾtLjƘƘUǎ˳ڝɟć̇đHɻͣh˷ƎƷƙבȈúȫΨĞа'], |
| 'encodeOffsets': [[ |
| 14138, |
| 47626 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'SWE', |
| 'properties': { 'name': 'Sweden' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ࠁוƀԥڭྱܡؓஃײףߦүޗॅȝ͍තӋ৳ĆӅڗঃˉߐ۳॔ٓஐφӜּۨ˦ন՝ю½ૠղ߀࠰ä̧ͬ˺ಬஂࡀञֈײ߮GɞҶཔƉŬքԸ૪Щ಼ֱv˴͛ฃʃ'], |
| 'encodeOffsets': [[ |
| 22716, |
| 67302 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'SWZ', |
| 'properties': { 'name': 'Swaziland' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ǡύӭěԅҖS̄ɰ̀ĂʔʐÒшƵŰϕðω'], |
| 'encodeOffsets': [[ |
| 32842, |
| -27375 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'SYR', |
| 'properties': { 'name': 'Syria' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ࣅऩͬgNŖŶ_ΈȸҠҜ̈́Əͤϗ¨ÿٞȶΌɤȀɤȀ°Ҹ˞Ǐऎɺ҂ƿۖFॴ̀Ґaक़žїԽҡȹĂؗͅ৫ᇵ'], |
| 'encodeOffsets': [[ |
| 39724, |
| 34180 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'TCD', |
| 'properties': { 'name': 'Chad' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ĎЄաnDզΓ̶δੴߌ¬ન͖ၼǼΰΓ˾_ˌ̽ɔȷರࡔҠ…ྑ…ྏ¦ ܥÐϧإɝԯǬȝˡʳĨΏɑΕč̯̎¶Ǯ͕Vӥ̲ʛYȯՏƛэͽ؉ࣹ߅ϳ߹¾ʁûĊ̏ѫ̋Σ͟͏ȽȐƓhƹɍۛÙƀɪ˅ׄşΐλƜӷӪǼІϦċʂÐҸSқކÉͭՠ'], |
| 'encodeOffsets': [[ |
| 14844, |
| 13169 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'TGO', |
| 'properties': { 'name': 'Togo' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ڱdzȇ̎ɡՔãкȆݴɁ̬ăڎD؎ΕѠÖˀ݂kŅѵʲʝ̈̋ЭǜǥኝȺׅ'], |
| 'encodeOffsets': [[ |
| 1911, |
| 6290 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'THA', |
| 'properties': { 'name': 'Thailand' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ݭϬܗeŬڈ݉Káऋґ௯˙ݏÌ؋նދưܭҶӓԚĭѤѧ˝·ևĵßќۇςƣƭͧ͒ƝжҁӄПЌƏӳǃҲĠԾʚ߬ТࡸҤ͟ތ`϶ĩҸ֕ښȩф̄ƺ̮ܶ·ֆՓؘН݆ΠƴϦࣦצӬθӔȘθʷ´ԍ֨ȷࢭpݫࢰԆʤƧӰzǜَ̊ÍٖڽÀࠥںܷ܅˙ϛŦગDž՟ۧȤ১'], |
| 'encodeOffsets': [[ |
| 105047, |
| 12480 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'TJK', |
| 'properties': { 'name': 'Tajikistan' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@̭ʷࣳƖāӛ࣬Þਢ˗འŶɈާˠĐԜȓ͛ŴӍࡿBׁØԻϕύĉ̉ǯͩˠþ۸ʩ¢ĞʲғȐα̇ėŻūԇj˕ϩ˯nj؋ˑʱĺӀࡘǹض؟ȨɔφۮЌҬˌբȜǩϵŤɹΎv'], |
| 'encodeOffsets': [[ |
| 72719, |
| 41211 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'TKM', |
| 'properties': { 'name': 'Turkmenistan' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ñۼطॣݔڣĠगюׯþσƽ֙|ׯӓ݇NjƻרŪ࢞ٽ˶Ɏֺ֏¸Ȇ۾ߊȵ݈ˎؓԎʉӔڱɋď؛ʿհψ˨ॖǪ֨ɻךڅњ¤ॆ\\Əцܖ̂۾ӦଆѹĜڡ͐ǣࣦˮƳаࡽ०ׇոЃ࢞ЩΫwԥʩЅɤſ̙۽NjǙڥӁʭڏŵǫϟهŏࡩ͈'], |
| 'encodeOffsets': [[ |
| 62680, |
| 36506 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'TLS', |
| 'properties': { 'name': 'East Timor' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@IJȤܢȌזˀŀ͆Ľ̯ɫο۳ʋeʬďǔ'], |
| 'encodeOffsets': [[ |
| 127968, |
| -9106 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'TTO', |
| 'properties': { 'name': 'Trinidad and Tobago' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ӚŊǮصۭġƯúʒɲiͪ'], |
| 'encodeOffsets': [[ |
| -63160, |
| 11019 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'TUN', |
| 'properties': { 'name': 'Tunisia' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ΩພԭͺQȰۉԄóنԮҶȢۚƃߠǠќࣶͺךĵ}ы܊̲ÒljпЫMϱ̆ȽōܫփхDŽқѤaɄЍ͊ſ³٥Хʋʵˏֽ͓ĘΑïΟЧț'], |
| 'encodeOffsets': [[ |
| 9710, |
| 31035 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'TUR', |
| 'properties': { 'name': 'Turkey' }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@͗ঐżܤõলѬࣆ¢ߴЭƜ̑ăУزȻͨʕֻʇˀ५ǏʻҠڧЕƙ̏ɊňίŽॗŽҏbॳ̿ەEҁǀऍɹ˝ǐ¯ҷɣǿɣǿ̱Ϡ͈͂ԟí۱ȖֿәౣĥڹҊࣟȗΑׇij҄ࣻeӽ࠶ؗҰЦٸՓВठߨಒΜྀٔŏհʄർlุף'], |
| ['@@۫ҏ˃Ϻ\\ǦȦĦʺՂХɞࡦ˄ܤőĴ͓ܼ˓Ƶȵি±Ωʷ'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| 37800, |
| 42328 |
| ]], |
| [[ |
| 27845, |
| 41668 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'TZA', |
| 'properties': { 'name': 'United Republic of Tanzania' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ƚġᵂႋÌӣϱਙ¸Ӊՠ̩~ɓɳԓ¶ʭÇГ̌Ճΐ̰ࠡǿڝӣࣿ͛ԋb̙ʥבsɕŃঢ়ʂكåɽଢ˵ϺǛɶࠗƾӉʨՕƘͯƘΗɈґӣҺǗӤČѨƯޞΎ ̨̦͜ѬȺǮS˘ǷȐ·ͨʐł¶Ӷͫӄ̎Ķऄ[ႎà'], |
| 'encodeOffsets': [[ |
| 34718, |
| -972 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'UGA', |
| 'properties': { 'name': 'Uganda' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ः\\̍ĵԇʷȯĐPوȜ͎²ڬǰϸ͎Ѭ͔ɠ˒̘͵Ŗ¼চΌɮՖȉڰȠעEԬϮЊİсτ९̧ؓЯʉͽTࢹႍß'], |
| 'encodeOffsets': [[ |
| 32631, |
| -1052 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'UKR', |
| 'properties': { 'name': 'Ukraine' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@̾ɄȒʮ¥ࢌĆ՞Ӈȿǝêʻڠ£̘ηkǑ੪̏٢ƄϿӮVఊ˙XʙͿѯȆҩƃ˩Õџɻύڡã֑˕«ܣ̻¸ԹЪȭࡨ¼Ǐ̛ँơଛӟұǠȄЂࣽʘƨLjߪ˪ʑȔಯɆË̼ީĻ̷ҧٱةϟƠЁƉϑƺɂĞƦ˾ɲˎÑƮǬäĊśӸ{ɞØƽĎÐŲ̉ɈŧΘ̩ƐÒ˶ϝɦΉأʾ֑ĉȧŭΟ@Ƀȟاă˹ŹϷȴ՟HԳĢγǵÍɤұɮǐͺɸɔȀµɑϘބۦиİĜɾхܼДҢɪٲnࡖßबȫڎi͂ŧ̀Ʀɚȝݸ¢ͮąÄцʶȂܞº'], |
| 'encodeOffsets': [[ |
| 32549, |
| 53353 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'URY', |
| 'properties': { 'name': 'Uruguay' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ղĚࡆٯ̺|ࡺ՟ڈҫӠֱχЉɸӇεՇॉұاǚғěޥΰ֫ԟҬÞլǾȈS࠸ɤࡺȾڦ'], |
| 'encodeOffsets': [[ |
| -59008, |
| -30941 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'USA', |
| 'properties': { 'name': 'United States of America' }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@ũƕȽŤ|ɾƓ̨¦ĤƤƎÍǔ¸þÜe͐ƙƬñƌőɊ̍q¯͟ǵˏſ'], |
| ['@@˭ÑƟǮīèQÀĈî̘āɘŹëĵ'], |
| ['@@ĝ҉|Úĸа'], |
| ['@@µÓŻŃȒɤŚêÃʐ˥'], |
| ['@@ıĉ˱ƴªÖŸĈȘijȝ'], |
| ['@@Ƭңʼƛז½ƅࠂʹڼŊਖɓ˞Tݨʄ߂̧ࠒ͗ں˩ٶˏĈəȢĉ½ĉɦǎĔ¦ȣǜƅɴ@ŬĹĽƫЁǶށǚܳʗӹЁҥȁ̍mēĦť˸Ɓɂ@ঊ҆ࡾƀસмfĐ÷ʰƉǒϜƆࠜHޘAˎ͞ŀàࢶϜƸ౦NBĎȺː¦Φž̖Ϣʲٺٚي˨ə֜ƜώʏAଧռӅƢ˝࣋Пࡷ̃ࢱʝѻӿƛȋSѽˤѽΒsė̬ʦȇãʇ֥ƋЗhةƥλ¥ӥ¥۫ʏఀǂʠǃ୳ʥC|ĺʭɷʚǹؑ٧×Ɏȁª˟ɀǪҍȼƭ^ͅˏ͛ҿڡûʺֲѕ͎įۦljεǴՑևƀׂ˓ߛʊÍĖ̃ŠࡁՕدࢇʝցӱнÁэ̱ţ˭इձӁЍЅӽŻׯƪˬܗώשLεЊঅ֥͛ȿԡʣŃЯĺƁς͋ȖѻܢϹٞű͢ǤɽҦٻ۲͟źࡑϡƭ¦СϼՃȺोŁݗĤٙÍΏſƲɟaͽǴǓLJō̵Ů́ǃ؍طѺܻĿ؏ȚԹÏۻȝއح࠳γҝБȕϗUׅ¨ЕDŽ˹͝{ȂٽʺɽЄȁטӷӐ̃ӰуֺףͲۉgՉڑۣʦѡʪȽҦ˧Ѯӿτїˈ̩̖ป@Cڗ@ဩOቿפТĀǒ੩ĝॕÝƙіխӚϻĴğʌһ¦̝ɪޭĊɉƌĹҢࠁࡊ۩ୠȚχˤٯ۴řۆ҃ҞȀۢ
ܜˍ٢͠ߊĸނĺނƱૼˇܘʓ϶ĸǐ˷҂ߋȺɜƇې˷ێᛸ@᠂@ࠜ@ᢢ@៚@ᡀ@ᡄ@᭰@ᮞBაAF͔˴J'], |
| ['@@࠽͋ѕɐŽЀބ̘҆ŸÉΤʻܫЍ'], |
| ['@@ԧŽսƾԛɮࠦƞښùĂ͑'], |
| ['@@DžԾĒڸɛ࠲őéĝُDZٕǾ͋Ʋݍµȧôº̈́'], |
| ['@@؊ϛώnjහ»¹ȕ౾ƛࡨČᄚ˅ྤā٨ʼn૦Ǝౢʧࣲŝ@@MᷱIⷍࠠ{ࠌɵהρݜցࠈҺࡈ˖Ҁѡ֤·ޒϙՂय़ේxՋұЙҥ͂ݍˌʃܺએںҍߎ߯ÄrটʌࢎߩDŽ̜íϬৃΨटǯǦҫÁঁǫ݉˱झdzťӶϚࠚࣀʶɱɂੱҵֵ֑ױؚСߏࣗΗࡁʱȻωಽѡ˅ϿছΫֽÞɻ˹ۧ˫ʉſƘऀϾࠔʸࣆҠਬĨвΈԊȈǚب̒ƢْђӸॹʫ˓Ơҕ̧շюɧ̝̽мͳԩBïԄƲ̮ե̚થLJ܁ЀַȬIӈ٩Ϊ͘ӘۆҸ̚њںÖ־ƇڴМ؎ï٘ʼƻϨҹưج͖ԩWࢻǽʯȃڏȄஏĥ௷ȬΛӦΘመШ۔@ŕнᄢڽԶਕ͌ױр߫ΨଽˈҺѲਗ਼ϦȨФЎࠊĪཪώޜÉಐ҄ౚǭ'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| -159275, |
| 19542 |
| ]], |
| [[ |
| -159825, |
| 21140 |
| ]], |
| [[ |
| -160520, |
| 21686 |
| ]], |
| [[ |
| -161436, |
| 21834 |
| ]], |
| [[ |
| -163169, |
| 22510 |
| ]], |
| [[ |
| -97093, |
| 50575 |
| ]], |
| [[ |
| -156678, |
| 58487 |
| ]], |
| [[ |
| -169553, |
| 61348 |
| ]], |
| [[ |
| -175853, |
| 65314 |
| ]], |
| [[ |
| -158789, |
| 72856 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'UZB', |
| 'properties': { 'name': 'Uzbekistan' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@xԦૣά࢝ЪշЄ॥Яࡾ˭ƴࣥ͏ǤěڢଅѺ۽ӥܕ́Ɛхॅ[ᶾᓘӺƾïದیͅߤݵঢŪàؗÙࡅЦMǢۍ੬ɲЉ̺LπהӖƺʠĉ۵խئ́ײȾ়ѷٕĊuţɺǪ϶૱țˋաЋҫۭ ɓυؠȧǺصҿࡗهǰҳN'], |
| 'encodeOffsets': [[ |
| 68116, |
| 38260 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'VEN', |
| 'properties': { 'name': 'Venezuela' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@yȣӱĭ˜ϡYѭυӥ͆ڙδÆȌ؈ʻ̒§َਸ਼řІ̎ˆ̞ןל_մҵ˧ݮQ࣌ĔӖϕٞĻҼʾXɄਨ¼\\܉ʛ˼Їڦ×ِЯƆڧѬn͢ȣڕӱó̫˾̷ȽƽԫƉjϱɫɱّ֪Őʁ̭͍ऱ̽Žʏȣڛɀثņƿýϔɑ֝ŜՉ܆ï°ǭʅĭΣΉƏسȝNjʱٷÅҧѼʯ࠺ɟ̧̌Ȅюм
ȊʅʠǛ֒àȈ˰ƲҎ̓Ơӏĩ®ͻęסܢӥńઉăȧ̊ȷêǬĴ̶áͺȃȂŅϮѡÈɸӮĺʔ̸͘ʌɈрդƖ'], |
| 'encodeOffsets': [[ |
| -73043, |
| 12059 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'VNM', |
| 'properties': { 'name': 'Vietnam' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@૭ܗ۫ߍȁ٠ࢭળނԱԞګϪ།ŕ๓۫փ१եۇ۫ޱ̧ՠʀ֬دӌܬࢦÔσԚප٨ļț֖ƶࡀɃצٍאՋۥԊʊ̠՞ɘ͙ܺਙPϕކӭڐҊȴڢIࠈĬܒ҄К̿ސƵƃӛАͿࡎɓ'], |
| 'encodeOffsets': [[ |
| 110644, |
| 22070 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'VUT', |
| 'properties': { 'name': 'Vanuatu' }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@ˣō˭ςɤՆӗ'], |
| ['@@ƌڱɥŀǩťɴi٢Дʵ'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| 171874, |
| -16861 |
| ]], |
| [[ |
| 171119, |
| -15292 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'PSE', |
| 'properties': { 'name': 'West Bank' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@ԣŭʙЃŕɜɌŚɁĦǬ̤֔ś'], |
| 'encodeOffsets': [[ |
| 36399, |
| 33172 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'YEM', |
| 'properties': { 'name': 'Yemen' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@؉ɥNjύo˹࠷Οഇϻݩףυ±ʥºӭΑlj۷©ɃµǿɛəÕŻɇеlˍœ¨ɓӬzҠƍʜǑتʋΊǚ¤đϨĸNJξςˌđΠɞЮΊɓɬúॺnƸċč͐¨ɂ˫ϺƖࢦϚᝒ͒ڀ൳˞ח'], |
| 'encodeOffsets': [[ |
| 54384, |
| 17051 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'ZAF', |
| 'properties': { 'name': 'South Africa' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': [ |
| '@@ǏŧΣяɻћӇोࢁףԋًϣ࢛͙ѓ«ŇɷԛŰеDž࣫NJԙĹΏ¬ࡿͩܓƃԱͅϡoΣ̚˳fαϒśŏɦLӰ˙֞˔ƴs٤սх܈AFતДдͪɯƘΫϘÓՈǃҌÖݤіB᷌ɨűӾߙûԟȈ̏ĒрϒЊʨȶДЦȚΠķВɽۂ£՞ȜĐʾƨДҚäʨ͂˪֔ݮغஒؤUОƛ˲Ķ҂ċДɔׯƫऩî̟чƶʏÑāʓɯ̿T̃ԆҕӮĜǢώْQȿؑıۥɑϛֵщ', |
| '@@νʶϻǟҕ҃͡Տـ٧̜ČƺˎҴƀƜ˜ʴФ̅ʪ' |
| ], |
| 'encodeOffsets': [ |
| [ |
| 32278, |
| -29959 |
| ], |
| [ |
| 29674, |
| -29650 |
| ] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'ZMB', |
| 'properties': { 'name': 'Zambia' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ІϏɊ܋ƝɩǙڻLjۡ˃̇ʭޭѶɓᢇۗĂׯٍřӍͯĹ̛̅ßܵۓҭխ˳o˗ĬऱĠƯÚOêͧȎկ¶ۋȑչԾ֣یᦶშYí̂Ű̀ƧЀĪТėʺ̂q¶ʽϾrՖûˬϡڨŝԤˆȌѯ٠ş̴ΧΈҥ٠Që࣠ɱƳח͞ɧƬļࡈƬসȉψʈ՚ɤĶƚͦđΘɇͰƗՖƗӊʧ'], |
| 'encodeOffsets': [[ |
| 33546, |
| -9452 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': 'ZWE', |
| 'properties': { 'name': 'Zimbabwe' }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ҁČ˱ĵНƜVՙϞٯźʙՒC̒έĞ्ई˃ӢǛƮ͓ڤलğ˘ī˴pҮծܶ۔̜àĺ̆ӎͰَŚÆ̻۬hϴǯǺȻАÓѦˑFǏعƊʝħӵŵùɛࢫ॓'], |
| 'encodeOffsets': [[ |
| 31941, |
| -22785 |
| ]] |
| } |
| } |
| ], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/util/mapData/geoJson/xiang_gang_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [{ |
| 'type': 'Feature', |
| 'id': '8100', |
| 'properties': { |
| 'name': '香港', |
| 'cp': [ |
| 114.2784, |
| 22.3057 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@}ScTʟ@cWuJÁ]l¦RLj¼BĄà H@TOHCTDDDHDNAT@PEHDDNJLX@BABALHFF@DKHADBBLDHHFBLEJB@GDBBFBADDB@@KFAFBBJJA@BB@@FFDDADFF@FADDDBJC@AFBD@@DDD@DAA@D@DB@DHHBFJBBFEHDFAN@DGDC@DLCBDDCFDlAFBFCBEF@BC@GDAB@FD@DZJX´HĐMja@Ý`p_PCZ@lLnRGSDMFK|a\\Y}§Mën'], |
| 'encodeOffsets': [[ |
| 117078, |
| 22678 |
| ]] |
| } |
| }], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/util/mapData/geoJson/xin_jiang_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [ |
| { |
| 'type': 'Feature', |
| 'id': '6528', |
| 'properties': { |
| 'name': '巴音郭楞蒙古自治州', |
| 'cp': [ |
| 88.1653, |
| 39.6002 |
| ], |
| 'childNum': 9 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@ÈÒĊanwŎVȮ¦ͪŃĢÜōȂçČéƐżLɆóĊĊaʊŁ±¯²Um»ˌmÈ»VʠţWÑůǓéôƑƒğÆīŎī@Ƿwô˺LÞ¯ƨVǪуĢȘV°wĢôk°¯ƒ»@Ȃ»ĸǔ@͔ôôLɆó̐ÝɜLɲōͪƨóŤK@ī@IU܃ÛmȻţǩÝ˹ÛljťǓǫō@Ɲ²¯VçōKͿŁΗÇţ»ƽɅƑLÓŏÅÅɱV@ÝĊU¯ÑĊĭÞLÞŎJ±̃XȣˌōlUȯŎKÆƅ°XÑܱnŗġV¯óaUƧUōŁÑ±çɲ¥lĉkğ°k¥nğţL¯ÝÝUƽĬlķ°@ōXÿݯV»ŹLʉÞɱŤĉó°ÝJ¦ÝKÝ£ţÜÈĉ@xǩUċƑ@ky͓¹`U²ĉVġ»ğa¯¥ť@ĉó@ŻÛÛJw¯nó¯ġWƽʩķÝɛwĉĕݼȭÞķō@ó£ÅƑ¯ôȯÞ¯ȰÆōèĉXǼó@ÝnºĸÞVƜĸȚUʶõˀĵĖɱŎÝĖVࢰӒѢ°˘nϚVˌÈmɼĵŦW¤öʊõʔ@°ÈXVènŎȁb¯ǫĉ±Èğ`ġwōÔğ»mVVÝ¥ó@ĸķô@bXĶmV²²`Þ_ɴbͪÈ°ÞWĸÈŌmÞkɲÈUÆ»n¼ǬVķĸźô¯°n¦ɄÇÈ'], |
| 'encodeOffsets': [[ |
| 86986, |
| 44534 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6532', |
| 'properties': { |
| 'name': '和田地区', |
| 'cp': [ |
| 81.167, |
| 36.9855 |
| ], |
| 'childNum': 8 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ƨ¥èź٨ΘƑᩄbUࢯÞĕɲōĶĕöʿVʵķșUƛÝķm¹Þô@È»ĊWŎçÅ°ȯȰÝ°óƒÆͿĉ»̽çnmɱĵƧºóUƽ@±wóL¯°̻L±Æ¯Vƴķb¯VÇ¥ğ²Ǖbk¥ÇKlÅɱġ@ÑóK@ÇaÝXğţxĉČǫķê¯K@ÑaŹƑK¼¯VóaónġwóÞéUġbóĉğÇl¹aUóğKWVůnÇŋƑķnʇ»óxĉwçÇ°Åw°ċXób±kÈÇJm²ţx@ÒÝŦǺnó¼n°ÇbUÒ±¼XĸĠłƽXmwĉºzÈÜmnxmx²ĖmÒbnƧêUºĊêÆVóĖóUĉ¼ÅĬƑ°ɆƆŻŚlłÞL¼nĠ¼@ÞÞź@ŎÞ°VɄɴжϼِ͈Ŏ'], |
| 'encodeOffsets': [[ |
| 81293, |
| 39764 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6522', |
| 'properties': { |
| 'name': '哈密地区', |
| 'cp': [ |
| 93.7793, |
| 42.9236 |
| ], |
| 'childNum': 3 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@WnŐÆĶLĢ¦ţºźlxÅĸƽŚɄĮè@ô²ÞUĔƐńV°¯ĸX¦Ɛm̐bƒ»ɆaĢƐLˤȘÑnІljĸÿn¯ĶaŎ¯ĢĕȘ¯°la¯¥ǕǔwˤӱlťО̻nŻmɃĕċţUw°WUóƨÅţķ°ýV±óÅǓéʉ¯ƽŁéōǖȁÝƏůǕw˹ǫȗǓƧǕVýé@ĬţLƧôͩɱŎɛK̏ÞɅôóK@²@°ōŘ¼lŦ¯ŰóƜÛlV¼ķ¼°kȰŰĠǬŚÝŎmĖ`@ÇÜn'], |
| 'encodeOffsets': [[ |
| 93387, |
| 44539 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6529', |
| 'properties': { |
| 'name': '阿克苏地区', |
| 'cp': [ |
| 82.9797, |
| 41.0229 |
| ], |
| 'childNum': 10 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': [ |
| '@@VÆxˌŎÞŎ°nȂÒ°²VĊ¯VğƾˍǬƨÞÞKÈÞĊVźôɆÞĢèŌôWČ²ŤVÞĸʶbl¯ôn_VÆĸlmÞnVź_ĸ¼ȮmǖéĸW°°ĸJkʠ¼Æw°¤ÈlxɆzČºĶI²ÆǔU°ô@Þ¦UnUĠ¼ŎÓĢxĠ_²ÇĊǬ°ȂamōçUÇW@¯öʓõʉX£ĶťnɻÇUˋmϙ¯˗ӑѡᩃaΗƒɜ°xWƴUxɃÒˣ¤ɅwğʉōóÝŹ±°ȗ@¯Æƒ²¼', |
| '@@ōгwȁ¥Ƨ°ŹÑķV¼ÞêĊ»lĵm¦ÅW@ĀôÈźaɜxÈbÞÆĶIОŘnIÇŃÛÝĊÑĠƏ' |
| ], |
| 'encodeOffsets': [ |
| [ |
| 80022, |
| 41294 |
| ], |
| [ |
| 83914, |
| 41474 |
| ] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6543', |
| 'properties': { |
| 'name': '阿勒泰地区', |
| 'cp': [ |
| 88.2971, |
| 47.0929 |
| ], |
| 'childNum': 7 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ɲˣĊIÈ¥ÅU±Ċýkō°ĉƽó»ĶƽXóʵʵȯƑÅȁɅ¯ĉ@ÇሗK֛@@ˤV֜ʵрƒǬVĸƑŎ@ƆϯÑóķ@ʇ»ķ¦έmlÈĸĊX¼WźÛÞÝѸĢČþĀĊôάVö¼ĊUƨ°°èŎČUÜÆóôVôô²êȘlˌç°`n²ǬĊaÛ°±kğmm»@°ÝɆÛÅÇVaÝVm͔ğôÝÈb@n¯ÜUĢÑĊ@źīżWŤÈǖWôŁÆI²ÓƨL@ĊXmmÑÆ»ȰÑkĶō@ý°m¯'], |
| 'encodeOffsets': [[ |
| 92656, |
| 48460 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6531', |
| 'properties': { |
| 'name': '喀什地区', |
| 'cp': [ |
| 77.168, |
| 37.8534 |
| ], |
| 'childNum': 13 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': [ |
| '@@Č@°ĠôÓô@Ŏĉ@Ƴĸ@Ť£ĢlVôWVóřXĉŤêÞ@ƐÒĢÑlèÈV@ĠIk°ÆŘ@ÈÈĀ@ǶťÒğ@@ÒĉlŻ_@ƧĖÅĬōÆ@bźÞnƒlVÝĬWƼʇÝÅ@ÇÅÈwWóĉ±ğzĬČƨÆÝIĉݯbÇÑĉ¯ʈV°xUŰĊ¤ƪ_ôÓɚI@lȚXȮŎlɴȘ¦ɲÆʈ_ɴźôÞʊŎĠɆxˤ£ɄÑVwXƳ¯wɛŹ٧çƧ¦ōُ͇еϻɃɳUݯ@ōÝŹ@Ý»mğ»ÝKkŁżřɅƅƒ¯ÆīĊ»ôVôĕÅUĉéV¹ƨémanѱĕnwmwnÇÛyĉ¹ŹlŏkĵèķmōÞġKñÔċKÅèĉzômxȗÿƿI@þÅČÝKÝ°@¼ÈVº@ÅĢÆUċłnÝÆǕČĵJm£ÝJ¦@ĊxV°ƏLċ¼ǩ@m@ÅĢómÇÆğ¹ÇÆĖÞKxwô¦ÆÑÆL²ÆƾU±ŚÅŻĖ@ĬŤÈñ@ǔÇxÈǃ', |
| '@@VÇţ°ğUĠ¯mk¯ó¥ķIġÿƏbĉa±ÒĸĀlKU_m»nwm@ÈŤ¦ĉbÞ°±Þżł̦°ĢŁVé' |
| ], |
| 'encodeOffsets': [ |
| [ |
| 76624, |
| 39196 |
| ], |
| [ |
| 81507, |
| 40877 |
| ] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6542', |
| 'properties': { |
| 'name': '塔城地区', |
| 'cp': [ |
| 86.6272, |
| 45.8514 |
| ], |
| 'childNum': 7 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': [ |
| '@@ήnĸ¥ʈ¼ĸ@ôϰÒ@ƅƒōUķƑǫʶпU֛܃LګK@ĸ@Æ£ÞġÅĠċLVÝ»@Å»Ýnm¯»nŻĊ@nķŃ@¯ómóÛÝǟ¯aÝóȭ¥ōUmxĉbÇÑ@bUº¯X¯ÆƧbVÒĉnǕw¯°ƑVÇ@kx±UɱnÅK¯ƒĠǠU°ɜL@°xnĬĀŋŎÇLğϱÞέƜkôÅĀǕłĸĊŤUŰĢ°¦ȂϰÜɨ°x@°żǠÆƈČVĠ»ČL°ÇbĊÑ̐óÞlĶwÞɆVÞwǬxǪţȼÜLŐĶˢ@', |
| '@@óKĵĀV͈ĉłƾNJÆŤzXl°ÆL²¼źôÈĢǔ¦lô°ɜÞʊĠğÅm»ʵƳƑʝȗīV¥¯ĉ°Ñ@ŃÅI»ĉmğnaċƨbVğwġ¯@UōaĉÝJğÑÆŎkŎÞĀlź¦' |
| ], |
| 'encodeOffsets': [ |
| [ |
| 87593, |
| 48184 |
| ], |
| [ |
| 86884, |
| 45760 |
| ] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6523', |
| 'properties': { |
| 'name': '昌吉回族自治州', |
| 'cp': [ |
| 89.6814, |
| 44.4507 |
| ], |
| 'childNum': 7 |
| }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@መL@È°ĊȂɆƒÆĊ£ťôWÓɆbĢÅŎƦČÑW¥°ķU¯ƏŃVē±Ý@óçĭɃƾřÆķkwŹŤ¹ġ¥ĵKŏÅXmˍщwǓ¤Ƒ@wóōVķ£ɱġôÛa±ÒȁóèţIVƽ¼k¤ó¹ġJmx»ÝU²@ÅÆĸǫŎĊmŎǬ'], |
| ['@@Þô°bÞǠôÜôn@°ĸńǶkł¼UÞKğČÆÝĢŤķ@@ΌڬL܄K@ˣȂ˭lĉÅW¥ĵVÆý@ŃÞēUŃȗƅ@ŹƩǕĉ»k»ÇVğóřXŻKƏċêȁèÛŎġͩń'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| 90113, |
| 46080 |
| ]], |
| [[ |
| 87638, |
| 44579 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6530', |
| 'properties': { |
| 'name': '克孜勒苏柯尔克孜自治州', |
| 'cp': [ |
| 74.6301, |
| 39.5233 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ˎǫĠƽ°UUĉ¯±ȁÑm¯ÝōˋōwUű»ÅƑ°Ș@²¯ɳʇ`ɱÅ¥ɳȗōkȭșW@kəJóÔƩ`ĉ£Vů¯wU°ʇĊÈÒ°aĊÞÞJÅċƧīĠyĊ²XôÇxÈÆÆ@ÞʈÅ»XÞīUƑkmŹÝ@aŎÅÆīƨĕ@ż`Ċk@ÑĠ@ŦÑ@ǵÇÿ@ÇÅŗl¯ğJ@ÇUkçġÒƏÑÝ@ţéWĊôŚUóXUġkţ¤ķ@@ƴōĊó@óÔğ¯ċ@@Ò¤kôˣŰ͓k»KX¯ċwƧôğɐÒôIVƯUķǬķn¼ôb°ÒȰVVÈÞ°ĸó¤V¼°V°²êlĢÒUƨ¦ôȰƴĊVV¼ǖIċĊÞɜénČW˸ǸařÈw±īçĸ¤ĊôwĸUĢ¦éǖĬĀô¼lÞkÒ°x°ƆÞxÆV²ǔ»b°wÞȘ¥°nŎV@°ʠèŰȂb'], |
| 'encodeOffsets': [[ |
| 80269, |
| 42396 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6521', |
| 'properties': { |
| 'name': '吐鲁番地区', |
| 'cp': [ |
| 89.6375, |
| 42.4127 |
| ], |
| 'childNum': 3 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ôKĉǪa²¼lÜô@ʠê°ĬôȂ²ÑÜbĢóɲĸ¤ŎUô@xƒǔ£ъxˎmÈÛ@_nĕÞōřǫğůlȯ¯ĸ»U»Ükôƛ°ůkť»Ŏŗ@¯@±͓óͿǓ@ķȁ¼Ϳ@Ƒ¼¯°ólġ¯xȗUġƑǩÒƧUÝ°˹Kóx@ǸōĬÅĬƑĠóƒǔêÆ°XÒʟŤUǼˋnn¼±V²°ȂUŌÝbʟǔɅô@żǬaҎÈ'], |
| 'encodeOffsets': [[ |
| 90248, |
| 44371 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6540', |
| 'properties': { |
| 'name': '伊犁哈萨克自治州', |
| 'cp': [ |
| 82.5513, |
| 43.5498 |
| ], |
| 'childNum': 10 |
| }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@ĉÆŘȁ̐mÞ¯ĀX°±¼@ƾ¯ƴ°ŎÝþŋ¦WÜÞbȂĉźUÇmwVUȂóô@ȰÝnÆJnƾʠŌLČóǪ¯¥ǔaǖŌaôÝĢLxÆLɲm²VlwÈ@Uƒ°¯ǖxĊmUÑƨa°Å°WV¹aÇɃÈm¥°¯ŹóĸķǫUm»Å¼ÇVɱlÝŋnķÇÝX¯ͩÇɳaÝ`±_U±ĵnWa@ĸóķ¯ǓV±ÅĵJċ¹Ʌykwǯ£Åxʟ»lķI¯X¯ķêǕȭnķ»Ź`±kÞ@Ýô@Þ°xŤŎIƨÆUxō¯²ǔĬǬlUŚ'], |
| ['@@ÞĀlź¦¯ĸŤKÞċƨbVğwġ¯@ţƽJ'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| 82722, |
| 44337 |
| ]], |
| [[ |
| 86817, |
| 45456 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6527', |
| 'properties': { |
| 'name': '博尔塔拉蒙古自治州', |
| 'cp': [ |
| 81.8481, |
| 44.6979 |
| ], |
| 'childNum': 3 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ήƛϲÝĠÈKŌōÿmīw@¯ɛKV¯ğǟ°ƑwġKóÞŋbǕǓb¦ǩ°ċôŋKʟƽmÅImͿȯÞó@ȁôUVnxÈŹVȁĊÝabŻ£¯°lóxȂŤĸkĊÞyĊêĊmĢxVƨÈĠXΘÆĠÔźɆţ°LXƾŤŤb'], |
| 'encodeOffsets': [[ |
| 84555, |
| 46311 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6501', |
| 'properties': { |
| 'name': '乌鲁木齐市', |
| 'cp': [ |
| 87.9236, |
| 43.5883 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@WôŚUĠÈl¼Ċ¼ƪǖ@źȘƆ@ýlÜXVŘÞ¦V¼kĖóÒèkĊȁˮ֜@ǫnōĉǬōķÆÅ@±ÞV¼nwĢIôºl£ƾ»UŤJôçó¯īʟéó@kÛ±»ǩbĊóLҍÇǫb@ŻɆóʠǓaŋÞȁVʉłĉbĉɅô'], |
| 'encodeOffsets': [[ |
| 88887, |
| 44146 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '6502', |
| 'properties': { |
| 'name': '克拉玛依市', |
| 'cp': [ |
| 85.2869, |
| 45.5054 |
| ], |
| 'childNum': 2 |
| }, |
| 'geometry': { |
| 'type': 'MultiPolygon', |
| 'coordinates': [ |
| ['@@ɜÞʊĊýVaÅm»ʵƳƑʝȗīV¥¯ĉ°Ñ@ŃÅI»ĉmğnaÝţL°ķóKĵĀV͈ĉłƾNJÆŤzXl°ÆL²¼źôÈĢǔ¦lô°'], |
| ['@@ƾIŤ@UUwōaĉÝJğÑÆŎkŎ'] |
| ], |
| 'encodeOffsets': [ |
| [[ |
| 87424, |
| 47245 |
| ]], |
| [[ |
| 86817, |
| 45456 |
| ]] |
| ] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '659002', |
| 'properties': { |
| 'name': '阿拉尔市', |
| 'cp': [ |
| 81.2769, |
| 40.6549 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@nIÇŃÛÝĊÑĠƏōгwȁ¥Ƨ°ŹÑķV¼ÞêĊ»lĵm¦ÅW@ĀôÈźaɜxÈbÞÆĶIОŘ'], |
| 'encodeOffsets': [[ |
| 83824, |
| 41929 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '659003', |
| 'properties': { |
| 'name': '图木舒克市', |
| 'cp': [ |
| 79.1345, |
| 39.8749 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VéVÇţ°ğUĠ¯mk¯ó¥ķIġÿƏbĉa±ÒĸĀlKU_m»nwm@ÈŤ¦ĉbÞ°±Þżł̦°ĢŁ'], |
| 'encodeOffsets': [[ |
| 81496, |
| 40962 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '659004', |
| 'properties': { |
| 'name': '五家渠市', |
| 'cp': [ |
| 87.5391, |
| 44.3024 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@çôÑlĕU»¥ÝUŗWkÛ@þVńÝĔ@ńÅþĶUX¦Æ'], |
| 'encodeOffsets': [[ |
| 89674, |
| 45636 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '659001', |
| 'properties': { |
| 'name': '石河子市', |
| 'cp': [ |
| 86.0229, |
| 44.2914 |
| ], |
| 'childNum': 1 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lŁǵmĉ@mż¼n°ÞmƼ@'], |
| 'encodeOffsets': [[ |
| 88178, |
| 45529 |
| ]] |
| } |
| } |
| ], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/util/mapData/geoJson/xi_zang_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [ |
| { |
| 'type': 'Feature', |
| 'id': '5424', |
| 'properties': { |
| 'name': '那曲地区', |
| 'cp': [ |
| 88.1982, |
| 33.3215 |
| ], |
| 'childNum': 10 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ƨʔĸbܺÞwnxźbÞ°ô@ĶĸIȼĊJŎÈôU݃¤ǔLÞŎ@ĢȘblôLÇźçȤôL¥ÞIÞ¯ĶxʊťƨƿÑĉXVķŦ¯ȂKÇǕѯIU£¯Óƿ£VĕÅÞÿÆwƑ£ǖxÞĕ±ÇÝaUÑÈU¯UōÈÝwWŁĵ±ÝóĢÿ°IÞ±mÅĢ¯mÿ¥°UnÑŤĢĕĶwǬŻͪwŎ¼źÇĢĠĕˎŁ°óƨ¼Èam@¥°wǔǖ°ƨÇŤġƨŎŃôbÈÛŎĊ°@Ġw²ÑÞJÆÆb²°êĊUÞlȲVÈKĊÒĸĉ»ÅôťUÅÇk¯@ÇÑklÇÅlĢVÑó@°@ÛĸV¯ÇĊn¯Uĕƽ¯m¯bÈ@Ò°Ĭbĵ¼kxķýÇJk£ÝaUÑÅóĶǟkÓʉnĉݼƑó»Þmn£mČ¯@ȮÿV¯ĸk@Ýów»ğġ±ǓLōV¼Əèķĉè±b@ÒţUÑóakl£Ó@¯L@ÇlUóȁ¯aġÈÅĕÝLķ¯Ė¯@WĬxÒÈnW°ţôU²ǓÓġ²V°¯ôǔÝLċk»Ý»Ý¯ÞVwÛÝÇōͩÈĉċ»ĉm¯£W¥ţKkóġƏW@¯±kōÈb@ÒÇaƯakóÛǦÝa¯Ýĉ@Ç»ÛmǓxķƛ¯lVĀÅÞġbÇJUÅVĖƑWzō»ōWn@è¯ÞóVkwƩnkźÇÞÒÞ¯ýğÇUxÆÈnè±bĉÝ»ÈŃwwÞ@m»ÈV@ýÇ°ķxaݯXċ¥ÈóW@ôkxlnxVÈóĊkŤġ¼@°¯ŰƑL̻۱ŎÝVÞVÇÞÅÇakƞ@èğŎĸżƾ°ÒLÞôĠKȰĖźVÈÒĠ¤VôUÈþťL@ôǬÞlÜÈnÇÒUŚ@ĊƨW°°X@ČÇþƴĉÒķ¦@ĢôWĀôłUÞĢǬź°¼@ôV°bUÆnzm¤ƽĸÈ'], |
| 'encodeOffsets': [[ |
| 88133, |
| 36721 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5425', |
| 'properties': { |
| 'name': '阿里地区', |
| 'cp': [ |
| 82.3645, |
| 32.7667 |
| ], |
| 'childNum': 7 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Çƾķn£myVÅaU¯ó@¯»ŹġǫVÝóŁXÿġó@ĸ¥ĊÑƳÈý@ċW¯X¯ĉƧ@VřÈÑÇmkÛǫÝ@óŦKÇýVUó£ğÇÑŹUȯĕğLÝóK¯ÑƽķŻĠō@çlƝÈbÆÈÝUÝÞU²ō̼ůƒK°ů@¯UK±ĊƧbōÇmçÈġóÅóbźó¥kīƯólçKôĵUÅVŃķ¥nÅŏm¯¹Å»@ÑÇóxÝkʇȤU¤ķb@ƒ¯ĊÇx¯ĸĉKm°Āk¦lKnĬȀƾÛ¦WÆÅmNJĉ°ōUţ¤UŎ°ŎKÞłÆǓ¦Þř¯bmUÝl¯Umğl¯£șwÅǫaÝnĉĶk@¯Kō»ĉnaÞ»ťnkmlĸ¥UÅŻkÑťĉVôó°LôīĠUÿĉǕÅz±K¤²ō¤¯Ė¯UÝ¥VĵóÈťÝwķÈÑk¤óWýĵĕVĠVóǓķ°k±VU±ţ¦UǟÝÅJVÑ¥XUċUÅlÛƆǕÆȗƆ¯wŏÞÅ@ĉlÝóÒnUôÅlxólÝôÛ±LÛôÝL@ġ¯X¯ÇUżóaó¤¼XÒġŎóLk¦ôżĸĠ¼KġƆô¦ÆƑÔĉĶ¯ImÒ°¦n°¯ÞlÝČnƒÒKĠÞĕklýƾťôIĖŤÒnƜm¼¯lnżóÞ@Ůó¦ôƽĖċŚn°Ý°ôÈUƜblÞó@ǖô°UÈƆ°XþôôlѢ²Ėm¦°@¤XĊblÜzkºƒĖmXŎWVóÞn°lĠxȚa°»żLźb@Æ°XĠÝȚxĊĕŤaȚ°È@@èŤ¦Ü¼WÞkÈ@V°lŤkŎ±²¦ƐUlj°aÈÑŎbĢŎbÆ¥ÞIȘlôVÈUbkɲĶnmnXb̼òƾĖŎ@ĢȂÑôÓĠĖʊĊÔ'], |
| 'encodeOffsets': [[ |
| 88133, |
| 36721 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5423', |
| 'properties': { |
| 'name': '日喀则地区', |
| 'cp': [ |
| 86.2427, |
| 29.5093 |
| ], |
| 'childNum': 18 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ĶĖXþôl£ÒĸÇÞxÇŦôUĶÞ¦°V°ĕŎ£±£²LÆyĊǖĀğVóĬ¯KóôUĊŦlÒżVÆķ¦klnŦmݼbĊmŎ¼L@°lĊĵÞmǬbÆȚx°¤Ġkn°VÞkVn°aŚÝǔ¥ÅÝŁōL¯ōVŤ£ŎVĊ¯nljÆXÅÜ¥ǿƽmīLkl¥ÿn¯ĊL°ķÈw°ĉ@ƑĸaV£ʈȣÞlôwÈ@ҼưºŐnmÆĸ¦UńÆVóĶLèôkÅ°lĬ¦ŹôôaÆôÇĢnèŎÈƨaĉ²VLĢ»lţôĉUÇwkmlw@óôXÇȦ°WÞbwĸȯ@þÇUn¼Ý@xxÇńÞ¼Ċ²amçÅÇVwĠÈþ°ÝÑÈÝlŹƪmlxôU°Ý@çmXŎŎ¼yƒXĕÆUVÈIĢaÆÝUÿ°kĸƜǔwnÜȼĊ@Þ°ÞbÈ¥Üôl°bÅÈb@ÑaǯUU¯Vġ»¯aV¯Ç°ÅmnÑŤçǬVǬ±ĉ¯¥Vĕ¯Ýk£ōw@±ġÛ°ÇVÑ@Ûa@ČLƳÇa¯¤ÝIĵ¼U¥ƿōķÅţŻókÝóĕ¥¯U»Æ£X¯ġŃÛkÝ°V°ó¼¯èWôÞĖȎkĀƧĀówm¥¯JŹÝJÝōVVÅaÝƑ@ğŭǯ_ĵVnxÅónĵxÇĖĉVÝÈğVÒó¯±Żĉ£ķÆÅLLjĉýţÛ¯VnV¤ÝÈ@°ÅÞݤŰğŁm¦ÝxóK¥ɱÈUĠôêVôÛ¼ÇWÝçĵaō¦óĖƧlÇĢƑnŎÇV¼¼ºÛ@m¦ƽĉmm¯ÝKÛç¯bŏłĬb¼ÅLmxť°ÅUÝXkÝmĉ¦W¯KÒknÝaVÝè¯KɅńÝKnÞ¯¼'], |
| 'encodeOffsets': [[ |
| 84117, |
| 30927 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5426', |
| 'properties': { |
| 'name': '林芝地区', |
| 'cp': [ |
| 95.4602, |
| 29.1138 |
| ], |
| 'childNum': 7 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VÈłVôÈk@°K@Ôk¤lôbVÒŤ@ѲaçĸĊƐçU»ŎǔKĢ²Ġ¼ôx@ÞlƨĬUl¯ÈLVÞJ°ÜnʊwÜbXêVÞ¯°anaU°wƼɴÑWÑ°mÈýÈam¥Þ£Ť@¥ôblÞĢź¥ôxÈÅmÝĕÅV»ĉōŤōnó»ÈīķIUĠÑ°ġĸLÞ¯VÒÆ@Āb¼WôÈ@V¼ôóŤKÈÑU»wVǫżnWÒÈx¼lŦ£ĊōŤx²¯@ÆU¯çÆ@¤°£é°k°lůÈó@¯ŤÇÈĉkkÿó¥ÝXķÑÜ@ÒóŚÝ¯°ĉówDZ¦ÅJUÒĉĀķw¯°mĖ¯±akxÝÅn»lÑK@¯lU¯UVѯóĊ¯mōğVǓƅÞWÝÈÛ@ƿô¯ÜġzÅþ¯ólmôʇġĊÅUͿřŏȁˋŁóÇˡōƧÇbw°Ķôk¦ÒnUþġÒÔkǔķèó@²@ŘōńĵyzġaݤÅI¤Ƀť¦ğѯ¤ķbó¯ó±U²°¤ČÜVnÈÆŚŎ°ôĢþÆzèVĀÇĀÇXŹÑ¯¤ówċķk¦łUÒġzÇ@ÆÝx@²Þ@ƤUô¦U°xU'], |
| 'encodeOffsets': [[ |
| 94737, |
| 30809 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5421', |
| 'properties': { |
| 'name': '昌都地区', |
| 'cp': [ |
| 97.0203, |
| 30.7068 |
| ], |
| 'childNum': 11 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@VĖm°ĉÈU°ķܯ@@ôUÒġkÆkÈlÒ@Èl°ÈVÆóŦƼaÅĢɄwnōw@¥Ŏ¦°ŹÞmV°wnÿwwÝw@¯mÞŗ°wĠĸkÞğlĔ²¦°@ĕĸwVóal@nĢÇĊn°@¦źUXçǔůĸVÆKÈÝĠ²ÅĔô@lÈ_mzǖlaU¼ôwV°¯¦ĬÈal@ČǼnIxô»ɜ@ƨ¥ɆŁŃǪȁkƛƨȍʊȡóĭ@ÈÇVůÞĸƅmēƨťÅÈʉVǵ°ġVŭÅɧ°ÿnɛ£mķ²ŃóÑUĉ°mÇ»¯@mxUĀ¯èţ°ȁÝçġU¯ÆÇţÈ@°ÇôŰ¯k¯lꯤ£Å@èV°Å@±°ţwĉŎť¤k»ÇwXÑŻmUǬxV¼ÇÒţLóôU»Ç@Xó»a@ÿÅUÑÝ°ķK¯ĢğÒVĸJÇĬ¼môţŎĊŎU¼ÆĖnÞÇÆówŹ¦ġkÝóa¦ţ@ݤn¦ÇbÇþ¯nXÒɳÒÅ»¯xVmbb¯Ý°UWéÛaxʉÛm¯ÝIUÇKk°VƧīķU°ȭĀ@ċ°nm¤Ýnô¼ƒÞ»ĊʊmlÔĵǠÆôVÒÞbl¤ÈIĸþlw»Ķa¯ī@ÑÇ°anƾ°'], |
| 'encodeOffsets': [[ |
| 97302, |
| 31917 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5422', |
| 'properties': { |
| 'name': '山南地区', |
| 'cp': [ |
| 92.2083, |
| 28.3392 |
| ], |
| 'childNum': 12 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@°ÞUĖ°¦²ĊôÇÜLǖĀɜȘŰÞLĸźêÞ@UÜUŤ°ɞ¯Ü°WŦĀmŎ¦ĢyVÑŁl¥Čĸôx°£źÒWÈÿÈUÿçÅyýóġō¯řÅmÇÛUċ¯£V±²°ôôĸa°£ĠÒŦ¥Ʉ£ÆJÞ£ĢbyĶzŎŃ@ŗ±ô@ĸçlǓÓĢÑVýmÑl¥ĵó¯̻̥ƛǫÝһÇƧĉyţ¼ҍēVĶĉŎ°ĸmÞVÝĸÒÛaċóŹĖèÈÈl¼k¤ÝX@`Þŏ¼Æō¼ÇçĉKUÝÝ£ğ¤@¦ġl¯Òġĉ¯ómóxÝÞğVƴċK@b@ÜUÒ¯ÈĢÜ@²xŎl¤'], |
| 'encodeOffsets': [[ |
| 92363, |
| 29672 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5401', |
| 'properties': { |
| 'name': '拉萨市', |
| 'cp': [ |
| 91.1865, |
| 30.1465 |
| ], |
| 'childNum': 8 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Ŏ²l@°XĢƐlôŤLX¦°¤ĊnČ¼ÇĊŎͪÞÈÜxU°ÝÞÞ¼¼lČÞKǓ°óU¯Ģ±ǔÔV±ŤóX¯ÇmÑwXī°@°ĕĸÞKÆĖĢÇ°bȂÇŁUV¯wVó¥VÅ£Ý@@±ÞwÅÈ@¥nōťÿ¯XÛɝ°ţ¯ÛVVÝ@ŹéķÝKȗůɛǕÿÛKóÈǫǫUţèmÒn¯Æ°ÈU°b¼UĢV°°V'], |
| 'encodeOffsets': [[ |
| 92059, |
| 30696 |
| ]] |
| } |
| } |
| ], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/util/mapData/geoJson/yun_nan_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [ |
| { |
| 'type': 'Feature', |
| 'id': '5308', |
| 'properties': { |
| 'name': '普洱市', |
| 'cp': [ |
| 100.7446, |
| 23.4229 |
| ], |
| 'childNum': 10 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Uô²a@²²Ķ¥V°Ķ²bl¤kVxl@°Ś²@y@ô¦¯@xxVxUVbVÜm¼ŎĢmºXXWÆ@ĀmmXU°ÅÒm¼Þx°w@°XêĠ°»nV°Ul@k@V±ôī@£ČŃÆ£KÞý@¥k@ya@nWVUVwm£Jknm@wmknXX¥mUUlUnb¯°nkVInlIUw°nmk@@mlanXlanmk@wVWUw_@éĠanmUaÜ£mX¥¯@@óUmݯ¯ÞÝlKnxô£»»ĠJ°aVUÝÿV¥ÛbI@wmón¯yÛL@WkÅmÈ`IWa¯K@¯mUnmaXmbmak¯ĢÒÝm¯mV¯KÇb¯KÛWWX@aVknċLUWVkXóW@ka@ób¯Uwmb¥UUlaU¥U£maķKXkmÝ@kwmѯk±ċbUUVakaġ¦kL@`a¯xmÅLUW@ċnÅUV°LkL@b°°@¤²nôôkl°kèÒÈzV¤ÈWôônV@¦@¼Ux'], |
| 'encodeOffsets': [[ |
| 101903, |
| 23637 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5325', |
| 'properties': { |
| 'name': '红河哈尼族彝族自治州', |
| 'cp': [ |
| 103.0408, |
| 23.6041 |
| ], |
| 'childNum': 13 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@°°nÞôV@°@¦WnÛ¤Vbmnğb@ê`VxUX@xÆÞUnnWÞĸĢÈ@Çè@zÛÜWÅêl²KnV¯ĖĊx@bk@@°JÆ£Èblnnm°nlUkVUUwVmKnnVÞxVLX¥laX@@xl@VzÈVmk@b°ÈĸmV¦`WXbUbbX¼°x@aVVkn@lþnXUlVxŤÅyIUkaIŎĊ@lXx@bz@ô¥_V@ln@ôy@al_l`nmÈ»@kmXwWKU¯»aÅ@wmUÝKUaUUwW@w²»@kÆV£mm£VKkÑV@@»nw¥@kÆnllIVlnLVakalknJWmnaUaVÑVVÞn¥m@¯Uÿl@VçaXaV¯UyVLVk@nJlXLlkxlbla²Òl@nVJVkxKlkUaVķÝÑU@Åm¯@±Uó°ğńķĠmUÑ@ǯ¯Å¼@nml@°¯¯`@w£@¯Çk@»nmċ¯U»I¯LÇĶÛn@bó°Uwm¯UmǯaI@ykIVU¯bIğ¼¼ó¤mwkLÝÞ'], |
| 'encodeOffsets': [[ |
| 104243, |
| 23429 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5326', |
| 'properties': { |
| 'name': '文山壮族苗族自治州', |
| 'cp': [ |
| 104.8865, |
| 23.5712 |
| ], |
| 'childNum': 8 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@wô@²¯maUmôUÆx@XbÞInlVUVwJVaUK°¥xmÞXnlKlnna°@ĊČÆwUmnkl@°£nyn@VV@Vak@@kÞÝbmx°Vnw°klÞInĖÞVlKl@Xa°KlVU@JnxU@ÈĢbUKlm@ak_wanWUk°l»k@Wk@lwU_@UalóU¥ÇnkJW@mVXx±bK@nV±a@Åa£ÝK²WknamKknÇk¯aVV¯ĀUÒ¥I@mm¯¯xÅW@@`k@ó»UU¯lm£ÅWlĵw@mmwÅmWU@y±UxmwU¯U¥Ý¥¯£m@kÇVUV°VbklLwUlUImk@±ÑkbkalwkWKkmI@UlUKVzU°WbbUè@kVĀ°@nm¦ÝUUUÒVbmbXnmIkllbUbmKUkkJmkÅ@l¦mx@¼U@lÒULn¤nU¤Å@l±¼@xXxVVVbÞLVn@xÆb°¼V'], |
| 'encodeOffsets': [[ |
| 106504, |
| 25037 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5303', |
| 'properties': { |
| 'name': '曲靖市', |
| 'cp': [ |
| 103.9417, |
| 25.7025 |
| ], |
| 'childNum': 9 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ȦlKÞĕUV¯Um¯ÇVUnVVUĉnĊÇƾLn°°ÈJÆw@lbÞa¦VXJ°¯W¯aÞJVkUa@lKnÅmWUk¯a¯»@m±@ÑkkbWWX_WÓU»_lkÑm@U»m@l@IWċn¯l@VanVUVUVwVxKÈVmUē@n@VÝÆLwVVwnVlmkUVÑÇ°ka@kÿÝaÞUl£ċĕX±±ĉa@UnVnalónk@wlUVmkÝJaW@ÅwóVVnnb±°@óxXLWxn@lǼnmk_k`@bózm@kU@`¦ó@nW@ÜÅXWw@yb¦@ÒlnUb@xlÜk@²Ç@U¯bmy@kV@bb¦U`lLVx@bLl¼Þ¤@°VVÞU@WÞUbJ@nn@lnnmxUUUbK@ÇwklkUVWakn@lbU@@ULVxkKUn°¯Ò@¼km¦m@klȰ@lUl¦@Vl°wnnþĊUÆbUxbVĖU°annaVal@@b'], |
| 'encodeOffsets': [[ |
| 106099, |
| 27653 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5323', |
| 'properties': { |
| 'name': '楚雄彝族自治州', |
| 'cp': [ |
| 101.6016, |
| 25.3619 |
| ], |
| 'childNum': 10 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@mÒXU`Wn@Xl±¦Uxnbl°knmKUxxVôUx°¼ôÒÈ°JlnÞKĠW°¦Vx²JVw_°¥@UV@@wnymknK¯I@²b°£V¥wUV¤nLkÆJÈwôô°l»Č¯ġVUU@@°ÝXl@U»°Å@U¯@w±¯VmUUlm@mÑnIVyUwmak£Vwm±@Çw@n@UxkwlÇnLmkÅ@±kka@kóJV¯Ç»U£lw¯Xalbl¥¯UX@aUaÈL@ÇVIVkaU¯mmakLWkUJ¯Umxn@kUx¯xmWÅīÝkkbŤbkxWmXwWk¯wKkLŤċń@¤óĬU²@@lk¯VmU¯¼@xV@k°l°kbU°nmVnU@°UVèÞÆbUÒÞnU¦V¼lô@Vl'], |
| 'encodeOffsets': [[ |
| 103433, |
| 26196 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5329', |
| 'properties': { |
| 'name': '大理白族自治州', |
| 'cp': [ |
| 99.9536, |
| 25.6805 |
| ], |
| 'childNum': 12 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lbKVIUa@²m@bxôÒÜxXLmbnl@K°¼kUôxôlV¦nJUÆnm@xÆwbXÆôôLUVwôK@wlmaVw@WknmIUmlnJla@_@kÝmKUaÑm¯Xw°aUaVl»²JVbÆJkôĶĀ²VVkmbVwUówVwnLlmk¯maVw²¥Wk@XmV_WnÑUk@kó»UV¥ÝmVÑÅaÝUçV@¯VUmn¯mVlak¯l¯U@@wğWé¯@¯xÝw¯¯Jċa¯U¥mLU¤bÞȤbÇLWUwmIUVW¼kb`UVb¯L±ĊÛkÿÝKkwKţêUĉþÈV¯ÞVbU°KVk²ÝmImV@kmUkVxm¯KXÈķJU¦V°ULWxL@môb@bkx±LnVUVLnkÜWnwlLŃmW@kkJU_VWĊÞ'], |
| 'encodeOffsets': [[ |
| 101408, |
| 26770 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5309', |
| 'properties': { |
| 'name': '临沧市', |
| 'cp': [ |
| 99.613, |
| 24.0546 |
| ], |
| 'childNum': 8 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@xĢl`²X°Vx@x°Þ°KXağUÑWbnIl`X²°bxl°V@xVxk¦mbl@xXVÆzX¤Æk°kx@lźêlaX»VUnJVxXÈKaÝȣaV£nKV¦°Čb°I°n»ÆÑV¯nWn@ÿXÅWWn¹ġōn»ÛUaUVUww@w°ó¥@z±@ř¯@kUwlk£±aĵ¯Uĵ¦±±@bó±VÝ@ó¤w¯I@mÅóm±X¯IólK@°UllbzkKlln@@ÔºUmVk²ôÒxŎUVóLbmÈnmbnlax@z@Ʀk'], |
| 'encodeOffsets': [[ |
| 101251, |
| 24734 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5334', |
| 'properties': { |
| 'name': '迪庆藏族自治州', |
| 'cp': [ |
| 99.4592, |
| 27.9327 |
| ], |
| 'childNum': 3 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@WXw@akk@yk°īX¥Uóķ¯w@n»UaVaUÛ¯mV¼kÞċô@n¯xÛÒmV¯Ô@x@kwmÅa@UaݯVÅyVa@ÿn»ÝVmankmmÞÅô@n£±ğzÇmU¦VmnÜmbn@°nV@xmzÅ@mºV¦k°ln¤¼õôn@xkÆIUxU@Ť¦VmVkmkXW¤XzVx@Æx¼Þ¯b@lVĸÞVm¼Xm¦VÞ@ƹVón¥ÆKnKX¯x@èĊȱłXaÆxnlV@UÛlȻkğV¥m²ljmÅÞĕƒƛm°ÆmX¤mznÆV¦ÞVVb°bnÞWbn°l@VÈ@VĵĊ±@óInxÆw¥@£ÞW¯ĸ£UUKk±akkkbmWmÈķaÆÇUÈÆW@wmknmU¯'], |
| 'encodeOffsets': [[ |
| 102702, |
| 28401 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5306', |
| 'properties': { |
| 'name': '昭通市', |
| 'cp': [ |
| 104.0955, |
| 27.6031 |
| ], |
| 'childNum': 11 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@mnK@wmUÅ¥móXǓŏmX@VmL@xţnk@mlUŻÒğŋ@L@mmLkm@bXÅW¼ka¯lÇŹ¯aÇ»ÝÝ_@m@@a@UklwUm@ak@bUmbmbV¯ĕUaVwÅaĉVmým¯xUk@k¥VUX¤VÈm`@ńÇÜ@ĀknĔkƞÆĠÞUVôƆÞI@UxƦnl@ĊĊnxUÒ°¦Vb¯WUnWIml@xnUbô¤¼ÈxlI»KV@ÈÔJkUĖ±ÆVb@nVÜVUVLwĠlknĠ@nx°¥Æ²mUw@mmÅUl¯UÑÑUmLllIl±@VkwW@w°@U»kUóI°»ĢÑL`nUĠ²lmbôV@nJUxƦX¦l@ŎUV@lVKVÅV£UaÞUnW@¯VU@ó'], |
| 'encodeOffsets': [[ |
| 107787, |
| 28244 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5301', |
| 'properties': { |
| 'name': '昆明市', |
| 'cp': [ |
| 102.9199, |
| 25.4663 |
| ], |
| 'childNum': 11 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@n@VkVUn²°@x°V@¯ÆV¼k@WÞ¯@@VVUĢċ°k¼VĊx¤Ōx°mVkÑÈL°x°X°VmĊLVxUĖ°bX¦VW@kȯlkn@¥ln@»°Ñ¯VmlLUwVK@V@ka@lmXbUlVlkÈx@LVaVVwnmm@km@mIVaÝ@XVUݯU@Ý£k»K@aUwkKV_¥a@alU@nz°aVÈ@@±lÛk@wVakm@Ñ¥az@XxÆW@ÛX@m@y@aWw@kōĉJlbVJzţÆUwVkmWkým@UlU@b¯wVºUVUêĠXUaUbVĊUWXUmkKWnUUUVVVÝ@kk±¯Lk±WkXlVkl@wXbmLVUIVmk@Ubma@kkaVKUkmlXLWnJ¯ÒĊ°@zkºlLUŤn@@nô@lÆnmKkÈlxVw@@mÈx@n²Uxl¤nbVxUzmJÒn'], |
| 'encodeOffsets': [[ |
| 104828, |
| 25999 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5307', |
| 'properties': { |
| 'name': '丽江市', |
| 'cp': [ |
| 100.448, |
| 26.955 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@l@@w°ÓUnÜÑ°w@mČóÝlU»n°VÜUbVbm¼@°xôĸVW¦¯Ĭl@zll@bWxXaX@ÆĠÆaXwl@XaƦn¼Jn@mnKW¯È»V¯°akVanXVwl@VyUĕVUbÈīlaUk°k¯l²VUkƛô@I@mVwĊaVakaÆbUVLaXIWKUwaWÑÅKUaVk°@Uw¯¥XğÝLkm¯IÇóѯ»anUl±UĵÿlóÅIaU±Ik¼UVb¯bWxn°ÒVbnLlÞ@@`kbmIkVnJmnXl@Uxbkn@xóLUxVKóóÅWaÅxw@nÅmVôXLlVU¤b¦m¼@ĀbUzUÆ°ÞVb@Æbnx'], |
| 'encodeOffsets': [[ |
| 101937, |
| 28227 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5328', |
| 'properties': { |
| 'name': '西双版纳傣族自治州', |
| 'cp': [ |
| 100.8984, |
| 21.8628 |
| ], |
| 'childNum': 3 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@l²°nÒlxÞ@nWlLĸnbV¤V¦kbVV¦nax°Vôa@b@lôXlWUVXČKlmU@bWXXÜ°LÈa°LnU°ÞnÑġ°lnba¯¯KWó@kmK@UĉV@k°VV¹a@y_ċl_nÓlL@anI@óWl£VUlkĕlKVwU@kVam¯ÅL@bÝk@VnUbÇbÝwÅ@ċ¥¯lk¼ÅÒ°b@¦nlUn@ÇVmÆbWôU@ÝÅōm¯aUmkWWw@±n¯UèaL¯mLkwl@°mnÈÒ¯ów@VxĀU¤°Į°Xl'], |
| 'encodeOffsets': [[ |
| 102376, |
| 22579 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5305', |
| 'properties': { |
| 'name': '保山市', |
| 'cp': [ |
| 99.0637, |
| 24.9884 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@X°Il@¦È¼m¼ÞaÞÅlÈxV¼lVôÈÆlLޣȺlkUUw¯UĕVwĊ@n¦mlnVĸIWÇ°LnUwlVn@lnUnJÞl±U¯LVUa°ÝUÇĊýVŤéLlxÞLĀÜl²ĉ°KUaV_Źé@klw¯lÅW£ÅyUW@wknal¥Uw@wUk¯w¯aW±k_mJaXVÒĠWb¯L¯Ý@wwU¯±Wk_ġwwōKmb@¤bk°lĖôUJVnÅlťU¯°VbnbWxXmÞWUĀLyWzÛKmbUxVKknÝkVĀċ¤Ux@¯m@¦'], |
| 'encodeOffsets': [[ |
| 100440, |
| 25943 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5304', |
| 'properties': { |
| 'name': '玉溪市', |
| 'cp': [ |
| 101.9312, |
| 23.8898 |
| ], |
| 'childNum': 9 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lL°xXlWxXnlwaţlaÞlÆĬnX°wVwl@mnw°VVIXllKbnnV°lbUUJ@ÈÇKVb@bW°Vk¦kaWb°kxV¤È¼U°ôI@llbl²@@ó@mm@VţkKl¹@yĉ¯°ÑIXmWKnklVULlb@lnbVal@UnVJUnKWax@lkkUlW²XlK°l²@lÞUUUVVVXmlLVnXWVUĉVaVbWğVéUVU¹W»aVaaWX_U¥nÇķ¯@alUnÇUyk@@wW@kbW¦UKÝwUmmLUnVxUVVlk¯mmnmkÇaŤ¯I@l@@aĉw°ĕmUL±kÆéXÜÛ@yÈç@ÇġÝķXmmÝVÅlmnkbmWkb@nl@nm¯VxkJmUJml¯°makVVnV¦WWmnl@xmnlI¤nxUVUmX@b@zl@¦Ýþ'], |
| 'encodeOffsets': [[ |
| 103703, |
| 24874 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5333', |
| 'properties': { |
| 'name': '怒江傈僳族自治州', |
| 'cp': [ |
| 99.1516, |
| 26.5594 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@WyX£lWlnnUU¥@ţVVwJlÅ@wmöó»£kml¯U¥n¹Æ@ny@wmU@¯mnamÛnUV¥ÈnĠy²m¤@ÆónÝnmlnbÞU¥aV£kUKWómIU¥ókwVól»¯Lk@mnaWKÛwóÑw@a±n@VbUJLkaÝXĉUV`lI@lnXÆƑkKmxÛXmlUKVmU²Klw@aaó@nKXwVKU¯V¥mUnkm¥ĉ@UxVĖ°VxVklmÞkKWĀkVWnl°Lnm@°UxlV@nk¦JVÈ°VÒ@nX°@ÆlUômlnô²nxmłnVV¯x@Èm°XblVUl°@xkXU¤WXXWXÆmkÅJmÞw±bxUīkKmÅVUĖÝèVkx@lXlnk¤LkĖk¦xUL°¯Ė@LnK@b°xVI¥Ua°Ñ@»nm@¹KŎÞÈWln²n'], |
| 'encodeOffsets': [[ |
| 101071, |
| 28891 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '5331', |
| 'properties': { |
| 'name': '德宏傣族景颇族自治州', |
| 'cp': [ |
| 98.1299, |
| 24.5874 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@¥n@°@VwČ£ÿUlÞlmULVwnaÜLXyzKVÿXÝnWXwmaUa°¯VŦÆkUmVIókĕl¯a@£nama@¯m¯ó@óyţbġkÅm±ÛammVkLwU`Wk@VkUmÅlUUKmbkkUVUw¦ó°¼bn°ô¦lºz@x¯@U°nU¤ţU°VƆ@ÈmlnzÞl°¦ÆaxUxLkxWƒn@²ŰW@°ÈXl°Llx'], |
| 'encodeOffsets': [[ |
| 100440, |
| 25943 |
| ]] |
| } |
| } |
| ], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/util/mapData/geoJson/zhe_jiang_geo', [], function () { |
| return { |
| 'type': 'FeatureCollection', |
| 'features': [ |
| { |
| 'type': 'Feature', |
| 'id': '3311', |
| 'properties': { |
| 'name': '丽水市', |
| 'cp': [ |
| 119.5642, |
| 28.1854 |
| ], |
| 'childNum': 9 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@VbVl@XnUXKV@¦nxlUXVnKVmnLUV@bn¤lLXK²`nnlJXIVJIVnn°KnnVll@VLXWV@UkVaVKzV@VVaUK@U»VUl@@WnUU@wVLn@Vwl@XW°LVbn@VU@Xl`@XnKVbkl@XVJlUnlVxlL@lnXl@VUnV°°@aUVLXblWVXn@VVUV@L¤VLVUVbnalLUUVX_laVaWVzXKV@@a@KUmImmXama@kU@yVIUKaVa@kXK@aWU@VIUmW@kkVmU@VwUa@K@k@U`@kUKVk@UV@VaUm²Vy@klUUWUkVmUa@_KVaXaXmU@mUlWkaUX@mmkL@wJnVVÅbWKXa@@I@aJUUÇ@VULW@akLmb@K@aXXw@mVmUVkUy@£@aU@@VkUWm@kUKXUWU_mW@wkkmJUUkLWWUXW@IkJ@k@mW_kÓ_UlLm@I@aUa¯m@ka¯LUJ@mVVxUba@LUKkXbm@Uak@@a@Um`IUbUJ@nUVW@@LnVV@lUbVlUX@`@blXklWUmXlm¦U@@V¯bml@@nUb@llnn@VbX@lV@UVULmU@JVnbVbkbVWxU@@nUVk@'], |
| 'encodeOffsets': [[ |
| 121546, |
| 28992 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3301', |
| 'properties': { |
| 'name': '杭州市', |
| 'cp': [ |
| 119.5313, |
| 29.8773 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@X@l°KXXlWb@²`bIX`l@@bWl@n@VnLUV@V@°¦@l@XVlU@@xVbUb@Vkb@@XVJVzJ@LÞ@VmLUxUJ@LUVxbxXUl@VaÈwbaÞa@Vl@XUVx@V@VLlbnVal@lbVnnLnKnL@VlbVJXalIb@KUU@mVInJUVl@xUVLnU@UÞaV@lkV@UanKL@UlKVUnbÆmn@@nUlVnVJl@@UXUL@WVIVJVxVLXV@IÜKnbn@V¥V@@I@y°b@UUwnk°ÆƨVlUçXm£aÇIkV@WV@@aWIUWUIkb@WW@UnK@UU@kaWVkVIVVnU@UWVUV@VmVkKkWIkVWaULU`UImJUImmU@wmwUVIUWVkUamaU@mVkb@KVU@aVU@anKULVJU@kÛUJUVkkVakU@aVwkW@UWkXmWaULUaUK@XJUUmVU@UVUkJ@ImwmKU@k@lUW@@akKmkamIkWl_UwVm@UkaVUUa@UamakbWlkL@aUalU@mkL@U@UlmK@XkKm@Ýakb@xnXb`nUUU@U@wU@@mKkkV¯U@lULUbVbUb@Va@LºÝb@bLmKx@VUL@bk@mxULWl'], |
| 'encodeOffsets': [[ |
| 121185, |
| 30184 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3303', |
| 'properties': { |
| 'name': '温州市', |
| 'cp': [ |
| 120.498, |
| 27.8119 |
| ], |
| 'childNum': 9 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@ll@xnXV`VXWVL@lXnlV@UV@@b@¤VzUlnVU@nWxW@b@LnalK@bXVKUÈ@VVI@b@J@WbXLÆaUUmI@xlKnn@VWlbkXV@nVWnWbUbL@`VbUnVlVXkV@lUz±VnUbU@@VUlVL@l_@V@l@LVbV@XLV`VÈlxn@lU@aaVVk@XJ@nl@@LU`°LVbL°a@aUVy@anI@aanV@²wÜJX@VVV°kna@WVkaWwU@m@kaUĕÝÝŤnÈaaóI»@±XWkUķ@kV±kwUkWwUÝ»ÛkɳlImaUaWóXÿǬkUnWVmmkKţnŏÞğlUlUx@XWbV@JkX°mb@VULVxUVk@@LWWk@WIkUkJmUkVmI@y@UakLmU@mUUUkaVk@mK@UlUU@UmKmbUUUJ@n@KVLUL@VkJWXX`mnULWlkL@JVLVb@°kxkU@LVV@VLV`UL@VUX'], |
| 'encodeOffsets': [[ |
| 122502, |
| 28334 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3302', |
| 'properties': { |
| 'name': '宁波市', |
| 'cp': [ |
| 121.5967, |
| 29.6466 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@Ċ¦ĸĀ°nXÞVKkƨƑźÿ°»n@wô¥ÜbU°ÆXÞWóçĉݱIUÈ¥@U°wÆ»²mm_@aXVKÞVlk@akk̅@£X»VwÆXWa¯aȗbKƽŰĊxLók@@¯nKUL@xkLÑkWULUUmJUXVU@mUX¯@V`mbXbV@@nn¤WXx@kJ@nVVUVl²UbÝVUVk@Wx@V@VXzmlaL@VlLU`XUVVVUnl@VbnJlnUVVnlUKkbmnnVxlJnxmbU@UL@KUVX@xmb@lk@mnVVUè'], |
| 'encodeOffsets': [[ |
| 123784, |
| 30977 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3309', |
| 'properties': { |
| 'name': '舟山市', |
| 'cp': [ |
| 122.2559, |
| 30.2234 |
| ], |
| 'childNum': 3 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lƒʠþÆVĢLĊǬXĊÜXôVÑÆwlƏÈóVĭVǓ@ĉwɛkmK@ĉXīWaĉUĵÝm¯ĉwĉ±±nż¯x@VǦV²JĊÞôèÝXÅW¯VÛaó¦@xm¯¼ŹĀ'], |
| 'encodeOffsets': [[ |
| 124437, |
| 30983 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3310', |
| 'properties': { |
| 'name': '台州市', |
| 'cp': [ |
| 121.1353, |
| 28.6688 |
| ], |
| 'childNum': 7 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@lVIVWVz@bXJl@Xal@°nLll@nVxnVK@UJVb¦°k`UIWJXnÆ@bUJXl@lbWn@UzVV@bVVmVnnJVXnabKUKnUVVUnVLlKVLXaJm£@mU@WanaU_°@VWnV@UVWnIVVVKlXÒlK@wVKL°m@l@ôKwĉƾůUl£@»UVkm@ƅUaÛIŏmUk@mw@a£Wk@ţIm±@ankôUlaUUw¯ōabÇbţmÞÞVĖbl@@nVXxbUl@Xmb¯lUUUW@ÛI±xU@mb@bmJ@bUzV@b¯bKUa¯KV_@Kk@@mWI@lUUb@bkVm@kwUÇU_WKU@Ux@VUnllX@VnJ@UXV@bWL@lUbbVLUJ@zV@lnbWbnnnJV@L'], |
| 'encodeOffsets': [[ |
| 123312, |
| 29526 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3307', |
| 'properties': { |
| 'name': '金华市', |
| 'cp': [ |
| 120.0037, |
| 29.1028 |
| ], |
| 'childNum': 8 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@nbVb@VbUVlb@VUnVxk`lXnJlbnlL@bX@V@klV@nLnx@JlIVU@VUVnVVI@WVLVbVKXbWnXl@VlXUxb@lVUbllVUIÜVnalKX@@bV@@aUUlUwUw@naWWUVaUUaVbLlxXJVk°UlkU¥@ka@LVlXLVlVWznVn@lxJl_@WX_@mVaa@alU@kVVnaKVLlKb@UUaVabnUWmXU@k@yVI@aÅWmXIVJl_¯¥UaVI@LmUUw@mkkmK¯k@Wbk@WI@aUyUXJkU@bU@WLUyXUbkbW`UVVkKmbUaVUUK£@KVUUUm@UWkXWaUKV@b¯¯mUV@UkmW@kkKwUmkkVUI@WlkUamL@Wk_W@UVm@Ua¯KWXk@Uxm@UK@xVmV@Xk@UVV¼@VLUbUU@yULUbVlU@@XlVUVVbU@lXXVW@XUVl@@VUVÈn@VVU@lVa@UmL@`X@`WL@VUX@lUL@xlx'], |
| 'encodeOffsets': [[ |
| 122119, |
| 29948 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3308', |
| 'properties': { |
| 'name': '衢州市', |
| 'cp': [ |
| 118.6853, |
| 28.8666 |
| ], |
| 'childNum': 5 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@XkVKnwl@@aVK@UwnLK@aÞa¹@Kb@UVaUaVaVK@k°VUllnL@V@xV@V@VVm_Wam@wlaÞbn@lL@WnLk@V@VlK@nkVVb@blKXklakw@wVK@kVW@UXK@_W@_nKV@Ub@kVUUm@ÇVU@Uk@VU@WUXWW@kVUaVUkU@WWXUKk@Ukmm¯LmmUJUIWJkImm_±WLkKm£@aVUmKUnLmWUkVmw@¥ULVWm@WUka@UmmLmm@@bUX@@WUIm@UVUK@UVUUUVVJmb@bXnmV¼nnn¦mJUVLV@VW@UzUlVnUbl`UnVl@XU@kl@bmÈUxVk@@J@¼W@ÅaVVnzmV@WJk@kWJ@lXbWbXxmVnlLXb@°lKVXnWbWVXmbV@XlbI@Kn@@x@VLlm'], |
| 'encodeOffsets': [[ |
| 121185, |
| 30184 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3306', |
| 'properties': { |
| 'name': '绍兴市', |
| 'cp': [ |
| 120.564, |
| 29.7565 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@x@VnnVJnIVJV_VKXblUXJllLUUnU@UVVX@mVUUUJlXUlbV@@VLVmX@@XlaVJVXXJ@b@XU@lUJÈb¤ŌJçVUUnml@@kna@wWVU@LVKV@namwkIUwmnmlaVLkUmVUkmmIUak@VmUUVUWV_kK@UKbnkWyU@@UXwl@VUÞUVak±VUUU@mlI@wXWIWbUKkLUKVmUUmVVLLambUWmIUmnUU@aUUVym@Xkak@W@z@lWVXnmVaUbVb@VakLUKLmbUU@lkV@bbUb@nW`@Xk`Ikwm@mUXyUUkWKUk@Kb@lV¦klV¯UlWIkwKUabVVUbVXXmb@VxxkVVV@bU@@aW@kLmb@lVUIVKmL@bUV@bUV@LalnUV@nbVbUlVXJVUnx'], |
| 'encodeOffsets': [[ |
| 122997, |
| 30561 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3304', |
| 'properties': { |
| 'name': '嘉兴市', |
| 'cp': [ |
| 120.9155, |
| 30.6354 |
| ], |
| 'childNum': 6 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@@blIX@@VÜVUnn@lklKnI°Þl`²LVKVbnbVaVLUVn@W¦@VkVVb@VI`@blLnLaX@VVb@U@XlVa@@kVaUKV»U_lWXU@albk@VllnLVKn@@UVIUw@y°IVVXU@VV@lwm@wVkƾaJLkΡƧƒlLÝUmW¯ķÿĉ¥IŋWnèkVƧU¯ÅmlVx@V¯az@@JU@U¦m@@nVmn@VLV'], |
| 'encodeOffsets': [[ |
| 123233, |
| 31382 |
| ]] |
| } |
| }, |
| { |
| 'type': 'Feature', |
| 'id': '3305', |
| 'properties': { |
| 'name': '湖州市', |
| 'cp': [ |
| 119.8608, |
| 30.7782 |
| ], |
| 'childNum': 4 |
| }, |
| 'geometry': { |
| 'type': 'Polygon', |
| 'coordinates': ['@@kLlkm@VmÛU@UW@kJ@aUK@UnmmU@maÛL@JWUUKUwUIUJ@XKWV@Vk@UIUmVk@mm@ÅnmaUVkL@VKmLVbU@klU@ÝbV@mVUKV@wUkVmIUJ@nVV@LakJWbUIka@UmKmLKmmUUVk@@nmLX`WXUV@@nUlkmlU@UbxVVIlVnn@@nUÒ@°n@@xmb@VbnV@@b@`@L@L@x@blVklVbnnV@aXb°VlU@Wb°ULXWVUVVwÈwÜ»ĸaĠnUVw²X@V@lVU@wlaUUVm@knUV'], |
| 'encodeOffsets': [[ |
| 123379, |
| 31500 |
| ]] |
| } |
| } |
| ], |
| 'UTF8Encoding': true |
| }; |
| });define('echarts/chart/gauge', [ |
| 'require', |
| '../component/base', |
| './base', |
| '../util/shape/GaugePointer', |
| 'zrender/shape/Text', |
| 'zrender/shape/Line', |
| 'zrender/shape/Rectangle', |
| 'zrender/shape/Circle', |
| 'zrender/shape/Sector', |
| '../config', |
| '../util/ecData', |
| '../util/accMath', |
| 'zrender/tool/util', |
| '../chart' |
| ], function (require) { |
| var ComponentBase = require('../component/base'); |
| var ChartBase = require('./base'); |
| var GaugePointerShape = require('../util/shape/GaugePointer'); |
| var TextShape = require('zrender/shape/Text'); |
| var LineShape = require('zrender/shape/Line'); |
| var RectangleShape = require('zrender/shape/Rectangle'); |
| var CircleShape = require('zrender/shape/Circle'); |
| var SectorShape = require('zrender/shape/Sector'); |
| var ecConfig = require('../config'); |
| var ecData = require('../util/ecData'); |
| var accMath = require('../util/accMath'); |
| var zrUtil = require('zrender/tool/util'); |
| function Gauge(ecTheme, messageCenter, zr, option, myChart) { |
| ComponentBase.call(this, ecTheme, messageCenter, zr, option, myChart); |
| ChartBase.call(this); |
| this.refresh(option); |
| } |
| Gauge.prototype = { |
| type: ecConfig.CHART_TYPE_GAUGE, |
| _buildShape: function () { |
| var series = this.series; |
| this._paramsMap = {}; |
| for (var i = 0, l = series.length; i < l; i++) { |
| if (series[i].type === ecConfig.CHART_TYPE_GAUGE) { |
| series[i] = this.reformOption(series[i]); |
| this.legendHoverLink = series[i].legendHoverLink || this.legendHoverLink; |
| this._buildSingleGauge(i); |
| this.buildMark(i); |
| } |
| } |
| this.addShapeList(); |
| }, |
| _buildSingleGauge: function (seriesIndex) { |
| var serie = this.series[seriesIndex]; |
| this._paramsMap[seriesIndex] = { |
| center: this.parseCenter(this.zr, serie.center), |
| radius: this.parseRadius(this.zr, serie.radius), |
| startAngle: serie.startAngle.toFixed(2) - 0, |
| endAngle: serie.endAngle.toFixed(2) - 0 |
| }; |
| this._paramsMap[seriesIndex].totalAngle = this._paramsMap[seriesIndex].startAngle - this._paramsMap[seriesIndex].endAngle; |
| this._colorMap(seriesIndex); |
| this._buildAxisLine(seriesIndex); |
| this._buildSplitLine(seriesIndex); |
| this._buildAxisTick(seriesIndex); |
| this._buildAxisLabel(seriesIndex); |
| this._buildPointer(seriesIndex); |
| this._buildTitle(seriesIndex); |
| this._buildDetail(seriesIndex); |
| }, |
| _buildAxisLine: function (seriesIndex) { |
| var serie = this.series[seriesIndex]; |
| if (!serie.axisLine.show) { |
| return; |
| } |
| var min = serie.min; |
| var total = serie.max - min; |
| var params = this._paramsMap[seriesIndex]; |
| var center = params.center; |
| var startAngle = params.startAngle; |
| var totalAngle = params.totalAngle; |
| var colorArray = params.colorArray; |
| var lineStyle = serie.axisLine.lineStyle; |
| var lineWidth = this.parsePercent(lineStyle.width, params.radius[1]); |
| var r = params.radius[1]; |
| var r0 = r - lineWidth; |
| var sectorShape; |
| var lastAngle = startAngle; |
| var newAngle; |
| for (var i = 0, l = colorArray.length; i < l; i++) { |
| newAngle = startAngle - totalAngle * (colorArray[i][0] - min) / total; |
| sectorShape = this._getSector(center, r0, r, newAngle, lastAngle, colorArray[i][1], lineStyle); |
| lastAngle = newAngle; |
| sectorShape._animationAdd = 'r'; |
| ecData.set(sectorShape, 'seriesIndex', seriesIndex); |
| ecData.set(sectorShape, 'dataIndex', i); |
| this.shapeList.push(sectorShape); |
| } |
| }, |
| _buildSplitLine: function (seriesIndex) { |
| var serie = this.series[seriesIndex]; |
| if (!serie.splitLine.show) { |
| return; |
| } |
| var params = this._paramsMap[seriesIndex]; |
| var splitNumber = serie.splitNumber; |
| var min = serie.min; |
| var total = serie.max - min; |
| var splitLine = serie.splitLine; |
| var length = this.parsePercent(splitLine.length, params.radius[1]); |
| var lineStyle = splitLine.lineStyle; |
| var color = lineStyle.color; |
| var center = params.center; |
| var startAngle = params.startAngle * Math.PI / 180; |
| var totalAngle = params.totalAngle * Math.PI / 180; |
| var r = params.radius[1]; |
| var r0 = r - length; |
| var angle; |
| var sinAngle; |
| var cosAngle; |
| for (var i = 0; i <= splitNumber; i++) { |
| angle = startAngle - totalAngle / splitNumber * i; |
| sinAngle = Math.sin(angle); |
| cosAngle = Math.cos(angle); |
| this.shapeList.push(new LineShape({ |
| zlevel: this._zlevelBase + 1, |
| hoverable: false, |
| style: { |
| xStart: center[0] + cosAngle * r, |
| yStart: center[1] - sinAngle * r, |
| xEnd: center[0] + cosAngle * r0, |
| yEnd: center[1] - sinAngle * r0, |
| strokeColor: color === 'auto' ? this._getColor(seriesIndex, min + total / splitNumber * i) : color, |
| lineType: lineStyle.type, |
| lineWidth: lineStyle.width, |
| shadowColor: lineStyle.shadowColor, |
| shadowBlur: lineStyle.shadowBlur, |
| shadowOffsetX: lineStyle.shadowOffsetX, |
| shadowOffsetY: lineStyle.shadowOffsetY |
| } |
| })); |
| } |
| }, |
| _buildAxisTick: function (seriesIndex) { |
| var serie = this.series[seriesIndex]; |
| if (!serie.axisTick.show) { |
| return; |
| } |
| var params = this._paramsMap[seriesIndex]; |
| var splitNumber = serie.splitNumber; |
| var min = serie.min; |
| var total = serie.max - min; |
| var axisTick = serie.axisTick; |
| var tickSplit = axisTick.splitNumber; |
| var length = this.parsePercent(axisTick.length, params.radius[1]); |
| var lineStyle = axisTick.lineStyle; |
| var color = lineStyle.color; |
| var center = params.center; |
| var startAngle = params.startAngle * Math.PI / 180; |
| var totalAngle = params.totalAngle * Math.PI / 180; |
| var r = params.radius[1]; |
| var r0 = r - length; |
| var angle; |
| var sinAngle; |
| var cosAngle; |
| for (var i = 0, l = splitNumber * tickSplit; i <= l; i++) { |
| if (i % tickSplit === 0) { |
| continue; |
| } |
| angle = startAngle - totalAngle / l * i; |
| sinAngle = Math.sin(angle); |
| cosAngle = Math.cos(angle); |
| this.shapeList.push(new LineShape({ |
| zlevel: this._zlevelBase + 1, |
| hoverable: false, |
| style: { |
| xStart: center[0] + cosAngle * r, |
| yStart: center[1] - sinAngle * r, |
| xEnd: center[0] + cosAngle * r0, |
| yEnd: center[1] - sinAngle * r0, |
| strokeColor: color === 'auto' ? this._getColor(seriesIndex, min + total / l * i) : color, |
| lineType: lineStyle.type, |
| lineWidth: lineStyle.width, |
| shadowColor: lineStyle.shadowColor, |
| shadowBlur: lineStyle.shadowBlur, |
| shadowOffsetX: lineStyle.shadowOffsetX, |
| shadowOffsetY: lineStyle.shadowOffsetY |
| } |
| })); |
| } |
| }, |
| _buildAxisLabel: function (seriesIndex) { |
| var serie = this.series[seriesIndex]; |
| if (!serie.axisLabel.show) { |
| return; |
| } |
| var splitNumber = serie.splitNumber; |
| var min = serie.min; |
| var total = serie.max - min; |
| var textStyle = serie.axisLabel.textStyle; |
| var textFont = this.getFont(textStyle); |
| var color = textStyle.color; |
| var params = this._paramsMap[seriesIndex]; |
| var center = params.center; |
| var startAngle = params.startAngle; |
| var totalAngle = params.totalAngle; |
| var r0 = params.radius[1] - this.parsePercent(serie.splitLine.length, params.radius[1]) - 10; |
| var angle; |
| var sinAngle; |
| var cosAngle; |
| var value; |
| for (var i = 0; i <= splitNumber; i++) { |
| value = accMath.accAdd(min, accMath.accMul(accMath.accDiv(total, splitNumber), i)); |
| angle = startAngle - totalAngle / splitNumber * i; |
| sinAngle = Math.sin(angle * Math.PI / 180); |
| cosAngle = Math.cos(angle * Math.PI / 180); |
| angle = (angle + 360) % 360; |
| this.shapeList.push(new TextShape({ |
| zlevel: this._zlevelBase + 1, |
| hoverable: false, |
| style: { |
| x: center[0] + cosAngle * r0, |
| y: center[1] - sinAngle * r0, |
| color: color === 'auto' ? this._getColor(seriesIndex, value) : color, |
| text: this._getLabelText(serie.axisLabel.formatter, value), |
| textAlign: angle >= 110 && angle <= 250 ? 'left' : angle <= 70 || angle >= 290 ? 'right' : 'center', |
| textBaseline: angle >= 10 && angle <= 170 ? 'top' : angle >= 190 && angle <= 350 ? 'bottom' : 'middle', |
| textFont: textFont, |
| shadowColor: textStyle.shadowColor, |
| shadowBlur: textStyle.shadowBlur, |
| shadowOffsetX: textStyle.shadowOffsetX, |
| shadowOffsetY: textStyle.shadowOffsetY |
| } |
| })); |
| } |
| }, |
| _buildPointer: function (seriesIndex) { |
| var serie = this.series[seriesIndex]; |
| if (!serie.pointer.show) { |
| return; |
| } |
| var total = serie.max - serie.min; |
| var pointer = serie.pointer; |
| var params = this._paramsMap[seriesIndex]; |
| var length = this.parsePercent(pointer.length, params.radius[1]); |
| var width = this.parsePercent(pointer.width, params.radius[1]); |
| var center = params.center; |
| var value = this._getValue(seriesIndex); |
| value = value < serie.max ? value : serie.max; |
| var angle = (params.startAngle - params.totalAngle / total * (value - serie.min)) * Math.PI / 180; |
| var color = pointer.color === 'auto' ? this._getColor(seriesIndex, value) : pointer.color; |
| var pointShape = new GaugePointerShape({ |
| zlevel: this._zlevelBase + 1, |
| style: { |
| x: center[0], |
| y: center[1], |
| r: length, |
| startAngle: params.startAngle * Math.PI / 180, |
| angle: angle, |
| color: color, |
| width: width, |
| shadowColor: pointer.shadowColor, |
| shadowBlur: pointer.shadowBlur, |
| shadowOffsetX: pointer.shadowOffsetX, |
| shadowOffsetY: pointer.shadowOffsetY |
| }, |
| highlightStyle: { |
| brushType: 'fill', |
| width: width > 2 ? 2 : width / 2, |
| color: '#fff' |
| } |
| }); |
| ecData.pack(pointShape, this.series[seriesIndex], seriesIndex, this.series[seriesIndex].data[0], 0, this.series[seriesIndex].data[0].name, value); |
| this.shapeList.push(pointShape); |
| this.shapeList.push(new CircleShape({ |
| zlevel: this._zlevelBase + 2, |
| hoverable: false, |
| style: { |
| x: center[0], |
| y: center[1], |
| r: pointer.width / 2.5, |
| color: '#fff' |
| } |
| })); |
| }, |
| _buildTitle: function (seriesIndex) { |
| var serie = this.series[seriesIndex]; |
| if (!serie.title.show) { |
| return; |
| } |
| var data = serie.data[0]; |
| var name = data.name != null ? data.name : ''; |
| if (name !== '') { |
| var title = serie.title; |
| var offsetCenter = title.offsetCenter; |
| var textStyle = title.textStyle; |
| var textColor = textStyle.color; |
| var params = this._paramsMap[seriesIndex]; |
| var x = params.center[0] + this.parsePercent(offsetCenter[0], params.radius[1]); |
| var y = params.center[1] + this.parsePercent(offsetCenter[1], params.radius[1]); |
| this.shapeList.push(new TextShape({ |
| zlevel: this._zlevelBase + (Math.abs(x - params.center[0]) + Math.abs(y - params.center[1])) < textStyle.fontSize * 2 ? 2 : 1, |
| hoverable: false, |
| style: { |
| x: x, |
| y: y, |
| color: textColor === 'auto' ? this._getColor(seriesIndex) : textColor, |
| text: name, |
| textAlign: 'center', |
| textFont: this.getFont(textStyle), |
| shadowColor: textStyle.shadowColor, |
| shadowBlur: textStyle.shadowBlur, |
| shadowOffsetX: textStyle.shadowOffsetX, |
| shadowOffsetY: textStyle.shadowOffsetY |
| } |
| })); |
| } |
| }, |
| _buildDetail: function (seriesIndex) { |
| var serie = this.series[seriesIndex]; |
| if (!serie.detail.show) { |
| return; |
| } |
| var detail = serie.detail; |
| var offsetCenter = detail.offsetCenter; |
| var color = detail.backgroundColor; |
| var textStyle = detail.textStyle; |
| var textColor = textStyle.color; |
| var params = this._paramsMap[seriesIndex]; |
| var value = this._getValue(seriesIndex); |
| var x = params.center[0] - detail.width / 2 + this.parsePercent(offsetCenter[0], params.radius[1]); |
| var y = params.center[1] + this.parsePercent(offsetCenter[1], params.radius[1]); |
| this.shapeList.push(new RectangleShape({ |
| zlevel: this._zlevelBase + (Math.abs(x + detail.width / 2 - params.center[0]) + Math.abs(y + detail.height / 2 - params.center[1])) < textStyle.fontSize ? 2 : 1, |
| hoverable: false, |
| style: { |
| x: x, |
| y: y, |
| width: detail.width, |
| height: detail.height, |
| brushType: 'both', |
| color: color === 'auto' ? this._getColor(seriesIndex, value) : color, |
| lineWidth: detail.borderWidth, |
| strokeColor: detail.borderColor, |
| shadowColor: detail.shadowColor, |
| shadowBlur: detail.shadowBlur, |
| shadowOffsetX: detail.shadowOffsetX, |
| shadowOffsetY: detail.shadowOffsetY, |
| text: this._getLabelText(detail.formatter, value), |
| textFont: this.getFont(textStyle), |
| textPosition: 'inside', |
| textColor: textColor === 'auto' ? this._getColor(seriesIndex, value) : textColor |
| } |
| })); |
| }, |
| _getValue: function (seriesIndex) { |
| var data = this.series[seriesIndex].data[0]; |
| return data.value != null ? data.value : data; |
| }, |
| _colorMap: function (seriesIndex) { |
| var serie = this.series[seriesIndex]; |
| var min = serie.min; |
| var total = serie.max - min; |
| var color = serie.axisLine.lineStyle.color; |
| if (!(color instanceof Array)) { |
| color = [[ |
| 1, |
| color |
| ]]; |
| } |
| var colorArray = []; |
| for (var i = 0, l = color.length; i < l; i++) { |
| colorArray.push([ |
| color[i][0] * total + min, |
| color[i][1] |
| ]); |
| } |
| this._paramsMap[seriesIndex].colorArray = colorArray; |
| }, |
| _getColor: function (seriesIndex, value) { |
| if (value == null) { |
| value = this._getValue(seriesIndex); |
| } |
| var colorArray = this._paramsMap[seriesIndex].colorArray; |
| for (var i = 0, l = colorArray.length; i < l; i++) { |
| if (colorArray[i][0] >= value) { |
| return colorArray[i][1]; |
| } |
| } |
| return colorArray[colorArray.length - 1][1]; |
| }, |
| _getSector: function (center, r0, r, startAngle, endAngle, color, lineStyle) { |
| return new SectorShape({ |
| zlevel: this._zlevelBase, |
| hoverable: false, |
| style: { |
| x: center[0], |
| y: center[1], |
| r0: r0, |
| r: r, |
| startAngle: startAngle, |
| endAngle: endAngle, |
| brushType: 'fill', |
| color: color, |
| shadowColor: lineStyle.shadowColor, |
| shadowBlur: lineStyle.shadowBlur, |
| shadowOffsetX: lineStyle.shadowOffsetX, |
| shadowOffsetY: lineStyle.shadowOffsetY |
| } |
| }); |
| }, |
| _getLabelText: function (formatter, value) { |
| if (formatter) { |
| if (typeof formatter === 'function') { |
| return formatter.call(this.myChart, value); |
| } else if (typeof formatter === 'string') { |
| return formatter.replace('{value}', value); |
| } |
| } |
| return value; |
| }, |
| refresh: function (newOption) { |
| if (newOption) { |
| this.option = newOption; |
| this.series = newOption.series; |
| } |
| this.backupShapeList(); |
| this._buildShape(); |
| } |
| }; |
| zrUtil.inherits(Gauge, ChartBase); |
| zrUtil.inherits(Gauge, ComponentBase); |
| require('../chart').define('gauge', Gauge); |
| return Gauge; |
| });define('echarts/util/shape/GaugePointer', [ |
| 'require', |
| 'zrender/shape/Base', |
| 'zrender/tool/util', |
| './normalIsCover' |
| ], function (require) { |
| var Base = require('zrender/shape/Base'); |
| var zrUtil = require('zrender/tool/util'); |
| function GaugePointer(options) { |
| Base.call(this, options); |
| } |
| GaugePointer.prototype = { |
| type: 'gauge-pointer', |
| buildPath: function (ctx, style) { |
| var r = style.r; |
| var width = style.width; |
| var angle = style.angle; |
| var x = style.x - Math.cos(angle) * width * (width >= r / 3 ? 1 : 2); |
| var y = style.y + Math.sin(angle) * width * (width >= r / 3 ? 1 : 2); |
| angle = style.angle - Math.PI / 2; |
| ctx.moveTo(x, y); |
| ctx.lineTo(style.x + Math.cos(angle) * width, style.y - Math.sin(angle) * width); |
| ctx.lineTo(style.x + Math.cos(style.angle) * r, style.y - Math.sin(style.angle) * r); |
| ctx.lineTo(style.x - Math.cos(angle) * width, style.y + Math.sin(angle) * width); |
| ctx.lineTo(x, y); |
| return; |
| }, |
| getRect: function (style) { |
| if (style.__rect) { |
| return style.__rect; |
| } |
| var width = style.width * 2; |
| var xStart = style.x; |
| var yStart = style.y; |
| var xEnd = xStart + Math.cos(style.angle) * style.r; |
| var yEnd = yStart - Math.sin(style.angle) * style.r; |
| style.__rect = { |
| x: Math.min(xStart, xEnd) - width, |
| y: Math.min(yStart, yEnd) - width, |
| width: Math.abs(xStart - xEnd) + width, |
| height: Math.abs(yStart - yEnd) + width |
| }; |
| return style.__rect; |
| }, |
| isCover: require('./normalIsCover') |
| }; |
| zrUtil.inherits(GaugePointer, Base); |
| return GaugePointer; |
| });define('echarts/chart/funnel', [ |
| 'require', |
| '../component/base', |
| './base', |
| 'zrender/shape/Text', |
| 'zrender/shape/Line', |
| 'zrender/shape/Polygon', |
| '../config', |
| '../util/ecData', |
| '../util/number', |
| 'zrender/tool/util', |
| 'zrender/tool/color', |
| 'zrender/tool/area', |
| '../chart' |
| ], function (require) { |
| var ComponentBase = require('../component/base'); |
| var ChartBase = require('./base'); |
| var TextShape = require('zrender/shape/Text'); |
| var LineShape = require('zrender/shape/Line'); |
| var PolygonShape = require('zrender/shape/Polygon'); |
| var ecConfig = require('../config'); |
| var ecData = require('../util/ecData'); |
| var number = require('../util/number'); |
| var zrUtil = require('zrender/tool/util'); |
| var zrColor = require('zrender/tool/color'); |
| var zrArea = require('zrender/tool/area'); |
| function Funnel(ecTheme, messageCenter, zr, option, myChart) { |
| ComponentBase.call(this, ecTheme, messageCenter, zr, option, myChart); |
| ChartBase.call(this); |
| this.refresh(option); |
| } |
| Funnel.prototype = { |
| type: ecConfig.CHART_TYPE_FUNNEL, |
| _buildShape: function () { |
| var series = this.series; |
| var legend = this.component.legend; |
| this._paramsMap = {}; |
| this._selected = {}; |
| this.selectedMap = {}; |
| var serieName; |
| for (var i = 0, l = series.length; i < l; i++) { |
| if (series[i].type === ecConfig.CHART_TYPE_FUNNEL) { |
| series[i] = this.reformOption(series[i]); |
| this.legendHoverLink = series[i].legendHoverLink || this.legendHoverLink; |
| serieName = series[i].name || ''; |
| this.selectedMap[serieName] = legend ? legend.isSelected(serieName) : true; |
| if (!this.selectedMap[serieName]) { |
| continue; |
| } |
| this._buildSingleFunnel(i); |
| this.buildMark(i); |
| } |
| } |
| this.addShapeList(); |
| }, |
| _buildSingleFunnel: function (seriesIndex) { |
| var legend = this.component.legend; |
| var serie = this.series[seriesIndex]; |
| var data = this._mapData(seriesIndex); |
| var location = this._getLocation(seriesIndex); |
| this._paramsMap[seriesIndex] = { |
| location: location, |
| data: data |
| }; |
| var itemName; |
| var total = 0; |
| var selectedData = []; |
| for (var i = 0, l = data.length; i < l; i++) { |
| itemName = data[i].name; |
| if (legend) { |
| this.selectedMap[itemName] = legend.isSelected(itemName); |
| } else { |
| this.selectedMap[itemName] = true; |
| } |
| if (this.selectedMap[itemName] && !isNaN(data[i].value)) { |
| selectedData.push(data[i]); |
| total++; |
| } |
| } |
| if (total === 0) { |
| return; |
| } |
| var funnelCase = this._buildFunnelCase(seriesIndex); |
| var align = serie.funnelAlign; |
| var gap = serie.gap; |
| var height = total > 1 ? (location.height - (total - 1) * gap) / total : location.height; |
| var width; |
| var lastY = location.y; |
| var lastWidth = serie.sort === 'descending' ? this._getItemWidth(seriesIndex, selectedData[0].value) : number.parsePercent(serie.minSize, location.width); |
| var next = serie.sort === 'descending' ? 1 : 0; |
| var centerX = location.centerX; |
| var pointList = []; |
| var x; |
| var polygon; |
| var lastPolygon; |
| for (var i = 0, l = selectedData.length; i < l; i++) { |
| itemName = selectedData[i].name; |
| if (this.selectedMap[itemName] && !isNaN(selectedData[i].value)) { |
| width = i <= l - 2 ? this._getItemWidth(seriesIndex, selectedData[i + next].value) : serie.sort === 'descending' ? number.parsePercent(serie.minSize, location.width) : number.parsePercent(serie.maxSize, location.width); |
| switch (align) { |
| case 'left': |
| x = location.x; |
| break; |
| case 'right': |
| x = location.x + location.width - lastWidth; |
| break; |
| default: |
| x = centerX - lastWidth / 2; |
| } |
| polygon = this._buildItem(seriesIndex, selectedData[i]._index, legend ? legend.getColor(itemName) : this.zr.getColor(selectedData[i]._index), x, lastY, lastWidth, width, height, align); |
| lastY += height + gap; |
| lastPolygon = polygon.style.pointList; |
| pointList.unshift([ |
| lastPolygon[0][0] - 10, |
| lastPolygon[0][1] |
| ]); |
| pointList.push([ |
| lastPolygon[1][0] + 10, |
| lastPolygon[1][1] |
| ]); |
| if (i === 0) { |
| if (lastWidth === 0) { |
| lastPolygon = pointList.pop(); |
| align == 'center' && (pointList[0][0] += 10); |
| align == 'right' && (pointList[0][0] = lastPolygon[0]); |
| pointList[0][1] -= align == 'center' ? 10 : 15; |
| if (l == 1) { |
| lastPolygon = polygon.style.pointList; |
| } |
| } else { |
| pointList[pointList.length - 1][1] -= 5; |
| pointList[0][1] -= 5; |
| } |
| } |
| lastWidth = width; |
| } |
| } |
| if (funnelCase) { |
| pointList.unshift([ |
| lastPolygon[3][0] - 10, |
| lastPolygon[3][1] |
| ]); |
| pointList.push([ |
| lastPolygon[2][0] + 10, |
| lastPolygon[2][1] |
| ]); |
| if (lastWidth === 0) { |
| lastPolygon = pointList.pop(); |
| align == 'center' && (pointList[0][0] += 10); |
| align == 'right' && (pointList[0][0] = lastPolygon[0]); |
| pointList[0][1] += align == 'center' ? 10 : 15; |
| } else { |
| pointList[pointList.length - 1][1] += 5; |
| pointList[0][1] += 5; |
| } |
| funnelCase.style.pointList = pointList; |
| } |
| }, |
| _buildFunnelCase: function (seriesIndex) { |
| var serie = this.series[seriesIndex]; |
| if (this.deepQuery([ |
| serie, |
| this.option |
| ], 'calculable')) { |
| var location = this._paramsMap[seriesIndex].location; |
| var gap = 10; |
| var funnelCase = { |
| hoverable: false, |
| style: { |
| pointListd: [ |
| [ |
| location.x - gap, |
| location.y - gap |
| ], |
| [ |
| location.x + location.width + gap, |
| location.y - gap |
| ], |
| [ |
| location.x + location.width + gap, |
| location.y + location.height + gap |
| ], |
| [ |
| location.x - gap, |
| location.y + location.height + gap |
| ] |
| ], |
| brushType: 'stroke', |
| lineWidth: 1, |
| strokeColor: serie.calculableHolderColor || this.ecTheme.calculableHolderColor |
| } |
| }; |
| ecData.pack(funnelCase, serie, seriesIndex, undefined, -1); |
| this.setCalculable(funnelCase); |
| funnelCase = new PolygonShape(funnelCase); |
| this.shapeList.push(funnelCase); |
| return funnelCase; |
| } |
| }, |
| _getLocation: function (seriesIndex) { |
| var gridOption = this.series[seriesIndex]; |
| var zrWidth = this.zr.getWidth(); |
| var zrHeight = this.zr.getHeight(); |
| var x = this.parsePercent(gridOption.x, zrWidth); |
| var y = this.parsePercent(gridOption.y, zrHeight); |
| var width; |
| if (gridOption.width == null) { |
| width = zrWidth - x - this.parsePercent(gridOption.x2, zrWidth); |
| } else { |
| width = this.parsePercent(gridOption.width, zrWidth); |
| } |
| var height; |
| if (gridOption.height == null) { |
| height = zrHeight - y - this.parsePercent(gridOption.y2, zrHeight); |
| } else { |
| height = this.parsePercent(gridOption.height, zrHeight); |
| } |
| return { |
| x: x, |
| y: y, |
| width: width, |
| height: height, |
| centerX: x + width / 2 |
| }; |
| }, |
| _mapData: function (seriesIndex) { |
| var serie = this.series[seriesIndex]; |
| var funnelData = zrUtil.clone(serie.data); |
| for (var i = 0, l = funnelData.length; i < l; i++) { |
| funnelData[i]._index = i; |
| } |
| function numDescending(a, b) { |
| if (a.value === '-') { |
| return 1; |
| } else if (b.value === '-') { |
| return -1; |
| } |
| return b.value - a.value; |
| } |
| function numAscending(a, b) { |
| return -numDescending(a, b); |
| } |
| if (serie.sort != 'none') { |
| funnelData.sort(serie.sort === 'descending' ? numDescending : numAscending); |
| } |
| return funnelData; |
| }, |
| _buildItem: function (seriesIndex, dataIndex, defaultColor, x, y, topWidth, bottomWidth, height, align) { |
| var series = this.series; |
| var serie = series[seriesIndex]; |
| var data = serie.data[dataIndex]; |
| var polygon = this.getPolygon(seriesIndex, dataIndex, defaultColor, x, y, topWidth, bottomWidth, height, align); |
| ecData.pack(polygon, series[seriesIndex], seriesIndex, series[seriesIndex].data[dataIndex], dataIndex, series[seriesIndex].data[dataIndex].name); |
| this.shapeList.push(polygon); |
| var label = this.getLabel(seriesIndex, dataIndex, defaultColor, x, y, topWidth, bottomWidth, height, align); |
| ecData.pack(label, series[seriesIndex], seriesIndex, series[seriesIndex].data[dataIndex], dataIndex, series[seriesIndex].data[dataIndex].name); |
| this.shapeList.push(label); |
| if (!this._needLabel(serie, data, false)) { |
| label.invisible = true; |
| } |
| var labelLine = this.getLabelLine(seriesIndex, dataIndex, defaultColor, x, y, topWidth, bottomWidth, height, align); |
| this.shapeList.push(labelLine); |
| if (!this._needLabelLine(serie, data, false)) { |
| labelLine.invisible = true; |
| } |
| var polygonHoverConnect = []; |
| var labelHoverConnect = []; |
| if (this._needLabelLine(serie, data, true)) { |
| polygonHoverConnect.push(labelLine.id); |
| labelHoverConnect.push(labelLine.id); |
| } |
| if (this._needLabel(serie, data, true)) { |
| polygonHoverConnect.push(label.id); |
| labelHoverConnect.push(polygon.id); |
| } |
| polygon.hoverConnect = polygonHoverConnect; |
| label.hoverConnect = labelHoverConnect; |
| return polygon; |
| }, |
| _getItemWidth: function (seriesIndex, value) { |
| var serie = this.series[seriesIndex]; |
| var location = this._paramsMap[seriesIndex].location; |
| var min = serie.min; |
| var max = serie.max; |
| var minSize = number.parsePercent(serie.minSize, location.width); |
| var maxSize = number.parsePercent(serie.maxSize, location.width); |
| return value * (maxSize - minSize) / (max - min); |
| }, |
| getPolygon: function (seriesIndex, dataIndex, defaultColor, xLT, y, topWidth, bottomWidth, height, align) { |
| var serie = this.series[seriesIndex]; |
| var data = serie.data[dataIndex]; |
| var queryTarget = [ |
| data, |
| serie |
| ]; |
| var normal = this.deepMerge(queryTarget, 'itemStyle.normal') || {}; |
| var emphasis = this.deepMerge(queryTarget, 'itemStyle.emphasis') || {}; |
| var normalColor = this.getItemStyleColor(normal.color, seriesIndex, dataIndex, data) || defaultColor; |
| var emphasisColor = this.getItemStyleColor(emphasis.color, seriesIndex, dataIndex, data) || (typeof normalColor === 'string' ? zrColor.lift(normalColor, -0.2) : normalColor); |
| var xLB; |
| switch (align) { |
| case 'left': |
| xLB = xLT; |
| break; |
| case 'right': |
| xLB = xLT + (topWidth - bottomWidth); |
| break; |
| default: |
| xLB = xLT + (topWidth - bottomWidth) / 2; |
| break; |
| } |
| var polygon = { |
| zlevel: this._zlevelBase, |
| clickable: this.deepQuery(queryTarget, 'clickable'), |
| style: { |
| pointList: [ |
| [ |
| xLT, |
| y |
| ], |
| [ |
| xLT + topWidth, |
| y |
| ], |
| [ |
| xLB + bottomWidth, |
| y + height |
| ], |
| [ |
| xLB, |
| y + height |
| ] |
| ], |
| brushType: 'both', |
| color: normalColor, |
| lineWidth: normal.borderWidth, |
| strokeColor: normal.borderColor |
| }, |
| highlightStyle: { |
| color: emphasisColor, |
| lineWidth: emphasis.borderWidth, |
| strokeColor: emphasis.borderColor |
| } |
| }; |
| if (this.deepQuery([ |
| data, |
| serie, |
| this.option |
| ], 'calculable')) { |
| this.setCalculable(polygon); |
| polygon.draggable = true; |
| } |
| return new PolygonShape(polygon); |
| }, |
| getLabel: function (seriesIndex, dataIndex, defaultColor, x, y, topWidth, bottomWidth, height, align) { |
| var serie = this.series[seriesIndex]; |
| var data = serie.data[dataIndex]; |
| var location = this._paramsMap[seriesIndex].location; |
| var itemStyle = zrUtil.merge(zrUtil.clone(data.itemStyle) || {}, serie.itemStyle); |
| var status = 'normal'; |
| var labelControl = itemStyle[status].label; |
| var textStyle = labelControl.textStyle || {}; |
| var lineLength = itemStyle[status].labelLine.length; |
| var text = this.getLabelText(seriesIndex, dataIndex, status); |
| var textFont = this.getFont(textStyle); |
| var textAlign; |
| var textColor = defaultColor; |
| labelControl.position = labelControl.position || itemStyle.normal.label.position; |
| if (labelControl.position === 'inner' || labelControl.position === 'inside' || labelControl.position === 'center') { |
| textAlign = align; |
| textColor = Math.max(topWidth, bottomWidth) / 2 > zrArea.getTextWidth(text, textFont) ? '#fff' : zrColor.reverse(defaultColor); |
| } else if (labelControl.position === 'left') { |
| textAlign = 'right'; |
| } else { |
| textAlign = 'left'; |
| } |
| var textShape = { |
| zlevel: this._zlevelBase + 1, |
| style: { |
| x: this._getLabelPoint(labelControl.position, x, location, topWidth, bottomWidth, lineLength, align), |
| y: y + height / 2, |
| color: textStyle.color || textColor, |
| text: text, |
| textAlign: textStyle.align || textAlign, |
| textBaseline: textStyle.baseline || 'middle', |
| textFont: textFont |
| } |
| }; |
| status = 'emphasis'; |
| labelControl = itemStyle[status].label || labelControl; |
| textStyle = labelControl.textStyle || textStyle; |
| lineLength = itemStyle[status].labelLine.length || lineLength; |
| labelControl.position = labelControl.position || itemStyle.normal.label.position; |
| text = this.getLabelText(seriesIndex, dataIndex, status); |
| textFont = this.getFont(textStyle); |
| textColor = defaultColor; |
| if (labelControl.position === 'inner' || labelControl.position === 'inside' || labelControl.position === 'center') { |
| textAlign = align; |
| textColor = Math.max(topWidth, bottomWidth) / 2 > zrArea.getTextWidth(text, textFont) ? '#fff' : zrColor.reverse(defaultColor); |
| } else if (labelControl.position === 'left') { |
| textAlign = 'right'; |
| } else { |
| textAlign = 'left'; |
| } |
| textShape.highlightStyle = { |
| x: this._getLabelPoint(labelControl.position, x, location, topWidth, bottomWidth, lineLength, align), |
| color: textStyle.color || textColor, |
| text: text, |
| textAlign: textStyle.align || textAlign, |
| textFont: textFont, |
| brushType: 'fill' |
| }; |
| return new TextShape(textShape); |
| }, |
| getLabelText: function (seriesIndex, dataIndex, status) { |
| var series = this.series; |
| var serie = series[seriesIndex]; |
| var data = serie.data[dataIndex]; |
| var formatter = this.deepQuery([ |
| data, |
| serie |
| ], 'itemStyle.' + status + '.label.formatter'); |
| if (formatter) { |
| if (typeof formatter === 'function') { |
| return formatter.call(this.myChart, serie.name, data.name, data.value); |
| } else if (typeof formatter === 'string') { |
| formatter = formatter.replace('{a}', '{a0}').replace('{b}', '{b0}').replace('{c}', '{c0}'); |
| formatter = formatter.replace('{a0}', serie.name).replace('{b0}', data.name).replace('{c0}', data.value); |
| return formatter; |
| } |
| } else { |
| return data.name; |
| } |
| }, |
| getLabelLine: function (seriesIndex, dataIndex, defaultColor, x, y, topWidth, bottomWidth, height, align) { |
| var serie = this.series[seriesIndex]; |
| var data = serie.data[dataIndex]; |
| var location = this._paramsMap[seriesIndex].location; |
| var itemStyle = zrUtil.merge(zrUtil.clone(data.itemStyle) || {}, serie.itemStyle); |
| var status = 'normal'; |
| var labelLineControl = itemStyle[status].labelLine; |
| var lineLength = itemStyle[status].labelLine.length; |
| var lineStyle = labelLineControl.lineStyle || {}; |
| var labelControl = itemStyle[status].label; |
| labelControl.position = labelControl.position || itemStyle.normal.label.position; |
| var lineShape = { |
| zlevel: this._zlevelBase + 1, |
| hoverable: false, |
| style: { |
| xStart: this._getLabelLineStartPoint(x, location, topWidth, bottomWidth, align), |
| yStart: y + height / 2, |
| xEnd: this._getLabelPoint(labelControl.position, x, location, topWidth, bottomWidth, lineLength, align), |
| yEnd: y + height / 2, |
| strokeColor: lineStyle.color || defaultColor, |
| lineType: lineStyle.type, |
| lineWidth: lineStyle.width |
| } |
| }; |
| status = 'emphasis'; |
| labelLineControl = itemStyle[status].labelLine || labelLineControl; |
| lineLength = itemStyle[status].labelLine.length || lineLength; |
| lineStyle = labelLineControl.lineStyle || lineStyle; |
| labelControl = itemStyle[status].label || labelControl; |
| labelControl.position = labelControl.position; |
| lineShape.highlightStyle = { |
| xEnd: this._getLabelPoint(labelControl.position, x, location, topWidth, bottomWidth, lineLength, align), |
| strokeColor: lineStyle.color || defaultColor, |
| lineType: lineStyle.type, |
| lineWidth: lineStyle.width |
| }; |
| return new LineShape(lineShape); |
| }, |
| _getLabelPoint: function (position, x, location, topWidth, bottomWidth, lineLength, align) { |
| position = position === 'inner' || position === 'inside' ? 'center' : position; |
| switch (position) { |
| case 'center': |
| return align == 'center' ? x + topWidth / 2 : align == 'left' ? x + 10 : x + topWidth - 10; |
| case 'left': |
| if (lineLength === 'auto') { |
| return location.x - 10; |
| } else { |
| return align == 'center' ? location.centerX - Math.max(topWidth, bottomWidth) / 2 - lineLength : align == 'right' ? x - (topWidth < bottomWidth ? bottomWidth - topWidth : 0) - lineLength : location.x - lineLength; |
| } |
| break; |
| default: |
| if (lineLength === 'auto') { |
| return location.x + location.width + 10; |
| } else { |
| return align == 'center' ? location.centerX + Math.max(topWidth, bottomWidth) / 2 + lineLength : align == 'right' ? location.x + location.width + lineLength : x + Math.max(topWidth, bottomWidth) + lineLength; |
| } |
| } |
| }, |
| _getLabelLineStartPoint: function (x, location, topWidth, bottomWidth, align) { |
| return align == 'center' ? location.centerX : topWidth < bottomWidth ? x + Math.min(topWidth, bottomWidth) / 2 : x + Math.max(topWidth, bottomWidth) / 2; |
| }, |
| _needLabel: function (serie, data, isEmphasis) { |
| return this.deepQuery([ |
| data, |
| serie |
| ], 'itemStyle.' + (isEmphasis ? 'emphasis' : 'normal') + '.label.show'); |
| }, |
| _needLabelLine: function (serie, data, isEmphasis) { |
| return this.deepQuery([ |
| data, |
| serie |
| ], 'itemStyle.' + (isEmphasis ? 'emphasis' : 'normal') + '.labelLine.show'); |
| }, |
| refresh: function (newOption) { |
| if (newOption) { |
| this.option = newOption; |
| this.series = newOption.series; |
| } |
| this.backupShapeList(); |
| this._buildShape(); |
| } |
| }; |
| zrUtil.inherits(Funnel, ChartBase); |
| zrUtil.inherits(Funnel, ComponentBase); |
| require('../chart').define('funnel', Funnel); |
| return Funnel; |
| });define('echarts/chart/eventRiver', [ |
| 'require', |
| '../component/base', |
| './base', |
| '../layout/eventRiver', |
| 'zrender/shape/Polygon', |
| '../component/axis', |
| '../component/grid', |
| '../component/dataZoom', |
| '../config', |
| '../util/ecData', |
| '../util/date', |
| 'zrender/tool/util', |
| 'zrender/tool/color', |
| '../chart' |
| ], function (require) { |
| var ComponentBase = require('../component/base'); |
| var ChartBase = require('./base'); |
| var eventRiverLayout = require('../layout/eventRiver'); |
| var PolygonShape = require('zrender/shape/Polygon'); |
| require('../component/axis'); |
| require('../component/grid'); |
| require('../component/dataZoom'); |
| var ecConfig = require('../config'); |
| var ecData = require('../util/ecData'); |
| var ecDate = require('../util/date'); |
| var zrUtil = require('zrender/tool/util'); |
| var zrColor = require('zrender/tool/color'); |
| function EventRiver(ecTheme, messageCenter, zr, option, myChart) { |
| ComponentBase.call(this, ecTheme, messageCenter, zr, option, myChart); |
| ChartBase.call(this); |
| var self = this; |
| self._ondragend = function () { |
| self.isDragend = true; |
| }; |
| this.refresh(option); |
| } |
| EventRiver.prototype = { |
| type: ecConfig.CHART_TYPE_EVENTRIVER, |
| _buildShape: function () { |
| var series = this.series; |
| this.selectedMap = {}; |
| this._dataPreprocessing(); |
| var legend = this.component.legend; |
| var eventRiverSeries = []; |
| for (var i = 0; i < series.length; i++) { |
| if (series[i].type === this.type) { |
| series[i] = this.reformOption(series[i]); |
| this.legendHoverLink = series[i].legendHoverLink || this.legendHoverLink; |
| var serieName = series[i].name || ''; |
| this.selectedMap[serieName] = legend ? legend.isSelected(serieName) : true; |
| if (!this.selectedMap[serieName]) { |
| continue; |
| } |
| this.buildMark(i); |
| eventRiverSeries.push(this.series[i]); |
| } |
| } |
| eventRiverLayout(eventRiverSeries, this._intervalX, this.component.grid.getArea()); |
| this._drawEventRiver(); |
| this.addShapeList(); |
| }, |
| _dataPreprocessing: function () { |
| var series = this.series; |
| var xAxis; |
| var evolutionList; |
| for (var i = 0, iLen = series.length; i < iLen; i++) { |
| if (series[i].type === this.type) { |
| xAxis = this.component.xAxis.getAxis(series[i].xAxisIndex || 0); |
| for (var j = 0, jLen = series[i].eventList.length; j < jLen; j++) { |
| evolutionList = series[i].eventList[j].evolution; |
| for (var k = 0, kLen = evolutionList.length; k < kLen; k++) { |
| evolutionList[k].timeScale = xAxis.getCoord(ecDate.getNewDate(evolutionList[k].time) - 0); |
| evolutionList[k].valueScale = Math.pow(evolutionList[k].value, 0.8); |
| } |
| } |
| } |
| } |
| this._intervalX = Math.round(this.component.grid.getWidth() / 40); |
| }, |
| _drawEventRiver: function () { |
| var series = this.series; |
| for (var i = 0; i < series.length; i++) { |
| var serieName = series[i].name || ''; |
| if (series[i].type === this.type && this.selectedMap[serieName]) { |
| for (var j = 0; j < series[i].eventList.length; j++) { |
| this._drawEventBubble(series[i].eventList[j], i, j); |
| } |
| } |
| } |
| }, |
| _drawEventBubble: function (oneEvent, seriesIndex, dataIndex) { |
| var series = this.series; |
| var serie = series[seriesIndex]; |
| var serieName = serie.name || ''; |
| var data = serie.eventList[dataIndex]; |
| var queryTarget = [ |
| data, |
| serie |
| ]; |
| var legend = this.component.legend; |
| var defaultColor = legend ? legend.getColor(serieName) : this.zr.getColor(seriesIndex); |
| var normal = this.deepMerge(queryTarget, 'itemStyle.normal') || {}; |
| var emphasis = this.deepMerge(queryTarget, 'itemStyle.emphasis') || {}; |
| var normalColor = this.getItemStyleColor(normal.color, seriesIndex, dataIndex, data) || defaultColor; |
| var emphasisColor = this.getItemStyleColor(emphasis.color, seriesIndex, dataIndex, data) || (typeof normalColor === 'string' ? zrColor.lift(normalColor, -0.2) : normalColor); |
| var pts = this._calculateControlPoints(oneEvent); |
| var eventBubbleShape = { |
| zlevel: this._zlevelBase, |
| clickable: this.deepQuery(queryTarget, 'clickable'), |
| style: { |
| pointList: pts, |
| smooth: 'spline', |
| brushType: 'both', |
| lineJoin: 'round', |
| color: normalColor, |
| lineWidth: normal.borderWidth, |
| strokeColor: normal.borderColor |
| }, |
| highlightStyle: { |
| color: emphasisColor, |
| lineWidth: emphasis.borderWidth, |
| strokeColor: emphasis.borderColor |
| }, |
| draggable: 'vertical', |
| ondragend: this._ondragend |
| }; |
| eventBubbleShape = new PolygonShape(eventBubbleShape); |
| this.addLabel(eventBubbleShape, serie, data, oneEvent.name); |
| ecData.pack(eventBubbleShape, series[seriesIndex], seriesIndex, series[seriesIndex].eventList[dataIndex], dataIndex, series[seriesIndex].eventList[dataIndex].name); |
| this.shapeList.push(eventBubbleShape); |
| }, |
| _calculateControlPoints: function (oneEvent) { |
| var intervalX = this._intervalX; |
| var posY = oneEvent.y; |
| var evolution = oneEvent.evolution; |
| var n = evolution.length; |
| if (n < 1) { |
| return; |
| } |
| var time = []; |
| var value = []; |
| for (var i = 0; i < n; i++) { |
| time.push(evolution[i].timeScale); |
| value.push(evolution[i].valueScale); |
| } |
| var pts = []; |
| pts.push([ |
| time[0], |
| posY |
| ]); |
| var i = 0; |
| for (i = 0; i < n - 1; i++) { |
| pts.push([ |
| (time[i] + time[i + 1]) / 2, |
| value[i] / -2 + posY |
| ]); |
| } |
| pts.push([ |
| (time[i] + (time[i] + intervalX)) / 2, |
| value[i] / -2 + posY |
| ]); |
| pts.push([ |
| time[i] + intervalX, |
| posY |
| ]); |
| pts.push([ |
| (time[i] + (time[i] + intervalX)) / 2, |
| value[i] / 2 + posY |
| ]); |
| for (i = n - 1; i > 0; i--) { |
| pts.push([ |
| (time[i] + time[i - 1]) / 2, |
| value[i - 1] / 2 + posY |
| ]); |
| } |
| return pts; |
| }, |
| ondragend: function (param, status) { |
| if (!this.isDragend || !param.target) { |
| return; |
| } |
| status.dragOut = true; |
| status.dragIn = true; |
| status.needRefresh = false; |
| this.isDragend = false; |
| }, |
| refresh: function (newOption) { |
| if (newOption) { |
| this.option = newOption; |
| this.series = newOption.series; |
| } |
| this.backupShapeList(); |
| this._buildShape(); |
| } |
| }; |
| zrUtil.inherits(EventRiver, ChartBase); |
| zrUtil.inherits(EventRiver, ComponentBase); |
| require('../chart').define('eventRiver', EventRiver); |
| return EventRiver; |
| });define('echarts/layout/eventRiver', ['require'], function (require) { |
| function eventRiverLayout(series, intervalX, area) { |
| var space = 5; |
| var scale = intervalX; |
| function importanceSort(a, b) { |
| var x = a.importance; |
| var y = b.importance; |
| return x > y ? -1 : x < y ? 1 : 0; |
| } |
| function indexOf(array, value) { |
| if (array.indexOf) { |
| return array.indexOf(value); |
| } |
| for (var i = 0, len = array.length; i < len; i++) { |
| if (array[i] === value) { |
| return i; |
| } |
| } |
| return -1; |
| } |
| for (var i = 0; i < series.length; i++) { |
| for (var j = 0; j < series[i].eventList.length; j++) { |
| if (series[i].eventList[j].weight == null) { |
| series[i].eventList[j].weight = 1; |
| } |
| var importance = 0; |
| for (var k = 0; k < series[i].eventList[j].evolution.length; k++) { |
| importance += series[i].eventList[j].evolution[k].valueScale; |
| } |
| series[i].eventList[j].importance = importance * series[i].eventList[j].weight; |
| } |
| series[i].eventList.sort(importanceSort); |
| } |
| for (var i = 0; i < series.length; i++) { |
| if (series[i].weight == null) { |
| series[i].weight = 1; |
| } |
| var importance = 0; |
| for (var j = 0; j < series[i].eventList.length; j++) { |
| importance += series[i].eventList[j].weight; |
| } |
| series[i].importance = importance * series[i].weight; |
| } |
| series.sort(importanceSort); |
| var minTime = Number.MAX_VALUE; |
| var maxTime = 0; |
| for (var i = 0; i < series.length; i++) { |
| for (var j = 0; j < series[i].eventList.length; j++) { |
| for (var k = 0; k < series[i].eventList[j].evolution.length; k++) { |
| var time = series[i].eventList[j].evolution[k].timeScale; |
| minTime = Math.min(minTime, time); |
| maxTime = Math.max(maxTime, time); |
| } |
| } |
| } |
| var root = segmentTreeBuild(Math.floor(minTime), Math.ceil(maxTime)); |
| var totalMaxY = 0; |
| for (var i = 0; i < series.length; i++) { |
| for (var j = 0; j < series[i].eventList.length; j++) { |
| var e = series[i].eventList[j]; |
| e.time = []; |
| e.value = []; |
| for (var k = 0; k < series[i].eventList[j].evolution.length; k++) { |
| e.time.push(series[i].eventList[j].evolution[k].timeScale); |
| e.value.push(series[i].eventList[j].evolution[k].valueScale); |
| } |
| var mxIndex = indexOf(e.value, Math.max.apply(Math, e.value)); |
| var maxY = segmentTreeQuery(root, e.time[mxIndex], e.time[mxIndex + 1]); |
| var k = 0; |
| e.y = maxY + e.value[mxIndex] / 2 + space; |
| for (k = 0; k < e.time.length - 1; k++) { |
| var curMaxY = segmentTreeQuery(root, e.time[k], e.time[k + 1]); |
| if (e.y - e.value[k] / 2 - space < curMaxY) { |
| e.y = curMaxY + e.value[k] / 2 + space; |
| } |
| } |
| var curMaxY = segmentTreeQuery(root, e.time[k], e.time[k] + scale); |
| if (e.y - e.value[k] / 2 - space < curMaxY) { |
| e.y = curMaxY + e.value[k] / 2 + space; |
| } |
| series[i].y = e.y; |
| totalMaxY = Math.max(totalMaxY, e.y + e.value[mxIndex] / 2); |
| for (k = 0; k < e.time.length - 1; k++) { |
| segmentTreeInsert(root, e.time[k], e.time[k + 1], e.y + e.value[k] / 2); |
| } |
| segmentTreeInsert(root, e.time[k], e.time[k] + scale, e.y + e.value[k] / 2); |
| } |
| } |
| scaleY(series, area, totalMaxY, space); |
| } |
| function scaleY(series, area, maxY, space) { |
| var yBase = area.y; |
| var yScale = (area.height - space) / maxY; |
| for (var i = 0; i < series.length; i++) { |
| series[i].y = series[i].y * yScale + yBase; |
| var eventList = series[i].eventList; |
| for (var j = 0; j < eventList.length; j++) { |
| eventList[j].y = eventList[j].y * yScale + yBase; |
| var evolutionList = eventList[j].evolution; |
| for (var k = 0; k < evolutionList.length; k++) { |
| evolutionList[k].valueScale *= yScale * 1; |
| } |
| } |
| } |
| } |
| function segmentTreeBuild(left, right) { |
| var root = { |
| 'left': left, |
| 'right': right, |
| 'leftChild': null, |
| 'rightChild': null, |
| 'maxValue': 0 |
| }; |
| if (left + 1 < right) { |
| var mid = Math.round((left + right) / 2); |
| root.leftChild = segmentTreeBuild(left, mid); |
| root.rightChild = segmentTreeBuild(mid, right); |
| } |
| return root; |
| } |
| function segmentTreeQuery(root, left, right) { |
| if (right - left < 1) { |
| return 0; |
| } |
| var mid = Math.round((root.left + root.right) / 2); |
| var result = 0; |
| if (left == root.left && right == root.right) { |
| result = root.maxValue; |
| } else if (right <= mid && root.leftChild != null) { |
| result = segmentTreeQuery(root.leftChild, left, right); |
| } else if (left >= mid && root.rightChild != null) { |
| result = segmentTreeQuery(root.rightChild, left, right); |
| } else { |
| var leftValue = 0; |
| var rightValue = 0; |
| if (root.leftChild != null) { |
| leftValue = segmentTreeQuery(root.leftChild, left, mid); |
| } |
| if (root.rightChild != null) { |
| rightValue = segmentTreeQuery(root.rightChild, mid, right); |
| } |
| result = leftValue > rightValue ? leftValue : rightValue; |
| } |
| return result; |
| } |
| function segmentTreeInsert(root, left, right, value) { |
| if (root == null) { |
| return; |
| } |
| var mid = Math.round((root.left + root.right) / 2); |
| root.maxValue = root.maxValue > value ? root.maxValue : value; |
| if (Math.floor(left * 10) == Math.floor(root.left * 10) && Math.floor(right * 10) == Math.floor(root.right * 10)) { |
| return; |
| } else if (right <= mid) { |
| segmentTreeInsert(root.leftChild, left, right, value); |
| } else if (left >= mid) { |
| segmentTreeInsert(root.rightChild, left, right, value); |
| } else { |
| segmentTreeInsert(root.leftChild, left, mid, value); |
| segmentTreeInsert(root.rightChild, mid, right, value); |
| } |
| } |
| return eventRiverLayout; |
| }); |
| var zrender = require('zrender'); |
| zrender.tool = { |
| color : require('zrender/tool/color'), |
| math : require('zrender/tool/math'), |
| util : require('zrender/tool/util'), |
| vector : require('zrender/tool/vector'), |
| area : require('zrender/tool/area'), |
| event : require('zrender/tool/event') |
| } |
| |
| zrender.animation = { |
| Animation : require('zrender/animation/Animation'), |
| Cip : require('zrender/animation/Clip'), |
| easing : require('zrender/animation/easing') |
| } |
| var echarts = require('echarts'); |
| echarts.config = require('echarts/config'); |
| echarts.util = { |
| mapData : { |
| params : require('echarts/util/mapData/params') |
| } |
| } |
| |
| require("echarts/chart/gauge"); |
| require("echarts/chart/funnel"); |
| require("echarts/chart/scatter"); |
| require("echarts/chart/k"); |
| require("echarts/chart/radar"); |
| require("echarts/chart/chord"); |
| require("echarts/chart/force"); |
| require("echarts/chart/line"); |
| require("echarts/chart/bar"); |
| require("echarts/chart/pie"); |
| require("echarts/chart/eventRiver"); |
| require("echarts/chart/map"); |
| require("echarts/chart/island"); |
| |
| _global['echarts'] = echarts; |
| _global['zrender'] = zrender; |
| |
| })(window); |
