SwiftUI地图大距离标注聚类失效问题排查

问题背景 #

在SwiftUI地图应用中实现标注聚类，设置缩放级别≥60时聚类、<60时展示单个标注（共90个PetSittingListing标注点），遇到两个核心问题：

• 纽约（NY）与新墨西哥州（NM）的远距离标注无法合并为聚类，仅马略卡岛与巴塞罗那的近距离标注可正常聚类
• 聚类标注无法正确显示总数量

问题排查 #

1. 远距离标注不聚类的原因 #

当前聚类逻辑存在两个致命缺陷：

• 聚类半径计算完全不合理：使用log(zoomLevel) * 5计算半径，当zoomLevel=60时，半径仅约20公里，远小于跨州/跨国的距离（纽约到新墨西哥州超2000公里），根本无法触发远距离聚类。
• 聚类匹配逻辑不完整：遍历标注时仅匹配clusteredAnnotations中第一个符合距离条件的聚类，但聚类是逐个添加的，后续标注无法和更早创建的聚类匹配，导致聚类分组碎片化。

2. 聚类数量显示错误的原因 #

直接修改现有聚类的title字段，但初始标注的title是房源名称（listing.title），并非数字。第一次合并时，Int(existingCluster.title ?? "1")会因无法将字符串转为整数而崩溃（或默认取1，逻辑完全错误）。

修复后的代码实现 #

首先自定义标注类，分离普通标注和聚类标注的属性，避免依赖title存储数量：

import MapKit

// 自定义标注类型，区分房源标注和聚类标注
enum CustomAnnotation {
    case listing(MKPointAnnotation)
    case cluster(coordinate: CLLocationCoordinate2D, count: Int)
    
    // 统一获取坐标
    var coordinate: CLLocationCoordinate2D {
        switch self {
        case .listing(let annotation):
            return annotation.coordinate
        case .cluster(let coordinate, _):
            return coordinate
        }
    }
    
    // 统一获取显示标题
    var displayTitle: String {
        switch self {
        case .listing(let annotation):
            return annotation.title ?? ""
        case .cluster(_, let count):
            return "\(count) Listings"
        }
    }
}

class MapViewModel: ObservableObject {
    @Published var annotations: [CustomAnnotation] = []

    func createAnnotations(from listings: [PetSittingListing], zoomLevel: Double) {
        let group = DispatchGroup()
        var temporaryAnnotations: [MKPointAnnotation] = []

        for listing in listings {
            group.enter()
            if let latitude = listing.latitude, let longitude = listing.longitude {
                let annotation = MKPointAnnotation()
                annotation.title = listing.title
                annotation.coordinate = CLLocationCoordinate2D(latitude: latitude, longitude: longitude)
                temporaryAnnotations.append(annotation)
                group.leave()
            } else if let locationName = listing.location {
                let searchRequest = MKLocalSearch.Request()
                searchRequest.naturalLanguageQuery = locationName
                
                let search = MKLocalSearch(request: searchRequest)
                search.start { response, error in
                    if let error = error {
                        print("Error searching for location: \(error.localizedDescription)")
                        group.leave()
                        return
                    }
                    
                    if let coordinate = response?.mapItems.first?.placemark.coordinate {
                        let annotation = MKPointAnnotation()
                        annotation.title = listing.title
                        annotation.coordinate = coordinate
                        temporaryAnnotations.append(annotation)
                    }
                    group.leave()
                }
            } else {
                group.leave()
            }
        }

        group.notify(queue: .main) {
            if zoomLevel >= 60 {
                self.annotations = self.clusterAnnotations(annotations: temporaryAnnotations, zoomLevel: zoomLevel)
            } else {
                self.annotations = temporaryAnnotations.map { .listing($0) }
            }
        }
    }
    
