/**
* @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.pointToPixel(bounds.getNorthEast())
var pixelSW = map.pointToPixel(bounds.getSouthWest())
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的实例化对象
*
* @return {BMap.Bounds} 返回不越界的视图范围
*/
var cutBoundsInRange = function(bounds) {
var maxX = getRange(bounds.getNorthEast().lng, -180, 180)
var minX = getRange(bounds.getSouthWest().lng, -180, 180)
var maxY = getRange(bounds.getNorthEast().lat, -74, 74)
var minY = getRange(bounds.getSouthWest().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，否则返回false
*/
var isArray = function(source) {
return ‘[object Array]‘ === Object.prototype.toString.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)
} else {
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
}
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 = false
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 = false
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._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)
}
}
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._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)
}
}
/**
* 清除上一次的聚合的结果
* @return 无返回值。
*/
MarkerClusterer.prototype._clearLastClusters = function() {
for (var i = 0, cluster; (cluster = this._clusters[i]); i++) {
cluster.remove()
}
this._clusters = [] //置空Cluster数组
this._removeMarkersFromCluster() //把Marker的cluster标记设为false
}
/**
* 清除某个聚合中的所有标记
* @return 无返回值
*/
MarkerClusterer.prototype._removeMarkersFromCluster = function() {
for (var i = 0, marker; (marker = this._markers[i]); i++) {
marker.isInCluster = false
}
}
/**
* 把所有的标记从地图上清除
* @return 无返回值
*/
MarkerClusterer.prototype._removeMarkersFromMap = function() {
for (var i = 0, marker; (marker = this._markers[i]); i++) {
marker.isInCluster = false
tmplabel = marker.getLabel()
this._map.removeOverlay(marker)
marker.setLabel(tmplabel)
}
}
/**
* 删除单个标记
* @param {BMap.Marker} marker 需要被删除的marker
*
* @return {Boolean} 删除成功返回true，否则返回false
*/
MarkerClusterer.prototype._removeMarker = function(marker) {
var index = indexOf(marker, this._markers)
if (index === -1) {
return false
}
tmplabel = marker.getLabel()
this._map.removeOverlay(marker)
marker.setLabel(tmplabel)
this._markers.splice(index, 1)
return true
}
/**
* 删除单个标记
* @param {BMap.Marker} marker 需要被删除的marker
*
* @return {Boolean} 删除成功返回true，否则返回false
*/
MarkerClusterer.prototype.removeMarker = function(marker) {
var success = this._removeMarker(marker)
if (success) {
this._clearLastClusters()
this._createClusters()
}
return success
}
/**
* 删除一组标记
* @param {Array<BMap.Marker>} markers 需要被删除的marker数组
*
* @return {Boolean} 删除成功返回true，否则返回false
*/
MarkerClusterer.prototype.removeMarkers = function(markers) {
var success = false
for (var i = 0; i < markers.length; i++) {
var r = this._removeMarker(markers[i])
success = success || r
}
if (success) {
this._clearLastClusters()
this._createClusters()
}
return success
}
/**
* 从地图上彻底清除所有的标记
* @return 无返回值
*/
MarkerClusterer.prototype.clearMarkers = function() {
this._clearLastClusters()
this._removeMarkersFromMap()
this._markers = []
}
/**
* 重新生成，比如改变了属性等
* @return 无返回值
*/
MarkerClusterer.prototype._redraw = function() {
this._clearLastClusters()
this._createClusters()
}
/**
* 获取网格大小
* @return {Number} 网格大小
*/
MarkerClusterer.prototype.getGridSize = function() {
return this._gridSize
}
/**
* 设置网格大小
* @param {Number} size 网格大小
* @return 无返回值
*/
MarkerClusterer.prototype.setGridSize = function(size) {
this._gridSize = size
this._redraw()
}
/**
* 获取聚合的最大缩放级别。
* @return {Number} 聚合的最大缩放级别。
*/
MarkerClusterer.prototype.getMaxZoom = function() {
return this._maxZoom
}
/**
* 设置聚合的最大缩放级别
* @param {Number} maxZoom 聚合的最大缩放级别
* @return 无返回值
*/
MarkerClusterer.prototype.setMaxZoom = function(maxZoom) {
this._maxZoom = maxZoom
this._redraw()
}
/**
* 获取聚合的样式风格集合
* @return {Array<IconStyle>} 聚合的样式风格集合
*/
MarkerClusterer.prototype.getStyles = function() {
return this._styles
}
/**
* 设置聚合的样式风格集合
* @param {Array<IconStyle>} styles 样式风格数组
* @return 无返回值
*/
MarkerClusterer.prototype.setStyles = function(styles) {
this._styles = styles
this._redraw()
}
/**
* 获取单个聚合的最小数量。
* @return {Number} 单个聚合的最小数量。
*/
MarkerClusterer.prototype.getMinClusterSize = function() {
return this._minClusterSize
}
/**
* 设置单个聚合的最小数量。
* @param {Number} size 单个聚合的最小数量。
* @return 无返回值。
*/
MarkerClusterer.prototype.setMinClusterSize = function(size) {
this._minClusterSize = size
this._redraw()
}
/**
* 获取单个聚合的落脚点是否是聚合内所有标记的平均中心。
* @return {Boolean} true或false。
*/
MarkerClusterer.prototype.isAverageCenter = function() {
return this._isAverageCenter
}
/**
* 获取聚合的Map实例。
* @return {Map} Map的示例。
*/
MarkerClusterer.prototype.getMap = function() {
return this._map
}
/**
* 获取所有的标记数组。
* @return {Array<Marker>} 标记数组。
*/
MarkerClusterer.prototype.getMarkers = function() {
return this._markers
}
/**
* 获取聚合的总数量。
* @return {Number} 聚合的总数量。
*/
MarkerClusterer.prototype.getClustersCount = function() {
var count = 0
for (var i = 0, cluster; (cluster = this._clusters[i]); i++) {
cluster.isReal() && count++
}
return count
}
/**
* @ignore
* Cluster
* @class 表示一个聚合对象，该聚合，包含有N个标记，这N个标记组成的范围，并有予以显示在Map上的TextIconOverlay等。
* @constructor
* @param {MarkerClusterer} markerClusterer 一个标记聚合器示例。
*/
function Cluster(markerClusterer) {
this._markerClusterer = markerClusterer
this._map = markerClusterer.getMap()
this._minClusterSize = markerClusterer.getMinClusterSize()
this._isAverageCenter = markerClusterer.isAverageCenter()
this._center = null //落脚位置
this._markers = [] //这个Cluster中所包含的markers
this._gridBounds = null //以中心点为准，向四边扩大gridSize个像素的范围，也即网格范围
this._isReal = false //真的是个聚合
this._clusterMarker = new BMapLib.TextIconOverlay(this._center, this._markers.length, { styles: this._markerClusterer.getStyles() })
//this._map.addOverlay(this._clusterMarker);
}
/**
* 向该聚合添加一个标记。
* @param {Marker} marker 要添加的标记。
* @return 无返回值。
*/
Cluster.prototype.addMarker = function(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)
}
/**
* 进行dom操作
* @return 无返回值
*/
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()
}
}
/**
* 判断一个标记是否在该聚合中。
* @param {Marker} marker 要判断的标记。
* @return {Boolean} true或false。
*/
Cluster.prototype.isMarkerInCluster = function(marker) {
if (this._markers.indexOf) {
return this._markers.indexOf(marker) != -1
} else {
for (var i = 0, m; (m = this._markers[i]); i++) {
if (m === marker) {
return true
}
}
}
return false
}
/**
* 判断一个标记是否在该聚合网格范围中。
* @param {Marker} marker 要判断的标记。
* @return {Boolean} true或false。
*/
Cluster.prototype.isMarkerInClusterBounds = function(marker) {
return this._gridBounds.containsPoint(marker.getPosition())
}
Cluster.prototype.isReal = function(marker) {
return this._isReal
}
/**
* 更新该聚合的网格范围。
* @return 无返回值。
*/
Cluster.prototype.updateGridBounds = function() {
var bounds = new BMap.Bounds(this._center, this._center)
this._gridBounds = getExtendedBounds(this._map, bounds, this._markerClusterer.getGridSize())
}
/**
* 更新该聚合的显示样式，也即TextIconOverlay。
* @return 无返回值。
*/
Cluster.prototype.updateClusterMarker = function() {
if (this._map.getZoom() > this._markerClusterer.getMaxZoom()) {
this._clusterMarker && this._map.removeOverlay(this._clusterMarker)
for (var i = 0, marker; (marker = this._markers[i]); i++) {
this._map.addOverlay(marker)
}
return
}
if (this._markers.length < this._minClusterSize) {
this._clusterMarker.hide()
return
}
this._clusterMarker.setPosition(this._center)
this._clusterMarker.setText(this._markers.length)
var thatMap = this._map
var thatBounds = this.getBounds()
this._clusterMarker.addEventListener(‘click‘, function(event) {
thatMap.setViewport(thatBounds)
})
}
/**
* 删除该聚合。
* @return 无返回值。
*/
Cluster.prototype.remove = function() {
for (var i = 0, m; (m = this._markers[i]); i++) {
tmplabel = this._markers[i].getLabel()
this._markers[i].getMap() && this._map.removeOverlay(this._markers[i])
this._markers[i].setLabel(tmplabel)
} //清除散的标记点
this._map.removeOverlay(this._clusterMarker)
this._markers.length = 0
delete this._markers
}
/**
* 获取该聚合所包含的所有标记的最小外接矩形的范围。
* @return {BMap.Bounds} 计算出的范围。
*/
Cluster.prototype.getBounds = function() {
var bounds = new BMap.Bounds(this._center, this._center)
for (var i = 0, marker; (marker = this._markers[i]); i++) {
bounds.extend(marker.getPosition())
}
return bounds
}
/**
* 获取该聚合的落脚点。
* @return {BMap.Point} 该聚合的落脚点。
*/
Cluster.prototype.getCenter = function() {
return this._center
}
})()
/**
* @description 封装聚合函数
* @param markes 是所有点的集合
*/
markerClustersPoint(markers) {
if (this.markerClusterer) {
this.markerClusterer.clearMarkers() //清除聚合
}
this.markerClusterer = new this.baiduMapLib.MarkerClusterer(this.map, {
markers: markers,
minClusterSize: 2, //最小的聚合数量，小于该数量的不能成为一个聚合，默认为2
})
// console.log(‘进入聚合函数markerClusterer‘, this.markerClusterer)
// 拿到所有的聚合点
//markerClusterer中的 _clusters是一个数组，包含了可视范围的所有聚合点
const cluster = this.markerClusterer._clusters
for (let i = 0; i < cluster.length; i++) {
//cluster[i]._markers中包含此聚合点的所有marker集合 //marker长度大于2时不进行聚合效果显示
//自定义函数内容，可进行聚合点数据获取操作 //...... //...... //拿到聚合点中的marker数量，用于数字显示
if (cluster[i]._markers.length < 2) continue
}
},
百度地图点聚合优化（修改源码）
原文：https://www.cnblogs.com/xiaoqian227/p/13994996.html
