解决百度地图多点聚合卡顿问题
由于百度地图提供的MarkerClusterer_min.js ⽐较卡顿
特此提供加速后的MarkerClusterer_min.js
点击链接即可到百度⽹盘下载
源码如下：
/**
* @fileoverview MarkerClusterer标记聚合器⽤来解决加载⼤量点要素到地图上产⽣覆盖现象的问题，并提⾼性能。 * 主⼊⼝类是<a href="symbols/BMapLib.MarkerClusterer.html">MarkerClusterer</a>，
* 基于Baidu Map API 1.2。
*
* @author Baidu Map Api Group
* @version 1.2
*/
/**
* @namespace BMap的所有library类均放在BMapLib命名空间下
*/
var BMapLib = window.BMapLib = BMapLib || {};
(function(){
/**
* 获取⼀个扩展的视图范围，把上下左右都扩⼤⼀样的像素值。
* @param {Map} map BMap.Map的实例化对象
* @param {BMap.Bounds} bounds BMap.Bounds的实例化对象
* @param {Number} gridSize 要扩⼤的像素值
*
* @return {BMap.Bounds} 返回扩⼤后的视图范围。
*/
var getExtendedBounds = function(map, bounds, gridSize){
bounds = cutBoundsInRange(bounds);
var pixelNE = map.NorthEast());
var pixelSW = map.SouthWest());
pixelNE.x += gridSize;
pixelNE.y -= gridSize;
pixelSW.x -= gridSize;
pixelSW.y += gridSize;
var newNE = map.pixelToPoint(pixelNE);
var newSW = map.pixelToPoint(pixelSW);
return new BMap.Bounds(newSW, newNE);
};
/**
* 按照百度地图⽀持的世界范围对bounds进⾏边界处理
* @param {BMap.Bounds} bounds BMap.Bounds的实例化对象canus
*
* @return {BMap.Bounds} 返回不越界的视图范围
无锡会计培训
*/
var cutBoundsInRange = function (bounds) {
var maxX = NorthEast().lng, -180, 180);
var minX = SouthWest().lng, -180, 180);
var maxY = NorthEast().lat, -74, 74);
var minY = SouthWest().lat, -74, 74);
return new BMap.Bounds(new BMap.Point(minX, minY), new BMap.Point(maxX, maxY));
};
/**
* 对单个值进⾏边界处理。
* @param {Number} i 要处理的数值
* @param {Number} min 下边界值
* @param {Number} max 上边界值
*
* @return {Number} 返回不越界的数值
*/
var getRange = function (i, mix, max) {
mix && (i = Math.max(i, mix));
max && (i = Math.min(i, max));
return i;
};
/**
* 判断给定的对象是否为数组
* @param {Object} source 要测试的对象
*
* @return {Boolean} 如果是数组返回true，否则返回fal
*/
var isArray = function (source) {
return '[object Array]' === String.call(source);
};
/**
* 返回item在source中的索引位置
* @param {Object} item 要测试的对象
* @param {Array} source 数组
*
* @return {Number} 如果在数组内，返回索引，否则返回-1
*/
var indexOf = function(item, source){
var index = -1;
if(isArray(source)){
if (source.indexOf) {
index = source.indexOf(item);
} el {
for (var i = 0, m; m = source[i]; i++) {游戏开发培训
词根记忆法if (m === item) {
index = i;
break;
}
}
}
}
return index;
};
/**
*@exports MarkerClusterer as BMapLib.MarkerClusterer
*/
var MarkerClusterer =
/
**
* MarkerClusterer
* @class ⽤来解决加载⼤量点要素到地图上产⽣覆盖现象的问题，并提⾼性能
* @constructor
* @param {Map} map 地图的⼀个实例。
* @param {Json Object} options 可选参数，可选项包括：<br />
* markers {Array<Marker>} 要聚合的标记数组<br />
* girdSize {Number} 聚合计算时⽹格的像素⼤⼩，默认60<br />
* maxZoom {Number} 最⼤的聚合级别，⼤于该级别就不进⾏相应的聚合<br />
* minClusterSize {Number} 最⼩的聚合数量，⼩于该数量的不能成为⼀个聚合，默认为2<br />
* isAverangeCenter {Boolean} 聚合点的落脚位置是否是所有聚合在内点的平均值，默认为否，落脚
在聚合内的第⼀个点<br /> * styles {Array<IconStyle>} ⾃定义聚合后的图标风格，请参考TextIconOverlay类<br />
*/
BMapLib.MarkerClusterer = function(map, options){
if (!map){
炫耀英语return;
2013四级考试时间
this._map = map;
this._markers = [];
this._clusters = [];
var opts = options || {};
this._gridSize = opts["gridSize"] || 60;
this._maxZoom = opts["maxZoom"] || 18;
this._minClusterSize = opts["minClusterSize"] || 2;
this._isAverageCenter = fal;
if (opts['isAverageCenter'] != undefined) {
三分钟演讲
this._isAverageCenter = opts['isAverageCenter'];
}
this._styles = opts["styles"] || [];
var that = this;
this._map.addEventListener("zoomend",function(){
that._redraw();
});
this._map.addEventListener("moveend",function(){
that._redraw();
});
var mkrs = opts["markers"];
isArray(mkrs) && this.addMarkers(mkrs);
};
/**
* 添加要聚合的标记数组。
* @param {Array<Marker>} markers 要聚合的标记数组
*
* @return ⽆返回值。
*/
MarkerClusterer.prototype.addMarkers = function(markers){
for(var i = 0, len = markers.length; i <len ; i++){
this._pushMarkerTo(markers[i]);
}
this._createClusters();
};
/**
* 把⼀个标记添加到要聚合的标记数组中
* @param {BMap.Marker} marker 要添加的标记
*
* @return ⽆返回值。
*/
MarkerClusterer.prototype._pushMarkerTo = function(marker){
var index = indexOf(marker, this._markers);
if(index === -1){
marker.isInCluster = fal;
this._markers.push(marker);//Marker拖放后enableDragging不做变化，忽略 }
};
/**
* 添加⼀个聚合的标记。
* @param {BMap.Marker} marker 要聚合的单个标记。
* @return ⽆返回值。
*/
MarkerClusterer.prototype.addMarker = function(marker) {
this._pushMarkerTo(marker);
this._createClusters();
};
* 根据所给定的标记，创建聚合点，并遍历所有聚合点
* @return ⽆返回值
*/
MarkerClusterer.prototype._createClusters = function(){
var mapBounds = this._Bounds();
var extendedBounds = getExtendedBounds(this._map, mapBounds, this._gridSize); for(var i = 0, marker; marker = this._markers[i]; i++){
if(!marker.isInCluster && Position()) ){ this._addToClostCluster(marker);
}
}
var len = this._markers.length;
for (var i = 0; i < len; i++) {
if(this._clusters[i]){
this._clusters[i].render();
}
}
};
/**
* 根据标记的位置，把它添加到最近的聚合中
* @param {BMap.Marker} marker 要进⾏聚合的单个标记
*
* @return ⽆返回值。
*/
MarkerClusterer.prototype._addToClostCluster = function (marker){
var distance = 4000000;
var clusterToAddTo = null;
var position = Position();
for(var i = 0, cluster; cluster = this._clusters[i]; i++){
var center = Center();
if(center){
var d = this._Distance(center, Position());
if(d < distance){
distance = d;
共贯同条clusterToAddTo = cluster;
}
}
}
if (clusterToAddTo && clusterToAddTo.isMarkerInClusterBounds(marker)){
clusterToAddTo.addMarker(marker);
} el {
shallow sleep
var cluster = new Cluster(this);
cluster.addMarker(marker);
this._clusters.push(cluster);
}
};
/**
* 清除上⼀次的聚合的结果
* @return ⽆返回值。
*/
MarkerClusterer.prototype._clearLastClusters = function(){
for(var i = 0, cluster; cluster = this._clusters[i]; i++){
}
this._clusters = [];//置空Cluster数组
this._removeMarkersFromCluster();//把Marker的cluster标记设为fal
};
/**
* 清除某个聚合中的所有标记
* @return ⽆返回值
*/
MarkerClusterer.prototype._removeMarkersFromCluster = function(){ for(var i = 0, marker; marker = this._markers[i]; i++){
marker.isInCluster = fal;
}
};
/**
* 把所有的标记从地图上清除
* @return ⽆返回值
*/
MarkerClusterer.prototype._removeMarkersFromMap = function(){ for(var i = 0, marker; marker = this._markers[i]; i++){
marker.isInCluster = fal;
this._veOverlay(marker);
}
};
/**
* 删除单个标记
* @param {BMap.Marker} marker 需要被删除的marker
*
* @return {Boolean} 删除成功返回true，否则返回fal
*/
MarkerClusterer.prototype._removeMarker = function(marker) {
var index = indexOf(marker, this._markers);
if (index === -1) {
return fal;
}
this._veOverlay(marker);
this._markers.splice(index, 1);
return true;
};
/**
* 删除单个标记
* @param {BMap.Marker} marker 需要被删除的marker
*
英语文章翻译* @return {Boolean} 删除成功返回true，否则返回fal
*/
veMarker = function(marker) {
var success = this._removeMarker(marker);
if (success) {
this._clearLastClusters();
this._createClusters();
}
return success;
};
/**
* 删除⼀组标记
* @param {Array<BMap.Marker>} markers 需要被删除的marker数组 *
* @return {Boolean} 删除成功返回true，否则返回fal
*/
veMarkers = function(markers) {
var success = fal;
for (var i = 0; i < markers.length; i++) {
var r = this._removeMarker(markers[i]);
success = success || r;
}
if (success) {
this._clearLastClusters();