    private func clusterAnnotations(annotations: [MKPointAnnotation], zoomLevel: Double) -> [CustomAnnotation] {
        var clusters: [(coordinate: CLLocationCoordinate2D, count: Int)] = []
        
        // 根据缩放级别动态调整聚类半径，适配不同距离场景
        let clusterRadius: Double
        if zoomLevel < 70 {
            clusterRadius = 5000 // 远距离聚类（跨州/跨国）
        } else if zoomLevel < 80 {
            clusterRadius = 500 // 中等距离聚类（跨城市）
        } else {
            clusterRadius = 50 // 近距离聚类（同城）
        }
        
        for annotation in annotations {
            var foundClusterIndex: Int?
            // 遍历所有已存在的聚类，寻找符合距离条件的分组
            for (index, cluster) in clusters.enumerated() {
                let distance = haversineDistance(from: cluster.coordinate, to: annotation.coordinate)
                if distance < clusterRadius {
                    foundClusterIndex = index
                    break
                }
            }
            
            if let index = foundClusterIndex {
                // 更新聚类：数量+1，同时将聚类坐标调整为所有标注的中心点
                let oldCluster = clusters[index]
                let newCount = oldCluster.count + 1
                let newLatitude = (oldCluster.coordinate.latitude * Double(oldCluster.count) + annotation.coordinate.latitude) / Double(newCount)
                let newLongitude = (oldCluster.coordinate.longitude * Double(oldCluster.count) + annotation.coordinate.longitude) / Double(newCount)
                clusters[index] = (
                    coordinate: CLLocationCoordinate2D(latitude: newLatitude, longitude: newLongitude),
                    count: newCount
                )
            } else {
                // 无匹配聚类，创建新聚类
                clusters.append((coordinate: annotation.coordinate, count: 1))
            }
        }
        
        // 转换为CustomAnnotation数组返回
        return clusters.map { .cluster(coordinate: $0.coordinate, count: $0.count) }
    }
    
    private func haversineDistance(from: CLLocationCoordinate2D, to: CLLocationCoordinate2D) -> Double {
        let earthRadius = 6371.0 // 地球半径（公里）
        let dLat = (to.latitude - from.latitude).degreesToRadians
        let dLon = (to.longitude - from.longitude).degreesToRadians
        
        let a = sin(dLat / 2) * sin(dLat / 2) +
                cos(from.latitude.degreesToRadians) * cos(to.latitude.degreesToRadians) *
                sin(dLon / 2) * sin(dLon / 2)
        
        let c = 2 * atan2(sqrt(a), sqrt(1 - a))
        return earthRadius * c
    }
}

extension Double {
    var degreesToRadians: Double { self * .pi / 180.0 }
}

更合理的聚类触发方案 #

不要使用固定的缩放级别阈值，而是根据地图可见区域的实际范围触发聚类，更符合用户交互逻辑：

1. 获取地图当前的visibleMapRect，计算可见区域的对角线距离
2. 根据距离动态调整策略：
   • 可见区域对角线距离 > 1000公里：全局聚类
   • 距离在100-1000公里之间：中等粒度聚类
   • 距离 < 100公里：展示单个标注或小范围聚类

实现示例（SwiftUI视图层）：

struct MapView: UIViewRepresentable {
    @ObservedObject var viewModel: MapViewModel
    var listings: [PetSittingListing]
    
    func makeUIView(context: Context) -> MKMapView {
        let mapView = MKMapView()
        mapView.delegate = context.coordinator
        // 监听地图区域变化
        mapView.addObserver(context.coordinator, forKeyPath: "visibleMapRect", options: [.new], context: nil)
        return mapView
    }
    
    func updateUIView(_ uiView: MKMapView, context: Context) {
        updateAnnotations(for: uiView)
    }
    
    private func updateAnnotations(for mapView: MKMapView) {
        // 计算可见区域对角线距离
        let visibleRect = mapView.visibleMapRect
        let topLeft = MKMapPoint(x: visibleRect.minX, y: visibleRect.minY).coordinate
        let bottomRight = MKMapPoint(x: visibleRect.maxX, y: visibleRect.maxY).coordinate
        let visibleDistance = viewModel.haversineDistance(from: topLeft, to: bottomRight)
        
        // 根据距离判断是否聚类
        let shouldCluster = visibleDistance > 100
        // 生成对应标注
        viewModel.createAnnotations(from: listings, zoomLevel: shouldCluster ? 70 : 50)
    }
    
    func makeCoordinator() -> Coordinator {
        Coordinator(parent: self)
    }
    
    class Coordinator: NSObject, MKMapViewDelegate {
        let parent: MapView
        
        init(parent: MapView) {
            self.parent = parent
        }
        
        // 监听地图区域变化，更新标注
        override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
            guard keyPath == "visibleMapRect", let mapView = object as? MKMapView else {
                super.observeValue(forKeyPath: keyPath, of: object, change: change, context: context)
                return
            }
            parent.updateAnnotations(for: mapView)
        }
        
        // 自定义标注视图（根据CustomAnnotation类型返回不同样式）
        func mapView(_ mapView: MKMapView, viewFor annotation: MKAnnotation) -> MKAnnotationView? {
            // 这里需要自行实现标注视图的创建逻辑，区分普通标注和聚类标注
            return nil
        }
    }
}

内容的提问来源于stack exchange，提问作者Ali Düşkün