@supermapgis/iclient-ol 11.2.0

package/overlay/mapv/MapvLayer.js

@@ -0,0 +1,413 @@
+/* Copyright© 2000 - 2024 SuperMap Software Co.Ltd. All rights reserved.
+ * This program are made available under the terms of the Apache License, Version 2.0
+ * which accompanies this distribution and is available at http://www.apache.org/licenses/LICENSE-2.0.html.*/
+import {
+    MapvCanvasLayer
+} from './MapvCanvasLayer';
+import {
+    baiduMapLayer
+} from "mapv";
+import PointerInteraction from 'ol/interaction/Pointer';
+
+var BaiduMapLayer = baiduMapLayer ? baiduMapLayer.__proto__ : Function;
+
+/**
+ * @class MapvLayer
+ * @classdesc MapV 图层类。MapV 是一款地理信息可视化开源库，MapV 图层可以用来展示大量地理信息数据，点、线、面的数据，每种数据有不同的展示类型，如直接打点、热力图、网格、聚合等方式展示数据。<br>
+ * 展示大量的点数据：如热力图、网格、蜂窝状、点聚合、按颜色区间、按半径大小等方式。<br>
+ * 展示大量的线数据：如普通画线、高亮叠加、热力线数据展示等方式，适合展示大量轨迹的场景。<br>
+ * 展示大量的自定义面数据：按颜色区间来展示，如展示行政区划数据。
+ * @private
+ * @param {Object} map - 地图。
+ * @param {Mapv.DataSet} [dataSet] - 数据集。
+ * @param {Object} options - 参数。
+ * @param {number} mapWidth - 地图宽度。
+ * @param {number} mapHeight - 地图高度。
+ * @param {Object} source - 资源。
+ * @param {number} options.width - 画布宽度。
+ * @param {number} options.height - 画布高度。
+ * @param {string} [options.paneName='mapPane'] - 窗口名。
+ * @param {string} [options.context] - 内容。
+ * @param {number} [options.zIndex] - 层级。
+ * @param {string} [options.mixBlendMode] - 最小混合模式。
+ 
+ * @extends {Mapv.BaiduMapLayer}
+ */
+export class MapvLayer extends BaiduMapLayer {
+
+    constructor(map, dataSet, options, mapWidth, mapHeight, source) {
+        super(map, dataSet, options);
+        this.dataSet = dataSet;
+        this.mapWidth = mapWidth;
+        this.mapHeight = mapHeight;
+        var self = this;
+        options = options || {};
+        this.source = source;
+        self.animator = null;
+        self.map = map;
+        self.init(options);
+        self.argCheck(options);
+        this.canvasLayer = new MapvCanvasLayer({
+            map: map,
+            context: this.context,
+            paneName: options.paneName,
+            mixBlendMode: options.mixBlendMode,
+            enableMassClear: options.enableMassClear,
+            zIndex: options.zIndex,
+            width: mapWidth,
+            height: mapHeight,
+            update: function update() {
+                self._canvasUpdate();
+            }
+        });
+        this.clickEvent = this.clickEvent.bind(this);
+        this.mousemoveEvent = this.mousemoveEvent.bind(this);
+        map.on('movestart', this.moveStartEvent.bind(this));
+        map.on('moveend', this.moveEndEvent.bind(this));
+        map.getView().on('change:center', this.zoomEvent.bind(this));
+        map.getView().on('change:size', this.sizeEvent.bind(this));
+        map.on('pointerdrag', this.dragEvent.bind(this));
+        this.bindEvent();
+    }
+
+    /**
+     * @function MapvLayer.prototype.init
+     * @param {Object} options - 参数。
+     * @description 初始化参数。
+     */
+    init(options) {
+        var self = this;
+        self.options = options;
+        this.initDataRange(options);
+        this.context = self.options.context || '2d';
+        if (self.options.zIndex) {
+            this.canvasLayer && this.canvasLayer.setZIndex(self.options.zIndex);
+        }
+        this.initAnimator();
+    }
+
+    /**
+     * @function MapvLayer.prototype.clickEvent
+     * @param {Object} e - 事件参数。
+     * @description 点击事件。
+     */
+    clickEvent(e) {
+        var pixel = e.pixel;
+        super.clickEvent({
+            x: pixel[0] + this.offset[0],
+            y: pixel[1] + this.offset[1]
+        }, e);
+    }
+
+    /**
+     * @function MapvLayer.prototype.mousemoveEvent
+     * @param {Object} e - 事件参数。
+     * @description 鼠标移动事件。
+     */
+    mousemoveEvent(e) {
+        var pixel = e.pixel;
+        super.mousemoveEvent({
+            x: pixel[0],
+            y: pixel[1]
+        }, e);
+    }
+
+    /**
+     * @function MapvLayer.prototype.dragEvent
+     * @description 鼠标拖动事件。
+     */
+    dragEvent() {
+        this.clear(this.getContext());
+    }
+
+    /**
+     * @function MapvLayer.prototype.zoomEvent
+     * @description 缩放事件。
+     */
+    zoomEvent() {
+        this.clear(this.getContext());
+    }
+    /**
+     * @function MapvLayer.prototype.sizeEvent
+     * @description 地图窗口大小发生变化时触发。
+     */
+    sizeEvent() {
+        this.canvasLayer.resize();
+    }
+
+
+    /**
+     * @function MapvLayer.prototype.moveStartEvent
+     * @description 开始移动事件。
+     */
+    moveStartEvent() {
+        var animationOptions = this.options.animation;
+        if (this.isEnabledTime() && this.animator) {
+            this.steps.step = animationOptions.stepsRange.start;
+        }
+    }
+
+    /**
+     * @function MapvLayer.prototype.moveEndEvent
+     * @description 结束移动事件。
+     */
+    moveEndEvent() {
+        this.canvasLayer.draw();
+    }
+
+    /**
+     * @function MapvLayer.prototype.bindEvent
+     * @description 绑定事件。
+     */
+    bindEvent() {
+        var me = this;
+        var map = me.map;
+        if (me.options.methods) {
+            if (me.options.methods.click) {
+                map.on('click', me.clickEvent);
+            }
+            if (me.options.methods.mousemove) {
+                me.pointerInteraction = new PointerInteraction();
+                me.pointerInteraction.handleMoveEvent_ = function (event) {
+                    me.mousemoveEvent(event);
+                };
+                map.addInteraction(me.pointerInteraction);
+            }
+        }
+    }
+
+    /**
+     * @function MapvLayer.prototype.unbindEvent
+     * @description 解除绑定事件。
+     */
+    unbindEvent() {
+        var map = this.map;
+        if (this.options.methods) {
+            if (this.options.methods.click) {
+                map.un('click', this.clickEvent);
+            }
+            if (this.options.methods.mousemove) {
+                map.removeInteraction(this.pointerInteraction)
+            }
+        }
+    }
+
+    /**
+     * @function MapvLayer.prototype.addData
+     * @description 添加数据。
+     * @param {Object} data - 待添加的数据。
+     * @param {Object} options - 待添加的数据信息。
+     */
+    addData(data, options) {
+        var _data = data;
+        if (data && data.get) {
+            _data = data.get();
+        }
+        this.dataSet.add(_data);
+        this.update({
+            options: options
+        });
+    }
+
+    /**
+     * @function MapvLayer.prototype.update
+     * @description 更新图层。
+     * @param {Object} opt - 待更新的数据。
+     * @param {Object} opt.data - mapv 数据集。
+     */
+    update(opt) {
+        var update = opt || {};
+        var _data = update.data;
+        if (_data && _data.get) {
+            _data = _data.get();
+        }
+        if (_data != undefined) {
+            this.dataSet.set(_data);
+        }
+        super.update({
+            options: update.options
+        });
+    }
+
+    draw() {
+        this.canvasLayer.draw();
+    }
+
+    /**
+     * @function MapvLayer.prototype.getData
+     * @description 获取数据。
+     */
+    getData() {
+        return this.dataSet;
+    }
+
+    /**
+     * @function MapvLayer.prototype.removeData
+     * @description 删除符合过滤条件的数据。
+     * @param {function} filter - 过滤条件。条件参数为数据项，返回值为 true，表示删除该元素；否则表示不删除。
+     */
+    removeData(filter) {
+        if (!this.dataSet) {
+            return;
+        }
+        var newData = this.dataSet.get({
+            filter: function (data) {
+                return (filter != null && typeof filter === "function") ? !filter(data) : true;
+            }
+        });
+        this.dataSet.set(newData);
+        this.update({
+            options: null
+        });
+    }
+
+    /**
+     * @function MapvLayer.prototype.clearData
+     * @description 清除数据。
+     */
+    clearData() {
+        this.dataSet && this.dataSet.clear();
+        this.update({
+            options: null
+        });
+    }
+
+    _canvasUpdate(time) {
+        if (!this.canvasLayer) {
+            return;
+        }
+        var self = this;
+        var animationOptions = self.options.animation;
+        var map = self.map;
+        var context = self.canvasLayer.canvas.getContext(self.context);
+        if (self.isEnabledTime()) {
+            if (time === undefined) {
+                self.clear(context);
+                return;
+            }
+            if (!self.context || self.context === '2d') {
+                context.save();
+                context.globalCompositeOperation = 'destination-out';
+                context.fillStyle = 'rgba(0, 0, 0, .1)';
+                context.fillRect(0, 0, context.canvas.width, context.canvas.height);
+                context.restore();
+            }
+        } else {
+            this.clear(context);
+        }
+        if (!self.context || self.context === '2d') {
+            for (var key in self.options) {
+                context[key] = self.options[key];
+            }
+        } else {
+            context.clear(context.COLOR_BUFFER_BIT);
+        }
+        var ext = map.getView().calculateExtent();
+        var topLeftPx = map.getPixelFromCoordinate([ext[0], ext[3]]);
+
+        self._mapCenter = map.getView().getCenter();
+        self._mapCenterPx = map.getPixelFromCoordinate(self._mapCenter);
+        self._reselutions = map.getView().getResolution();
+        self._rotation = -map.getView().getRotation();
+        var zoomUnit = self._reselutions;
+        var scaleRatio = 1;
+        if (this.context != '2d') {
+            var global$2 = typeof window === 'undefined' ? {} : window;
+            var devicePixelRatio = global$2.devicePixelRatio || 1;
+            scaleRatio = devicePixelRatio;
+        }
+        var dataGetOptions = {
+            transferCoordinate: function (coordinate) {
+                var x = (coordinate[0] - self._mapCenter[0]) / self._reselutions,
+                    y = (self._mapCenter[1] - coordinate[1]) / self._reselutions;
+                var scaledP = [x + self._mapCenterPx[0], y + self._mapCenterPx[1]];
+                scaledP = scale(scaledP, self._mapCenterPx, 1);
+                /*//有旋转量的时候处理旋转
+                if (self._rotation !== 0) {
+                    var rotatedP = rotate(scaledP, self._rotation, self._mapCenterPx);
+                    return [rotatedP[0] + self.offset[0], rotatedP[1] + self.offset[1]];
+                }
+                //处理放大或缩小级别*/
+                return [(scaledP[0] + self.offset[0]) * scaleRatio, (scaledP[1] + self.offset[1]) * scaleRatio];
+            }
+        };
+
+        // //获取某像素坐标点pixelP绕中心center逆时针旋转rotation弧度后的像素点坐标。
+        // function rotate(pixelP, rotation, center) {
+        //     var x = Math.cos(rotation) * (pixelP[0] - center[0]) - Math.sin(rotation) * (pixelP[1] - center[1]) + center[0];
+        //     var y = Math.sin(rotation) * (pixelP[0] - center[0]) + Math.cos(rotation) * (pixelP[1] - center[1]) + center[1];
+        //     return [x, y];
+        // }
+
+        //获取某像素坐标点pixelP相对于中心center进行缩放scaleRatio倍后的像素点坐标。
+        function scale(pixelP, center, scaleRatio) {
+            var x = (pixelP[0] - center[0]) * scaleRatio + center[0];
+            var y = (pixelP[1] - center[1]) * scaleRatio + center[1];
+            return [x, y];
+        }
+
+        if (time !== undefined) {
+            dataGetOptions.filter = function (item) {
+                var trails = animationOptions.trails || 10;
+                return (time && item.time > (time - trails) && item.time < time);
+            };
+        }
+        if (self.isEnabledTime() && !self.notFirst) {
+            self.canvasLayer.resize(self.mapWidth, self.mapHeight);
+            self.notFirst = true;
+        }
+        var data = self.dataSet.get(dataGetOptions);
+        self.processData(data);
+        // 兼容unit为'm'的情况
+        if (self.options.unit === 'm') {
+            if (self.options.size) {
+                self.options._size = self.options.size / zoomUnit;
+            }
+            if (self.options.width) {
+                self.options._width = self.options.width / zoomUnit;
+            }
+            if (self.options.height) {
+                self.options._height = self.options.height / zoomUnit;
+            }
+        } else {
+            self.options._size = self.options.size;
+            self.options._height = self.options.height;
+            self.options._width = self.options.width;
+        }
+
+        var pixel = map.getPixelFromCoordinate([0, 0]);
+        pixel = [pixel[0] - topLeftPx[0], pixel[1] - topLeftPx[1]];
+        this.drawContext(context, data, self.options, {
+            x: pixel[0],
+            y: pixel[1]
+        });
+        if (self.isEnabledTime()) {
+            this.source.changed();
+        }
+        self.options.updateCallback && self.options.updateCallback(time);
+    }
+
+
+    isEnabledTime() {
+        var animationOptions = this.options.animation;
+        return animationOptions && !(animationOptions.enabled === false);
+    }
+
+
+    argCheck(options) {
+        if (options.draw === 'heatmap') {
+            if (options.strokeStyle) {
+                console.warn('[heatmap] options.strokeStyle is discard, pleause use options.strength [eg: options.strength = 0.1]');
+            }
+        }
+    }
+
+    getContext() {
+        return this.canvasLayer.canvas.getContext(this.context);
+    }
+
+
+    clear(context) {
+        context && context.clearRect && context.clearRect(0, 0, context.canvas.width, context.canvas.height);
+    }
+}

