百度地图开发中遇到的问题

逃离我推掉我的手 2022-07-14 05:49 253阅读 0赞

# 问题1：含有label的marker聚合时label消失问题 #

## 问题描述： ##

使用百度地图API实现marker聚合最简单的方式就是编写如下的代码：

**当将自定义的Marker（含有Label）通过MarkerClusterer 管理的时候，当地图发生任何移动、缩放 的时候，Marker 的Label 就会自动消失**

## 问题解决 ##

网上我找到了这个解决方案Nautilus 同学的一个解决方案 [http://blog.sina.com.cn/s/blog\_484d][http_blog.sina.com.cn_s_blog_484d]

屏蔽了Cluster.prototype.remove 中的

this._markers[i].getMap() && this._map.removeOverlay(this._markers[i]); 这句话

但是其实这句话的调用是 \_redraw 当中的\_clearLastClusters 里清除Cluster用的，其他操作的时候并没有走这个，所以就导致了他说的“不完美”解决，偶尔还是会出现这个问题。

而且实际上removeOverlay 这个语句本身是有意义的，屏蔽了这个代码会造成clusterer 出现了，但是marker 不消失的问题（偶尔出现，未仔细测试）。

其实诱发这个问题的原因是在于

`map.removeOverlay(marker)`，在这句话执行的时候，会自动将`marker.label =null`， 由于Map 这个js 是百度自身混淆了的，不是太好分析，但是我们可以在Clusterer 处理的所有地方都先读出来Label，等remove完毕之后再将这个Maker.setLabel 过去就ok了

tmplabel = this._markers[i].getLabel();
    this._markers[i].getMap() && this._map.removeOverlay(this._markers[i]);
    this._markers[i].setLabel(tmplabel);

知道了诱因，就ok了，我在所有的removeOverlay Marker 都加入了上面的语句，之后 就可以“完美解决”这个问题了。  
PS：想用map的RemoveOverlay 事件，但是在他响应这个事件的时候，label 已经空了，所以不行 。  
最后，贴上我修改之后的MarkClusterer.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.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);
                }
            }
        };
    
        /** * 根据标记的位置，把它添加到最近的聚合中 * @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);
    
            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++) {
                    tmplabel = this._markers[i].getLabel();
                    this._markers[i].getMap() && this._map.removeOverlay(this._markers[i]);
                    this._markers[i].setLabel(tmplabel);
                }
    
            }
            this._map.addOverlay(this._clusterMarker);
            this._isReal = true;
            this.updateClusterMarker();
            return true;
        };
    
        /** * 判断一个标记是否在该聚合中。 * @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++) {
                var 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;
        };
    
    })();

# 问题2：为marker聚合自定义样式时JS文件报404的问题 #

## 问题描述： ##

为聚合自定义样式有如下两种方式：

//方法1：
    new BMapLib.MarkerClusterer(map, {markers:markers,styles:[{url,size,textColor:"",textSize:}]});
    //方法2：
    var markerClusterer = new BMapLib.MarkerClusterer(map, {markers:markers});
    var styles = [{
        url:'images/mapBoard/map-mark.png',  //图标路径
        size: new BMap.Size(50, 51),  //图标大小
        textColor: '#fff',  //文字颜色
        textSize: 14  //字体大小
    }];
    markerClusterer.setStyles(styles);

**在自定义样式时，如果不设置url属性，则就会报JS404错误。**

## 问题解决 ##

在自定义样式时，必须指定url属性。

# 问题3 信息框InfoWindow的问题 #

问题概括：  
CSS样式定制不友好

详细问题：  
1，信息框的样式定制困难。翻阅了整个API文档，想将白色的背景图片[http://api.map.baidu.com/images/iw3.png][http_api.map.baidu.com_images_iw3.png]换成自己的貌似没辙。  
2，信息框的四个角的容器没有class，对于想定制四个圆角的人来说相当蛋疼。能否和头部div.top、中部div.center一样，加上四个角的class如左上.topL,右上.topR  
3，要是信息框的显示方式用户可定制就好了。比如我可以加一些渐变显示或者渐变消失的动画效果。google在这方面支持动画

我的强烈建议，  
1，圆角不要用img标签应该用背景图。我不是CSS大牛，但是这点很多CSS大牛都会支持的。另一方面，如果用背景图，用户可以方便换自己喜欢的背景图  
2，四个圆角和底部箭头的容器得加上相应的class。。。必须的  
3，用户可以定制信息框的显示，至少提供一个显示后的回调函数onShow啥的  
＃问题4 infoBox内容超出时无法滚动

[http_blog.sina.com.cn_s_blog_484d]: http://blog.sina.com.cn/s/blog_484d
[http_api.map.baidu.com_images_iw3.png]: http://api.map.baidu.com/images/iw3.png