百度地圖點聚合MarkerClusterer，性能優化

時間 2019-12-12

原文原文鏈接

參考文獻：http://www.cnblogs.com/lightnull/p/6184867.htmlhtml

百度的點聚合算法是基於方格和距離的聚合算法，即開始的時候地圖上沒有任何已知的聚合點，而後遍歷全部的點，去計算點的外包正方形（由gridSize指定），若此點的外包正方形與現有的聚合點的外包正方形不相交，則新建聚合點，若相交就把該點加到該聚合點，效果以下圖，爲了便於查看，咱們特意把外包正方形畫了出來。算法

好的，筆者開始了做死之旅。上面筆者只是生成了50個隨機點。數組

接下來要測試下1000個點，嗯有點小卡，可是還能操做，dom

2000個點，個人天，這shit同樣的卡頓是什麼鬼！！ide

5000個點，好的，完美，動也動不了簡直漂亮性能

10000個點，頁面無響應。。。。。。。測試

----------我只是一條漂亮的分割線----------優化

百度地圖點聚合的部分源碼：this

/**
     * 根據所給定的標記，建立聚合點
     * @return 無返回值
     */
    MarkerClusterer.prototype._createClusters = function(){
        var mapBounds = this._map.getBounds();
        var extendedBounds = getExtendedBounds(this._map, mapBounds, this._gridSize);
        for(var i = 0, marker; marker = this._markers[i]; i++){
            if(!marker.isInCluster && extendedBounds.containsPoint(marker.getPosition()) ){ 
                this._addToClosestCluster(marker);
            }
        }   
    };

    /**
     * 根據標記的位置，把它添加到最近的聚合中
     * @param {BMap.Marker} marker 要進行聚合的單個標記
     *
     * @return 無返回值。
     */
    MarkerClusterer.prototype._addToClosestCluster = function (marker){
        var distance = 4000000;
        var clusterToAddTo = null;
        var position = marker.getPosition();
        for(var i = 0, cluster; cluster = this._clusters[i]; i++){
            var center = cluster.getCenter();
            if(center){
                var d = this._map.getDistance(center, marker.getPosition());
                if(d < distance){
                    distance = d;
                    clusterToAddTo = cluster;
                }
            }
        }
    
        if (clusterToAddTo && clusterToAddTo.isMarkerInClusterBounds(marker)){
            clusterToAddTo.addMarker(marker);
        } else {
            var cluster = new Cluster(this);
            cluster.addMarker(marker);            
            this._clusters.push(cluster);
        }    
    };

以上兩個方法就是前文所述的算法的具體實現，spa

先排除全部不在可視範圍的點，而後經過比較marker點和聚合點的距離，拿到距離最近的聚合點，判斷marker點是否在聚合點的外包正方形內；

這一段是正常算法須要沒啥問題，看起來問題只能出在 cluster.addMarker(marker); 了

if(this.isMarkerInCluster(marker)){
            return false;
        }//也可用marker.isInCluster判斷,外面判斷OK，這裏基本不會命中
    
        if (!this._center){
            this._center = marker.getPosition();
            this.updateGridBounds();//
        } else {
            if(this._isAverageCenter){
                var l = this._markers.length + 1;
                var lat = (this._center.lat * (l - 1) + marker.getPosition().lat) / l;
                var lng = (this._center.lng * (l - 1) + marker.getPosition().lng) / l;
                this._center = new BMap.Point(lng, lat);
                this.updateGridBounds();
            }//計算新的Center
        }
    
        marker.isInCluster = true;
        this._markers.push(marker);
    
        var len = this._markers.length; if(len < this._minClusterSize ){ this._map.addOverlay(marker); //this.updateClusterMarker();
            return true; } else if (len === this._minClusterSize) { for (var i = 0; i < len; i++) { this._markers[i].getMap() && this._map.removeOverlay(this._markers[i]); } } this._map.addOverlay(this._clusterMarker); this._isReal = true; this.updateClusterMarker(); return true;
    };

果真不出所料，在addMarker() 方法內不停的去進行dom操做，不卡纔怪。爲何度娘就不等計算結束後，在去一次操做完呢，

因而筆者把標黃的代碼抽離了出來給cluster類加了一個render方法，而後在MarkerClusterer.createClusters方法最後加了一個遍歷全部聚合點的操做，代碼以下：