package/overlay/mapv/index.js

@@ -0,0 +1,5 @@
+/* Copyright© 2000 - 2024 SuperMap Software Co.Ltd. All rights reserved.
+ * This program are made available under the terms of the Apache License, Version 2.0
+ * which accompanies this distribution and is available at http://www.apache.org/licenses/LICENSE-2.0.html.*/
+export {MapvCanvasLayer} from './MapvCanvasLayer';
+export {MapvLayer} from './MapvLayer';

package/overlay/theme/GeoFeature.js

@@ -0,0 +1,275 @@
+/* Copyright© 2000 - 2024 SuperMap Software Co.Ltd. All rights reserved.
+ * This program are made available under the terms of the Apache License, Version 2.0
+ * which accompanies this distribution and is available at http://www.apache.org/licenses/LICENSE-2.0.html.*/
+import { Bounds } from '@supermapgis/iclient-common/commontypes/Bounds';
+import { ShapeFactory } from '@supermapgis/iclient-common/overlay/feature/ShapeFactory';
+import { ThemeVector as Vector} from '@supermapgis/iclient-common/overlay/ThemeVector';
+import { Util as CommonUtil } from '@supermapgis/iclient-common/commontypes/Util';
+import {Theme} from './Theme';
+
+/**
+ * @class GeoFeature
+ * @browsernamespace ol.source
+ * @category Visualization Theme
+ * @classdesc 地理几何专题要素型专题图层基类。此类型专题图的专题要素形状就是由 feature.geometry 决定。不建议直接实例化调用此类。
+ * @param {string} name - 图层名称。
+ * @param {Object} opt_options - 参数。
+ * @param {ol.Map} opt_options.map - 当前 OpenLayers Map 对象。
+ * @param {string} [opt_options.id] - 专题图层 ID。默认使用 CommonUtil.createUniqueID("themeLayer_") 创建专题图层 ID。
+ * @param {number} [opt_options.opacity=1] - 图层不透明度。
+ * @param {string} [opt_options.logo] - Logo（OpenLayers 5.0.0 及更高版本不再支持此参数）。
+ * @param {ol.proj.Projection} [opt_options.projection] - 投影信息。
+ * @param {number} [opt_options.ratio=1.5] - 视图比，1 表示画布是地图视口的大小，2 表示地图视口的宽度和高度的两倍，依此类推。必须是 1 或更高。
+ * @param {Array} [opt_options.resolutions] - 分辨率数组。
+ * @param {ol.source.State} [opt_options.state] - 资源状态。
+ * @param {Object} [opt_options.style] - 专题图样式。
+ * @param {Object} [opt_options.styleGroups] - 各专题类型样式组。
+ * @param {boolean} [opt_options.isHoverAble=false] - 是否开启 hover 事件。
+ * @param {Object} [opt_options.highlightStyle] - 开启 hover 事件后，触发的样式风格。
+ * @param {(string|Object)} [opt_options.attributions='Map Data <span>© <a href='http://support.supermap.com.cn/product/iServer.aspx' target='_blank'>SuperMap iServer</a></span> with <span>© <a href='https://iclient.supermap.io' target='_blank'>SuperMap iClient</a></span>'] - 版权描述信息。
+ * @extends {Theme}
+ * @usage
+ */
+
+export class GeoFeature extends Theme {
+
+    constructor(name, opt_options) {
+        super(name, opt_options);
+        this.cache = opt_options.cache || {};
+        this.cacheFields = opt_options.cacheFields || [];
+        this.style = opt_options.style || {};
+        this.maxCacheCount = opt_options.maxCacheCount || 0;
+        this.isCustomSetMaxCacheCount = opt_options.isCustomSetMaxCacheCount === undefined ? false : opt_options.isCustomSetMaxCacheCount;
+        this.nodesClipPixel = opt_options.nodesClipPixel || 2;
+        this.isHoverAble = opt_options.isHoverAble === undefined ? false : opt_options.isHoverAble;
+        this.isMultiHover = opt_options.isMultiHover === undefined ? false : opt_options.isMultiHover;
+        this.isClickAble = opt_options.isClickAble === undefined ? true : opt_options.isClickAble;
+        this.highlightStyle = opt_options.highlightStyle || null;
+        this.isAllowFeatureStyle = opt_options.isAllowFeatureStyle === undefined ? false : opt_options.isAllowFeatureStyle;
+    }
+
+    /**
+     * @function GeoFeature.prototype.destroy
+     * @description 释放资源，将引用资源的属性置空。
+     */
+    destroy() {
+        this.maxCacheCount = null;
+        this.isCustomSetMaxCacheCount = null;
+        this.nodesClipPixel = null;
+        this.isHoverAble = null;
+        this.isMultiHover = null;
+        this.isClickAble = null;
+        this.cache = null;
+        this.cacheFields = null;
+        this.style = null;
+        this.highlightStyle = null;
+        this.isAllowFeatureStyle = null;
+    }
+
+    /**
+     * @function GeoFeature.prototype.addFeatures
+     * @description 添加要素。
+     * @param {(Array.<ThemeFeature>|Array.<GeoJSONObject>|Array.<ol.Feature>|ThemeFeature|GeoJSONObject|ol.Feature)} features - 要素对象。
+     */
+    addFeatures(features) {
+        this.dispatchEvent({type: 'beforefeaturesadded', value: {features: features}});
+        //转换 features 形式
+        this.features = this.toiClientFeature(features);
+        if (!this.isCustomSetMaxCacheCount) {
+            this.maxCacheCount = this.features.length * 5;
+        }
+        //绘制专题要素
+        if (this.renderer) {
+            this.changed();
+        }
+    }
+
+    /**
+     * @function GeoFeature.prototype.removeFeatures
+     * @description 从专题图中删除要素。这个函数删除所有传递进来的矢量要素。
+     * @param {(Array.<FeatureVector>|FeatureVector|Function)} features - 待删除的要素对象或用于过滤的回调函数。
+     */
+    removeFeatures(features) { // eslint-disable-line no-unused-vars
+        this.clearCache();
+        Theme.prototype.removeFeatures.call(this, features);
+    }
+
+    /**
+     * @function GeoFeature.prototype.removeAllFeatures
+     * @description 清除当前图层所有的矢量要素。
+     */
+    removeAllFeatures() {
+        this.clearCache();
+        Theme.prototype.removeAllFeatures.apply(this, arguments);
+    }
+
+    /**
+     * @function GeoFeature.prototype.redrawThematicFeatures
+     * @description 重绘所有专题要素。
+     * @param {Object} extent - 视图范围数据。
+     */
+    redrawThematicFeatures(extent) {
+        //获取高亮专题要素对应的用户 id
+        var hoverone = this.renderer.getHoverOne();
+        var hoverFid = null;
+        if (hoverone && hoverone.refDataID) {
+            hoverFid = hoverone.refDataID;
+        }
+        //清除当前所有可视元素
+        this.renderer.clearAll();
+
+        var features = this.features;
+        var cache = this.cache;
+        var cacheFields = this.cacheFields;
+        var cmZoom = this.map.getView().getZoom();
+
+        var maxCC = this.maxCacheCount;
+
+        for (var i = 0, len = features.length; i < len; i++) {
+            var feature = features[i];
+            if (!feature.geometry) {
+                continue;
+            }
+            var feaBounds = feature.geometry.getBounds();
+
+            //剔除当前视图（地理）范围以外的数据
+            if (extent) {
+                var bounds = new Bounds(extent[0], extent[1], extent[2], extent[3]);
+                if (!bounds.intersectsBounds(feaBounds)) {
+                    continue;
+                }
+            }
+
+            //缓存字段
+            var fields = feature.id + "_zoom_" + cmZoom.toString();
+
+            var thematicFeature;
+
+            //判断专题要素缓存是否存在
+            if (cache[fields]) {
+                cache[fields].updateAndAddShapes();
+            } else {
+                //如果专题要素缓存不存在，创建专题要素
+                thematicFeature = this.createThematicFeature(features[i]);
+
+                //检查 thematicFeature 是否有可视化图形
+                if (thematicFeature.getShapesCount() < 1) {
+                    continue;
+                }
+
+                //加入缓存
+                cache[fields] = thematicFeature;
+                cacheFields.push(fields);
+
+                //缓存数量限制
+                if (cacheFields.length > maxCC) {
+                    var fieldsTemp = cacheFields[0];
+                    cacheFields.splice(0, 1);
+                    delete cache[fieldsTemp];
+                }
+            }
+
+        }
+        this.renderer.render();
+
+        //地图漫游后，重新高亮图形
+        if (hoverFid && this.isHoverAble && this.isMultiHover) {
+            var hShapes = this.getShapesByFeatureID(hoverFid);
+            this.renderer.updateHoverShapes(hShapes);
+        }
+    }
+
+    /**
+     * @function GeoFeature.prototype.createThematicFeature
+     * @description 创建专题要素。
+     * @param {Object} feature - 要素对象。
+     * @returns {Array.<FeatureVector>} 返回矢量要素。
+     */
+    createThematicFeature(feature) {
+        var style = CommonUtil.copyAttributesWithClip(this.style);
+        if (feature.style && this.isAllowFeatureStyle === true) {
+            style = CommonUtil.copyAttributesWithClip(feature.style);
+        }
+        //创建专题要素时的可选参数
+        var options = {};
+        options.nodesClipPixel = this.nodesClipPixel;
+        options.isHoverAble = this.isHoverAble;
+        options.isMultiHover = this.isMultiHover;
+        options.isClickAble = this.isClickAble;
+        options.highlightStyle = ShapeFactory.transformStyle(this.highlightStyle);
+        //将数据转为专题要素（Vector）
+        var thematicFeature = new Vector(feature, this, ShapeFactory.transformStyle(style), options);
+        //直接添加图形到渲染器
+        for (var m = 0; m < thematicFeature.shapes.length; m++) {
+            this.renderer.addShape(thematicFeature.shapes[m]);
+        }
+        return thematicFeature;
+    }
+
+    canvasFunctionInternal_(extent, resolution, pixelRatio, size, projection) { // eslint-disable-line no-unused-vars
+        return Theme.prototype.canvasFunctionInternal_.apply(this, arguments);
+    }
+
+    /**
+     * @function GeoFeature.prototype.clearCache
+     * @description 清除缓存。
+     */
+    clearCache() {
+        this.cache = {};
+        this.cacheFields = [];
+    }
+
+    /**
+     * @function GeoFeature.prototype.clear
+     * @description  清除的内容包括数据（features）、专题要素、缓存。
+     */
+    clear() {
+        this.renderer.clearAll();
+        this.renderer.refresh();
+        this.removeAllFeatures();
+        this.clearCache();
+    }
+
+    /**
+     * @function GeoFeature.prototype.getCacheCount
+     * @description 获取当前缓存数量。
+     * @returns {number} 返回当前缓存数量。
+     */
+    getCacheCount() {
+        return this.cacheFields.length;
+    }
+
+    /**
+     * @function GeoFeature.prototype.setMaxCacheCount
+     * @param {number} cacheCount - 缓存总数。
+     * @description 设置最大缓存条数。
+     */
+    setMaxCacheCount(cacheCount) {
+        if (!isNaN(cacheCount)) {
+            this.maxCacheCount = cacheCount;
+            this.isCustomSetMaxCacheCount = true;
+        }
+    }
+
+    /**
+     * @function GeoFeature.prototype.getShapesByFeatureID
+     * @param {number} featureID - 要素 ID。
+     * @description 通过要素 ID 获取要素关联的所有图形。如果不传入此参数，函数将返回所有图形。
+     * @returns {Array} 返回图形数组。
+     */
+    getShapesByFeatureID(featureID) {
+        var list = [];
+        var shapeList = this.renderer.getAllShapes();
+        if (!featureID) {
+            return shapeList
+        }
+        for (var i = 0, len = shapeList.length; i < len; i++) {
+            var si = shapeList[i];
+            if (si.refDataID && featureID === si.refDataID) {
+                list.push(si);
+            }
+        }
+        return list;
+    }
+
+}