Cluster.prototype.render = function(){
    var len = this._markers.length;
         
    if (len < this._minClusterSize) {
            for (var i = 0; i < len; i++) {
                this._map.addOverlay(this._markers[i]);
            }
    } else {
            this._map.addOverlay(this._clusterMarker);
            this._isReal = true;
            this.updateClusterMarker();
    }
}

var len = this._markers.length;
for (var i = 0; i < len; i++) {
    if(this._clusters[i]){
        this._clusters[i].render();
    }
}

測試比較一下吧！

Maker數量	原版點聚合js（時間：毫秒 ms）		優化後點聚合js（時間：毫秒 ms）
100	95	88	60	65
1000	588	612	146	133
10000	5840	5772	439	424
30000	19987	20170	1334	1457

新手上路！！

貼上修改後的代碼：

  1 /**
  2  * @fileoverview MarkerClusterer標記聚合器用來解決加載大量點要素到地圖上產生覆蓋現象的問題，並提升性能。
  3  * 主入口類是<a href="symbols/BMapLib.MarkerClusterer.html">MarkerClusterer</a>，
  4  * 基於Baidu Map API 1.2。
  5  *
  6  * @author Baidu Map Api Group 
  7  * @version 1.2
  8  */
  9   
 10  
 11 /** 
 12  * @namespace BMap的全部library類均放在BMapLib命名空間下
 13  */
 14 var BMapLib = window.BMapLib = BMapLib || {};
 15 (function(){
 16      
 17     /**
 18      * 獲取一個擴展的視圖範圍，把上下左右都擴大同樣的像素值。
 19      * @param {Map} map BMap.Map的實例化對象
 20      * @param {BMap.Bounds} bounds BMap.Bounds的實例化對象
 21      * @param {Number} gridSize 要擴大的像素值
 22      *
 23      * @return {BMap.Bounds} 返回擴大後的視圖範圍。
 24      */
 25     var getExtendedBounds = function(map, bounds, gridSize){
 26         bounds = cutBoundsInRange(bounds);
 27         var pixelNE = map.pointToPixel(bounds.getNorthEast());
 28         var pixelSW = map.pointToPixel(bounds.getSouthWest()); 
 29         pixelNE.x += gridSize;
 30         pixelNE.y -= gridSize;
 31         pixelSW.x -= gridSize;
 32         pixelSW.y += gridSize;
 33         var newNE = map.pixelToPoint(pixelNE);
 34         var newSW = map.pixelToPoint(pixelSW);
 35         return new BMap.Bounds(newSW, newNE);
 36     };
 37  
 38     /**
 39      * 按照百度地圖支持的世界範圍對bounds進行邊界處理
 40      * @param {BMap.Bounds} bounds BMap.Bounds的實例化對象
 41      *
 42      * @return {BMap.Bounds} 返回不越界的視圖範圍
 43      */
 44     var cutBoundsInRange = function (bounds) {
 45         var maxX = getRange(bounds.getNorthEast().lng, -180, 180);
 46         var minX = getRange(bounds.getSouthWest().lng, -180, 180);
 47         var maxY = getRange(bounds.getNorthEast().lat, -74, 74);
 48         var minY = getRange(bounds.getSouthWest().lat, -74, 74);
 49         return new BMap.Bounds(new BMap.Point(minX, minY), new BMap.Point(maxX, maxY));
 50     }; 
 51  
 52     /**
 53      * 對單個值進行邊界處理。
 54      * @param {Number} i 要處理的數值
 55      * @param {Number} min 下邊界值
 56      * @param {Number} max 上邊界值
 57      * 
 58      * @return {Number} 返回不越界的數值
 59      */
 60     var getRange = function (i, mix, max) {
 61         mix && (i = Math.max(i, mix));
 62         max && (i = Math.min(i, max));
 63         return i;
 64     };
 65  
 66     /**
 67      * 判斷給定的對象是否爲數組
 68      * @param {Object} source 要測試的對象
 69      *
 70      * @return {Boolean} 若是是數組返回true，不然返回false
 71      */
 72     var isArray = function (source) {
 73         return '[object Array]' === Object.prototype.toString.call(source);
 74     };
 75  
 76     /**
 77      * 返回item在source中的索引位置
 78      * @param {Object} item 要測試的對象
 79      * @param {Array} source 數組
 80      *
 81      * @return {Number} 若是在數組內，返回索引，不然返回-1
 82      */
 83     var indexOf = function(item, source){
 84         var index = -1;
 85         if(isArray(source)){
 86             if (source.indexOf) {
 87                 index = source.indexOf(item);
 88             } else {
 89                 for (var i = 0, m; m = source[i]; i++) {
 90                     if (m === item) {
 91                         index = i;
 92                         break;
 93                     }
 94                 }
 95             }
 96         }        
 97         return index;
 98     };
 99  
100     /**
101      *@exports MarkerClusterer as BMapLib.MarkerClusterer
102      */
103     var MarkerClusterer =  
104         /**
105          * MarkerClusterer
106          * @class 用來解決加載大量點要素到地圖上產生覆蓋現象的問題，並提升性能
107          * @constructor
108          * @param {Map} map 地圖的一個實例。
109          * @param {Json Object} options 可選參數，可選項包括：<br />
110          *    markers {Array<Marker>} 要聚合的標記數組<br />
111          *    girdSize {Number} 聚合計算時網格的像素大小，默認60<br />
112          *    maxZoom {Number} 最大的聚合級別，大於該級別就不進行相應的聚合<br />
113          *    minClusterSize {Number} 最小的聚合數量，小於該數量的不能成爲一個聚合，默認爲2<br />
114          *    isAverangeCenter {Boolean} 聚合點的落腳位置是不是全部聚合在內點的平均值，默認爲否，落腳在聚合內的第一個點<br />
115          *    styles {Array<IconStyle>} 自定義聚合後的圖標風格，請參考TextIconOverlay類<br />
116          */
117         BMapLib.MarkerClusterer = function(map, options){
118             if (!map){
119                 return;
120             }
121             this._map = map;
122             this._markers = [];
123             this._clusters = [];
124              
125             var opts = options || {};
126             this._gridSize = opts["gridSize"] || 60;
127             this._maxZoom = opts["maxZoom"] || 18;
128             this._minClusterSize = opts["minClusterSize"] || 2;           
129             this._isAverageCenter = false;
130             if (opts['isAverageCenter'] != undefined) {
131                 this._isAverageCenter = opts['isAverageCenter'];
132             }    
133             this._styles = opts["styles"] || [];
134          
135             var that = this;
136             this._map.addEventListener("zoomend",function(){
137                 that._redraw();     
138             });
139      
140             this._map.addEventListener("moveend",function(){
141                  that._redraw();     
142             });
143  
144             var mkrs = opts["markers"];
145             isArray(mkrs) && this.addMarkers(mkrs);
146         };
147  
148     /**
149      * 添加要聚合的標記數組。
150      * @param {Array<Marker>} markers 要聚合的標記數組
151      *
152      * @return 無返回值。
153      */
154     MarkerClusterer.prototype.addMarkers = function(markers){
155         for(var i = 0, len = markers.length; i <len ; i++){
156             this._pushMarkerTo(markers[i]);
157         }
158         this._createClusters();   
159     };
160  
161     /**
162      * 把一個標記添加到要聚合的標記數組中
163      * @param {BMap.Marker} marker 要添加的標記
164      *
165      * @return 無返回值。
166      */
167     MarkerClusterer.prototype._pushMarkerTo = function(marker){
168         var index = indexOf(marker, this._markers);
169         if(index === -1){
170             marker.isInCluster = false;
171             this._markers.push(marker);//Marker拖放後enableDragging不作變化，忽略
172         }
173     };
174  
175     /**
176      * 添加一個聚合的標記。
177      * @param {BMap.Marker} marker 要聚合的單個標記。
178      * @return 無返回值。
179      */
180     MarkerClusterer.prototype.addMarker = function(marker) {
181         this._pushMarkerTo(marker);
182         this._createClusters();
183     };
184  
185     /**
186      * 根據所給定的標記，建立聚合點，而且遍歷全部聚合點
187      * @return 無返回值
188      */
189     MarkerClusterer.prototype._createClusters = function(){
190         var mapBounds = this._map.getBounds();
191         var extendedBounds = getExtendedBounds(this._map, mapBounds, this._gridSize);
192         for(var i = 0, marker; marker = this._markers[i]; i++){
193             if(!marker.isInCluster && extendedBounds.containsPoint(marker.getPosition()) ){ 
194                 this._addToClosestCluster(marker);                
195             }
196         }
197 
198         var len = this._markers.length;
199         for (var i = 0; i < len; i++) {
200             if(this._clusters[i]){
201                 this._clusters[i].render();
202             }
203         }
204     };
205  
206     /**
207      * 根據標記的位置，把它添加到最近的聚合中
208      * @param {BMap.Marker} marker 要進行聚合的單個標記
209      *
210      * @return 無返回值。
211      */
212     MarkerClusterer.prototype._addToClosestCluster = function (marker){
213         var distance = 4000000;
214         var clusterToAddTo = null;
215         var position = marker.getPosition();
216         for(var i = 0, cluster; cluster = this._clusters[i]; i++){
217             var center = cluster.getCenter();
218             if(center){
219                 var d = this._map.getDistance(center, marker.getPosition());
220                 if(d < distance){
221                     distance = d;
222                     clusterToAddTo = cluster;
223                 }
224             }
225         }
226      
227         if (clusterToAddTo && clusterToAddTo.isMarkerInClusterBounds(marker)){
228             clusterToAddTo.addMarker(marker);
229         } else {
230             var cluster = new Cluster(this);
231             cluster.addMarker(marker);            
232             this._clusters.push(cluster);
233         }    
234     };
235  
236     /**
237      * 清除上一次的聚合的結果
238      * @return 無返回值。
239      */
240     MarkerClusterer.prototype._clearLastClusters = function(){
241         for(var i = 0, cluster; cluster = this._clusters[i]; i++){            
242             cluster.remove();
243         }
244         this._clusters = [];//置空Cluster數組
245         this._removeMarkersFromCluster();//把Marker的cluster標記設爲false
246     };
247  
248     /**
249      * 清除某個聚合中的全部標記
250      * @return 無返回值
251      */
252     MarkerClusterer.prototype._removeMarkersFromCluster = function(){
253         for(var i = 0, marker; marker = this._markers[i]; i++){
254             marker.isInCluster = false;
255         }
256     };
257     
258     /**
259      * 把全部的標記從地圖上清除
260      * @return 無返回值
261      */
262     MarkerClusterer.prototype._removeMarkersFromMap = function(){
263         for(var i = 0, marker; marker = this._markers[i]; i++){
264             marker.isInCluster = false;
265             tmplabel = marker.getLabel();
266             this._map.removeOverlay(marker);       
267             marker.setLabel(tmplabel);
268         }
269     };
270  
271     /**
272      * 刪除單個標記
273      * @param {BMap.Marker} marker 須要被刪除的marker
274      *
275      * @return {Boolean} 刪除成功返回true，不然返回false
276      */
277     MarkerClusterer.prototype._removeMarker = function(marker) {
278         var index = indexOf(marker, this._markers);
279         if (index === -1) {
280             return false;
281         }
282         tmplabel = marker.getLabel();
283         this._map.removeOverlay(marker);
284         marker.setLabel(tmplabel);
285         this._markers.splice(index, 1);
286         return true;
287     };
288  
289     /**
290      * 刪除單個標記
291      * @param {BMap.Marker} marker 須要被刪除的marker
292      *
293      * @return {Boolean} 刪除成功返回true，不然返回false
294      */
295     MarkerClusterer.prototype.removeMarker = function(marker) {
296         var success = this._removeMarker(marker);
297         if (success) {
298             this._clearLastClusters();
299             this._createClusters();
300         }
301         return success;
302     };
303      
304     /**
305      * 刪除一組標記
306      * @param {Array<BMap.Marker>} markers 須要被刪除的marker數組
307      *
308      * @return {Boolean} 刪除成功返回true，不然返回false
309      */
310     MarkerClusterer.prototype.removeMarkers = function(markers) {
311         var success = false;
312         for (var i = 0; i < markers.length; i++) {
313             var r = this._removeMarker(markers[i]);
314             success = success || r; 
315         }
316  
317         if (success) {
318             this._clearLastClusters();
319             this._createClusters();
320         }
321         return success;
322     };
323  
324     /**
325      * 從地圖上完全清除全部的標記
326      * @return 無返回值
327      */
328     MarkerClusterer.prototype.clearMarkers = function() {
329         this._clearLastClusters();
330         this._removeMarkersFromMap();
331         this._markers = [];
332     };
333  
334     /**
335      * 從新生成，好比改變了屬性等
336      * @return 無返回值
337      */
338     MarkerClusterer.prototype._redraw = function () {
339         this._clearLastClusters();
340         this._createClusters();
341     };
342  
343     /**
344      * 獲取網格大小
345      * @return {Number} 網格大小
346      */
347     MarkerClusterer.prototype.getGridSize = function() {
348         return this._gridSize;
349     };
350  
351     /**
352      * 設置網格大小
353      * @param {Number} size 網格大小
354      * @return 無返回值
355      */
356     MarkerClusterer.prototype.setGridSize = function(size) {
357         this._gridSize = size;
358         this._redraw();
359     };
360  
361     /**
362      * 獲取聚合的最大縮放級別。
363      * @return {Number} 聚合的最大縮放級別。
364      */
365     MarkerClusterer.prototype.getMaxZoom = function() {
366         return this._maxZoom;       
367     };
368  
369     /**
370      * 設置聚合的最大縮放級別
371      * @param {Number} maxZoom 聚合的最大縮放級別
372      * @return 無返回值
373      */
374     MarkerClusterer.prototype.setMaxZoom = function(maxZoom) {
375         this._maxZoom = maxZoom;
376         this._redraw();
377     };
378  
379     /**
380      * 獲取聚合的樣式風格集合
381      * @return {Array<IconStyle>} 聚合的樣式風格集合
382      */
383     MarkerClusterer.prototype.getStyles = function() {
384         return this._styles;
385     };
386  
387     /**
388      * 設置聚合的樣式風格集合
389      * @param {Array<IconStyle>} styles 樣式風格數組
390      * @return 無返回值
391      */
392     MarkerClusterer.prototype.setStyles = function(styles) {
393         this._styles = styles;
394         this._redraw();
395     };
396  
397     /**
398      * 獲取單個聚合的最小數量。
399      * @return {Number} 單個聚合的最小數量。
400      */
401     MarkerClusterer.prototype.getMinClusterSize = function() {
402         return this._minClusterSize;
403     };
404  
405     /**
406      * 設置單個聚合的最小數量。
407      * @param {Number} size 單個聚合的最小數量。
408      * @return 無返回值。
409      */
410     MarkerClusterer.prototype.setMinClusterSize = function(size) {
411         this._minClusterSize = size;
412         this._redraw();
413     };
414  
415     /**
416      * 獲取單個聚合的落腳點是不是聚合內全部標記的平均中心。
417      * @return {Boolean} true或false。
418      */
419     MarkerClusterer.prototype.isAverageCenter = function() {
420         return this._isAverageCenter;
421     };
422  
423     /**
424      * 獲取聚合的Map實例。
425      * @return {Map} Map的示例。
426      */
427     MarkerClusterer.prototype.getMap = function() {
428       return this._map;
429     };
430  
431     /**
432      * 獲取全部的標記數組。
433      * @return {Array<Marker>} 標記數組。
434      */
435     MarkerClusterer.prototype.getMarkers = function() {
436         return this._markers;
437     };
438  
439     /**
440      * 獲取聚合的總數量。
441      * @return {Number} 聚合的總數量。
442      */
443     MarkerClusterer.prototype.getClustersCount = function() {
444         var count = 0;
445         for(var i = 0, cluster; cluster = this._clusters[i]; i++){
446             cluster.isReal() && count++;     
447         }
448         return count;
449     };
450  
451     /**
452      * @ignore
453      * Cluster
454      * @class 表示一個聚合對象，該聚合，包含有N個標記，這N個標記組成的範圍，並有予以顯示在Map上的TextIconOverlay等。
455      * @constructor
456      * @param {MarkerClusterer} markerClusterer 一個標記聚合器示例。
457      */
458     function Cluster(markerClusterer){
459         this._markerClusterer = markerClusterer;
460         this._map = markerClusterer.getMap();
461         this._minClusterSize = markerClusterer.getMinClusterSize();
462         this._isAverageCenter = markerClusterer.isAverageCenter();
463         this._center = null;//落腳位置
464         this._markers = [];//這個Cluster中所包含的markers
465         this._gridBounds = null;//以中心點爲準，向四邊擴大gridSize個像素的範圍，也即網格範圍
466         this._isReal = false; //真的是個聚合
467      
468         this._clusterMarker = new BMapLib.TextIconOverlay(this._center, this._markers.length, {"styles":this._markerClusterer.getStyles()});
469         //this._map.addOverlay(this._clusterMarker);
470     }
471     
472     /**
473      * 向該聚合添加一個標記。
474      * @param {Marker} marker 要添加的標記。
475      * @return 無返回值。
476      */
477     Cluster.prototype.addMarker = function(marker){
478         if(this.isMarkerInCluster(marker)){
479             return false;
480         }//也可用marker.isInCluster判斷,外面判斷OK，這裏基本不會命中
481      
482         if (!this._center){
483             this._center = marker.getPosition();
484             this.updateGridBounds();//
485         } else {
486             if(this._isAverageCenter){
487                 var l = this._markers.length + 1;
488                 var lat = (this._center.lat * (l - 1) + marker.getPosition().lat) / l;
489                 var lng = (this._center.lng * (l - 1) + marker.getPosition().lng) / l;
490                 this._center = new BMap.Point(lng, lat);
491                 this.updateGridBounds();
492             }//計算新的Center
493         }
494      
495         marker.isInCluster = true;
496         this._markers.push(marker);
497     };
498     
499     /**
500      * 進行dom操做
501      * @return 無返回值
502      */
503     Cluster.prototype.render = function(){
504         var len = this._markers.length;
505          
506         if (len < this._minClusterSize) {
507             for (var i = 0; i < len; i++) {
508                 this._map.addOverlay(this._markers[i]);
509             }
510         } else {
511             this._map.addOverlay(this._clusterMarker);
512             this._isReal = true;
513             this.updateClusterMarker();
514         }
515     }
516 
517     /**
518      * 判斷一個標記是否在該聚合中。
519      * @param {Marker} marker 要判斷的標記。
520      * @return {Boolean} true或false。
521      */
522     Cluster.prototype.isMarkerInCluster= function(marker){
523         if (this._markers.indexOf) {
524             return this._markers.indexOf(marker) != -1;
525         } else {
526             for (var i = 0, m; m = this._markers[i]; i++) {
527                 if (m === marker) {
528                     return true;
529                 }
530             }
531         }
532         return false;
533     };
534  
535     /**
536      * 判斷一個標記是否在該聚合網格範圍中。
537      * @param {Marker} marker 要判斷的標記。
538      * @return {Boolean} true或false。
539      */
540     Cluster.prototype.isMarkerInClusterBounds = function(marker) {
541         return this._gridBounds.containsPoint(marker.getPosition());
542     };
543      
544     Cluster.prototype.isReal = function(marker) {
545         return this._isReal;
546     };
547  
548     /**
549      * 更新該聚合的網格範圍。
550      * @return 無返回值。
551      */
552     Cluster.prototype.updateGridBounds = function() {
553         var bounds = new BMap.Bounds(this._center, this._center);
554         this._gridBounds = getExtendedBounds(this._map, bounds, this._markerClusterer.getGridSize());
555     };
556  
557     /**
558      * 更新該聚合的顯示樣式，也即TextIconOverlay。
559      * @return 無返回值。
560      */
561     Cluster.prototype.updateClusterMarker = function () {
562         if (this._map.getZoom() > this._markerClusterer.getMaxZoom()) {
563             this._clusterMarker && this._map.removeOverlay(this._clusterMarker);
564             for (var i = 0, marker; marker = this._markers[i]; i++) {
565                 this._map.addOverlay(marker);
566             }
567             return;
568         }
569  
570         if (this._markers.length < this._minClusterSize) {
571             this._clusterMarker.hide();
572             return;
573         }
574  
575         this._clusterMarker.setPosition(this._center);
576          
577         this._clusterMarker.setText(this._markers.length);
578  
579         var thatMap = this._map;
580         var thatBounds = this.getBounds();
581         this._clusterMarker.addEventListener("click", function(event){
582             thatMap.setViewport(thatBounds);
583         });
584  
585     };
586  
587     /**
588      * 刪除該聚合。
589      * @return 無返回值。
590      */
591     Cluster.prototype.remove = function(){
592         for (var i = 0, m; m = this._markers[i]; i++) {
593             tmplabel = this._markers[i].getLabel(); 
594             this._markers[i].getMap() && this._map.removeOverlay(this._markers[i])
595             this._markers[i].setLabel(tmplabel)
596         }//清除散的標記點
597         this._map.removeOverlay(this._clusterMarker);
598         this._markers.length = 0;
599         delete this._markers;
600     }
601  
602     /**
603      * 獲取該聚合所包含的全部標記的最小外接矩形的範圍。
604      * @return {BMap.Bounds} 計算出的範圍。
605      */
606     Cluster.prototype.getBounds = function() {
607         var bounds = new BMap.Bounds(this._center,this._center);
608         for (var i = 0, marker; marker = this._markers[i]; i++) {
609             bounds.extend(marker.getPosition());
610         }
611         return bounds;
612     };
613  
614     /**
615      * 獲取該聚合的落腳點。
616      * @return {BMap.Point} 該聚合的落腳點。
617      */
618     Cluster.prototype.getCenter = function() {
619         return this._center;
620     };
621  
622 })();