expo-gaode-map 2.2.15 → 2.2.16

package/ios/overlays/ClusterView.swift

@@ -2,84 +2,290 @@ import ExpoModulesCore
 import MAMapKit
 
 class ClusterView: ExpoView {
-    var points: [[String: Any]] = []
-    var radius: Int = 100
-    var minClusterSize: Int = 2
+    // 属性
+    var points: [[String: Any]] = [] {
+        didSet {
+            buildQuadTree()
+        }
+    }
+    var radius: Int = 100 // 聚合范围 (screen points)
+    var minClusterSize: Int = 1
+    var clusterBuckets: [[String: Any]]?
+    
+    // 样式属性
+    private var clusterBackgroundColor: UIColor = .systemBlue
+    private var clusterBorderColor: UIColor = .white
+    private var clusterBorderWidth: CGFloat = 2.0
+    private var clusterTextColor: UIColor = .white
+    private var clusterTextSize: CGFloat = 14.0
+    private var clusterSize: CGSize = CGSize(width: 40, height: 40)
+    
+    let onClusterPress = EventDispatcher()
     
     private var mapView: MAMapView?
-    private var annotations: [MAPointAnnotation] = []
+    private var quadTree = CoordinateQuadTree()
+    private var currentAnnotations: [MAAnnotation] = []
+    private let quadTreeQueue = DispatchQueue(label: "com.expo.gaode.quadtree")
     
     required init(appContext: AppContext? = nil) {
         super.init(appContext: appContext)
     }
     
-    func setMap(_ map: MAMapView) {
-        self.mapView = map
-        updateCluster()
-    }
+    // MARK: - Setters for Expo Module
     
     func setPoints(_ points: [[String: Any]]) {
         self.points = points
-        updateCluster()
     }
     
     func setRadius(_ radius: Int) {
         self.radius = radius
-        updateCluster()
+        updateClusters()
     }
     
     func setMinClusterSize(_ size: Int) {
         self.minClusterSize = size
-        updateCluster()
+        updateClusters()
     }
     
-    private func updateCluster() {
-        guard let mapView = mapView else { return }
+    func setMap(_ map: MAMapView) {
+        self.mapView = map
+        updateClusters()
+    }
+
+    func setClusterStyle(_ style: [String: Any]) {
+        if let color = ColorParser.parseColor(style["backgroundColor"]) {
+            self.clusterBackgroundColor = color
+        }
+        if let borderColor = ColorParser.parseColor(style["borderColor"]) {
+            self.clusterBorderColor = borderColor
+        }
+        if let borderWidth = style["borderWidth"] as? Double {
+            self.clusterBorderWidth = CGFloat(borderWidth)
+        }
         
-        // 先移除旧的注释
-        removeAllAnnotations()
+        // 尺寸设置
+        if let width = style["width"] as? Double {
+            self.clusterSize.width = CGFloat(width)
+            // 如果只设置了宽度，默认高度等于宽度（正圆）
+            if style["height"] == nil {
+                self.clusterSize.height = CGFloat(width)
+            }
+        }
         
-        // 验证数据有效性
-        guard !points.isEmpty else { return }
+        if let height = style["height"] as? Double {
+            self.clusterSize.height = CGFloat(height)
+            // 如果只设置了高度，默认宽度等于高度
+            if style["width"] == nil {
+                self.clusterSize.width = CGFloat(height)
+            }
+        }
         
-        for point in points {
-            guard let latitude = point["latitude"] as? Double,
-                  let longitude = point["longitude"] as? Double else {
-                continue
+        updateClusters()
+    }
+    
+    func setClusterTextStyle(_ style: [String: Any]) {
+        if let color = ColorParser.parseColor(style["color"]) {
+            self.clusterTextColor = color
+        }
+        if let fontSize = style["fontSize"] as? Double {
+            self.clusterTextSize = CGFloat(fontSize)
+        }
+        updateClusters()
+    }
+
+    func setClusterBuckets(_ buckets: [[String: Any]]) {
+        self.clusterBuckets = buckets
+        updateClusters()
+    }
+
+    func mapRegionDidChange() {
+        updateClusters()
+    }
+    
+    // MARK: - QuadTree Logic
+    
+    private func buildQuadTree() {
+        // 在后台串行队列构建四叉树，保证线程安全
+        quadTreeQueue.async { [weak self] in
+            guard let self = self else { return }
+            self.quadTree.clear()
+            self.quadTree.build(with: self.points)
+            
+            // 构建完成后触发更新
+            DispatchQueue.main.async {
+                self.updateClusters()
             }
+        }
+    }
+    
+    // MARK: - Update Logic
+    
+    func updateClusters() {
+        guard let mapView = mapView else { return }
+        
+        // 确保地图已布局
+        if mapView.bounds.size.width == 0 { return }
+        
+        let visibleRect = mapView.visibleMapRect
+        let boundsWidth = Double(mapView.bounds.size.width)
+        let zoomScale = boundsWidth > 0 ? visibleRect.size.width / boundsWidth : 0
+        let currentRadius = Double(self.radius)
+        
+        // 在后台串行队列计算聚合
+        quadTreeQueue.async { [weak self] in
+            guard let self = self else { return }
             
-            let annotation = MAPointAnnotation()
-            annotation.coordinate = CLLocationCoordinate2D(latitude: latitude, longitude: longitude)
-            mapView.addAnnotation(annotation)
-            annotations.append(annotation)
+            let annotations = self.quadTree.clusteredAnnotations(within: visibleRect, zoomScale: zoomScale, gridSize: currentRadius)
+            
+            DispatchQueue.main.async {
+                self.updateMapViewAnnotations(with: annotations as [MAAnnotation])
+            }
         }
     }
     
-    /**
-     * 移除所有标注
-     */
-    private func removeAllAnnotations() {
+    private func updateMapViewAnnotations(with newAnnotations: [MAAnnotation]) {
         guard let mapView = mapView else { return }
         
-        for annotation in annotations {
-            mapView.removeAnnotation(annotation)
+        // Diff 算法：找出新增、移除和保留的标注
+        // 注意：ClusterAnnotation 需要实现 isEqual 和 hash
+        
+        let before = Set(currentAnnotations.compactMap { $0 as? ClusterAnnotation })
+        let after = Set(newAnnotations.compactMap { $0 as? ClusterAnnotation })
+        
+        // intersection 返回 before 中的元素（如果相等），这正是我们需要保留的已经在地图上的实例
+        let toKeep = before.intersection(after)
+        let toAdd = after.subtracting(toKeep)
+        let toRemove = before.subtracting(toKeep)
+        
+        // 只有当有变化时才操作
+        if !toRemove.isEmpty {
+            mapView.removeAnnotations(Array(toRemove) as [MAAnnotation])
         }
-        annotations.removeAll()
+        
+        if !toAdd.isEmpty {
+            mapView.addAnnotations(Array(toAdd) as [MAAnnotation])
+        }
+        
+        // 更新 currentAnnotations
+        // 关键：必须保留已经在地图上的实例 (toKeep)，加上新增的实例 (toAdd)
+        // 这样可以保证 currentAnnotations 中的对象始终与地图上的对象一致，避免 KVO 崩溃
+        var nextAnnotations: [MAAnnotation] = []
+        nextAnnotations.append(contentsOf: Array(toKeep) as [MAAnnotation])
+        nextAnnotations.append(contentsOf: Array(toAdd) as [MAAnnotation])
+        
+        currentAnnotations = nextAnnotations
     }
     
-    /**
-     * 从父视图移除时清理标注
-     */
-    override func removeFromSuperview() {
-        super.removeFromSuperview()
-        removeAllAnnotations()
+    // MARK: - View Provider
+    
+    func viewForAnnotation(_ annotation: MAAnnotation) -> MAAnnotationView? {
+        guard let clusterAnnotation = annotation as? ClusterAnnotation else { return nil }
+        
+        let reuseIdentifier = "ClusterAnnotation"
+        var annotationView = mapView?.dequeueReusableAnnotationView(withIdentifier: reuseIdentifier)
+        
+        if annotationView == nil {
+            annotationView = MAAnnotationView(annotation: annotation, reuseIdentifier: reuseIdentifier)
+        }
+        
+        annotationView?.annotation = annotation
+        annotationView?.canShowCallout = false
+        
+        // 生成图标
+        annotationView?.image = image(for: clusterAnnotation.count)
+        annotationView?.centerOffset = CGPoint(x: 0, y: 0)
+        annotationView?.zIndex = 100
+        
+        return annotationView
+    }
+    
+    private func image(for count: Int) -> UIImage? {
+        let size = self.clusterSize
+        let renderer = UIGraphicsImageRenderer(size: size)
+        
+        return renderer.image { context in
+            let rect = CGRect(origin: .zero, size: size)
+            
+            // 基础样式
+            var bgColor = self.clusterBackgroundColor
+            var borderColor = self.clusterBorderColor
+            var borderWidth = self.clusterBorderWidth
+            
+            // 应用分级样式
+            if let buckets = self.clusterBuckets {
+                var bestBucket: [String: Any]?
+                var maxMinPoints = -1
+                
+                for bucket in buckets {
+                    if let minPoints = bucket["minPoints"] as? Int, minPoints <= count {
+                        if minPoints > maxMinPoints {
+                            maxMinPoints = minPoints
+                            bestBucket = bucket
+                        }
+                    }
+                }
+                
+                if let bucket = bestBucket {
+                    if let c = ColorParser.parseColor(bucket["backgroundColor"]) {
+                        bgColor = c
+                    }
+                    if let c = ColorParser.parseColor(bucket["borderColor"]) {
+                        borderColor = c
+                    }
+                    if let w = bucket["borderWidth"] as? Double {
+                        borderWidth = CGFloat(w)
+                    }
+                }
+            }
+            
+            bgColor.setFill()
+            UIBezierPath(ovalIn: rect).fill()
+            
+            // 绘制边框
+            if borderWidth > 0 {
+                borderColor.setStroke()
+                let path = UIBezierPath(ovalIn: rect.insetBy(dx: borderWidth / 2, dy: borderWidth / 2))
+                path.lineWidth = borderWidth
+                path.stroke()
+            }
+            
+            // 绘制文字
+            let text = "\(count)"
+            let attributes: [NSAttributedString.Key: Any] = [
+                .font: UIFont.boldSystemFont(ofSize: self.clusterTextSize),
+                .foregroundColor: self.clusterTextColor
+            ]
+            let textSize = text.size(withAttributes: attributes)
+            let textRect = CGRect(x: (size.width - textSize.width) / 2,
+                                  y: (size.height - textSize.height) / 2,
+                                  width: textSize.width,
+                                  height: textSize.height)
+            text.draw(in: textRect, withAttributes: attributes)
+        }
     }
     
-    /**
-     * 析构时移除标注
-     */
-    deinit {
-        removeAllAnnotations()
-        mapView = nil
+    // MARK: - Event Handling
+    
+    func containsAnnotation(_ annotation: MAAnnotation) -> Bool {
+        guard let clusterAnnotation = annotation as? ClusterAnnotation else { return false }
+        return currentAnnotations.contains { $0.isEqual(clusterAnnotation) }
+    }
+    
+    func handleAnnotationTap(_ annotation: MAAnnotation) {
+        guard let clusterAnnotation = annotation as? ClusterAnnotation else { return }
+        
+        onClusterPress([
+            "count": clusterAnnotation.count,
+            "latitude": clusterAnnotation.coordinate.latitude,
+            "longitude": clusterAnnotation.coordinate.longitude,
+            "pois": clusterAnnotation.pois
+        ])
+    }
+    
+    // MARK: - Lifecycle
+    
+    override func removeFromSuperview() {
+        super.removeFromSuperview()
+        mapView?.removeAnnotations(currentAnnotations)
     }
-}
+}

package/ios/overlays/ClusterViewModule.swift

@@ -5,6 +5,8 @@ public class ClusterViewModule: Module {
         Name("ClusterView")
         
         View(ClusterView.self) {
+            Events("onClusterPress")
+
             Prop("points") { (view: ClusterView, points: [[String: Any]]) in
                 view.setPoints(points)
             }
@@ -16,6 +18,18 @@ public class ClusterViewModule: Module {
             Prop("minClusterSize") { (view: ClusterView, size: Int) in
                 view.setMinClusterSize(size)
             }
+            
+            Prop("clusterStyle") { (view: ClusterView, style: [String: Any]) in
+                view.setClusterStyle(style)
+            }
+            
+            Prop("clusterTextStyle") { (view: ClusterView, style: [String: Any]) in
+                view.setClusterTextStyle(style)
+            }
+
+            Prop("clusterBuckets") { (view: ClusterView, buckets: [[String: Any]]) in
+                view.setClusterBuckets(buckets)
+            }
         }
     }
 }

package/ios/overlays/CoordinateQuadTree.swift

@@ -0,0 +1,291 @@
+import Foundation
+import CoreLocation
+import MAMapKit
+
+// MARK: - 数据结构定义
+
+struct QuadTreePoint {
+    let x: Double // latitude
+    let y: Double // longitude
+    let data: [String: Any]
+}
+
+struct BoundingBox {
+    let minX: Double // min latitude
+    let minY: Double // min longitude
+    let maxX: Double // max latitude
+    let maxY: Double // max longitude
+    
+    func contains(_ point: QuadTreePoint) -> Bool {
+        return point.x >= minX && point.x <= maxX && point.y >= minY && point.y <= maxY
+    }
+    
+    func intersects(_ other: BoundingBox) -> Bool {
+        return other.minX <= maxX && other.maxX >= minX && other.minY <= maxY && other.maxY >= minY
+    }
+}
+
+private class QuadTreeNode {
+    var points: [QuadTreePoint] = []
+    var boundingBox: BoundingBox
+    var northWest: QuadTreeNode?
+    var northEast: QuadTreeNode?
+    var southWest: QuadTreeNode?
+    var southEast: QuadTreeNode?
+    
+    static let capacity = 20 // 增加容量以减少树深度
+    
+    init(boundingBox: BoundingBox) {
+        self.boundingBox = boundingBox
+    }
+    
+    func insert(_ point: QuadTreePoint) -> Bool {
+        if !boundingBox.contains(point) {
+            return false
+        }
+        
+        if points.count < QuadTreeNode.capacity && northWest == nil {
+            points.append(point)
+            return true
+        }
+        
+        if northWest == nil {
+            subdivide()
+        }
+        
+        if northWest!.insert(point) { return true }
+        if northEast!.insert(point) { return true }
+        if southWest!.insert(point) { return true }
+        if southEast!.insert(point) { return true }
+        
+        return false
+    }
+    
+    func subdivide() {
+        let xMid = (boundingBox.minX + boundingBox.maxX) / 2
+        let yMid = (boundingBox.minY + boundingBox.maxY) / 2
+        
+        northWest = QuadTreeNode(boundingBox: BoundingBox(minX: xMid, minY: boundingBox.minY, maxX: boundingBox.maxX, maxY: yMid)) // Top-Left (Lat increases upwards? No, Lat is X here)
+        // Note: Lat/Lon mapping to X/Y needs care.
+        // Let's assume X=Lat, Y=Lon.
+        // North is +Lat (MaxX), South is -Lat (MinX).
+        // East is +Lon (MaxY), West is -Lon (MinY).
+        
+        // Correct subdivision:
+        // North (High Lat) / South (Low Lat)
+        // East (High Lon) / West (Low Lon)
+        
+        // NorthWest: Lat [Mid, Max], Lon [Min, Mid]
+        northWest = QuadTreeNode(boundingBox: BoundingBox(minX: xMid, minY: boundingBox.minY, maxX: boundingBox.maxX, maxY: yMid))
+        
+        // NorthEast: Lat [Mid, Max], Lon [Mid, Max]
+        northEast = QuadTreeNode(boundingBox: BoundingBox(minX: xMid, minY: yMid, maxX: boundingBox.maxX, maxY: boundingBox.maxY))
+        
+        // SouthWest: Lat [Min, Mid], Lon [Min, Mid]
+        southWest = QuadTreeNode(boundingBox: BoundingBox(minX: boundingBox.minX, minY: boundingBox.minY, maxX: xMid, maxY: yMid))
+        
+        // SouthEast: Lat [Min, Mid], Lon [Mid, Max]
+        southEast = QuadTreeNode(boundingBox: BoundingBox(minX: boundingBox.minX, minY: yMid, maxX: xMid, maxY: boundingBox.maxY))
+        
+        // Redistribute points
+        for p in points {
+            _ = northWest!.insert(p) || northEast!.insert(p) || southWest!.insert(p) || southEast!.insert(p)
+        }
+        points.removeAll()
+    }
+    
+    func query(range: BoundingBox, results: inout [QuadTreePoint]) {
+        if !boundingBox.intersects(range) {
+            return
+        }
+        
+        for p in points {
+            if range.contains(p) {
+                results.append(p)
+            }
+        }
+        
+        if northWest == nil {
+            return
+        }
+        
+        northWest!.query(range: range, results: &results)
+        northEast!.query(range: range, results: &results)
+        southWest!.query(range: range, results: &results)
+        southEast!.query(range: range, results: &results)
+    }
+}
+
+// MARK: - QuadTree 管理类
+
+class CoordinateQuadTree {
+    private var root: QuadTreeNode?
+    
+    /// 构建四叉树
+    func build(with points: [[String: Any]]) {
+        // 全球范围
+        let worldBox = BoundingBox(minX: -90, minY: -180, maxX: 90, maxY: 180)
+        root = QuadTreeNode(boundingBox: worldBox)
+        
+        for pointData in points {
+            if let lat = pointData["latitude"] as? Double,
+               let lon = pointData["longitude"] as? Double {
+                let point = QuadTreePoint(x: lat, y: lon, data: pointData)
+                _ = root?.insert(point)
+            }
+        }
+    }
+    
+    /// 清除
+    func clear() {
+        root = nil
+    }
+    
+    /// 计算聚类
+    /// - Parameters:
+    ///   - visibleRect: 当前可见区域 (MAMapRect)
+    ///   - zoomLevel: 当前缩放级别
+    ///   - gridSize: 聚合网格大小（像素），默认 50
+    func clusteredAnnotations(within visibleRect: MAMapRect, zoomLevel: Double, gridSize: Double = 50) -> [ClusterAnnotation] {
+        guard let root = root else { return [] }
+        
+        // 1. 计算当前 zoomLevel 下，gridSize 对应的经纬度范围
+        // 这是一个粗略估算，因为经纬度距离随纬度变化。
+        // 为了简化，我们使用一个经验公式或 MAMapKit 提供的转换（如果可用）。
+        // 这里我们使用一个简单的比例：
+        // 缩放级别每增加1，分辨率翻倍（每像素代表的度数减半）。
+        // Zoom 3: ~30 degrees per screen? No.
+        // A standard approach in QuadTree clustering is distance-based clustering.
+        
+        // 计算当前可视区域的经纬度范围
+        let northEast = MACoordinateForMapPoint(MAMapPoint(x: visibleRect.origin.x + visibleRect.size.width, y: visibleRect.origin.y))
+        let southWest = MACoordinateForMapPoint(MAMapPoint(x: visibleRect.origin.x, y: visibleRect.origin.y + visibleRect.size.height))
+        
+        // 注意：MAMapRect 的坐标系原点在左上角？MAMapPoint 是投影坐标。
+        // MAMapCoordinateForMapPoint 转换是准确的。
+        
+        let minLat = min(northEast.latitude, southWest.latitude)
+        let maxLat = max(northEast.latitude, southWest.latitude)
+        let minLon = min(northEast.longitude, southWest.longitude)
+        let maxLon = max(northEast.longitude, southWest.longitude)
+        
+        // 扩大一点搜索范围，避免边界问题
+        let searchBox = BoundingBox(minX: minLat, minY: minLon, maxX: maxLat, maxY: maxLon)
+        
+        var pointsInView: [QuadTreePoint] = []
+        root.query(range: searchBox, results: &pointsInView)
+        
+        // 如果点太多，可能会卡顿。这里可以限制最大点数。
+        
+        // 2. 基于距离的聚类
+        // 将 gridSize (screen pixels) 转换为经纬度距离
+        // 这需要 mapView 的 bounds 和 visibleMapRect。但这里我们只有 visibleRect 和 zoomLevel。
+        // 我们可以估算。
+        // Scale = visibleRect.size.width / mapView.bounds.size.width (MAMapPoint per pixel)
+        // 这里没有 map view bounds，只有 visibleRect。
+        // 假设 visibleRect 对应整个屏幕。
+        
+        // 实际上，MAMapPoint 的单位是米（大约）。
+        // 我们可以直接在 MAMapPoint 坐标系下做聚类，这样更方便，因为它是平面的。
+        // 但是我们的 QuadTree 存储的是经纬度。
+        // 方案：将查询到的点转换为 MAMapPoint，然后进行距离聚类。
+        
+        var clusters: [ClusterAnnotation] = []
+        var visited = Set<String>() // 存储已处理点的唯一标识（这里用 hash 或 index）
+        // 由于 QuadTreePoint 没有 ID，我们用 index
+        var visitedIndices = Set<Int>()
+        
+        // 转换 gridSize 到 MAMapPoint 距离
+        // 整个地图宽度约 2.68亿 (MAMapSizeWorld.width)
+        // ZoomLevel 3 -> 1 pixel = large distance
+        // 我们利用传入的 zoomScale 或者直接利用 MAMetersPerMapPointAtZoomLevel? No.
+        
+        // 用户传入了 zoomScale (MAMapPoint per pixel)
+        // Let's assume gridSize is 50 pixels.
+        // distance = gridSize * zoomScale
+        
+        // 但是参数里没有 zoomScale，只有 visibleRect 和 zoomLevel。
+        // 我们可以推算 zoomScale。
+        // 实际上，用户示例代码传了 zoomScale:
+        // clusteredAnnotations(within: visibleRect, withZoomScale: zoomScale, andZoomLevel: zoomLevel)
+        // 我应该修改方法签名以包含 zoomScale。
+        
+        // 暂时无法获取 zoomScale，我们先用 zoomLevel 估算。
+        // 或者直接让调用者传入 zoomScale。
+        
+        return [] // 临时返回，需要在 updateClusterView 中正确调用
+    }
+    
+    // 重载带 zoomScale 的方法
+    func clusteredAnnotations(within visibleRect: MAMapRect, zoomScale: Double, gridSize: Double = 50) -> [ClusterAnnotation] {
+        guard let root = root else { return [] }
+        
+        // 1. 查询可见区域内的点
+        let northEast = MACoordinateForMapPoint(MAMapPoint(x: visibleRect.origin.x + visibleRect.size.width, y: visibleRect.origin.y))
+        let southWest = MACoordinateForMapPoint(MAMapPoint(x: visibleRect.origin.x, y: visibleRect.origin.y + visibleRect.size.height))
+        
+        let minLat = min(northEast.latitude, southWest.latitude)
+        let maxLat = max(northEast.latitude, southWest.latitude)
+        let minLon = min(northEast.longitude, southWest.longitude)
+        let maxLon = max(northEast.longitude, southWest.longitude)
+        
+        let searchBox = BoundingBox(minX: minLat, minY: minLon, maxX: maxLat, maxY: maxLon)
+        
+        var pointsInView: [QuadTreePoint] = []
+        root.query(range: searchBox, results: &pointsInView)
+        
+        if pointsInView.isEmpty { return [] }
+        
+        // 2. 聚类
+        // 聚类半径（MAMapPoint 单位）
+        let clusterRadius = gridSize * zoomScale
+        let clusterRadiusSq = clusterRadius * clusterRadius
+        
+        var clusters: [ClusterAnnotation] = []
+        var visited = [Bool](repeating: false, count: pointsInView.count)
+        
+        // 将所有点转换为 MAMapPoint 以便计算距离
+        let mapPoints = pointsInView.map { MAMapPointForCoordinate(CLLocationCoordinate2D(latitude: $0.x, longitude: $0.y)) }
+        
+        for i in 0..<pointsInView.count {
+            if visited[i] { continue }
+            
+            let centerPoint = pointsInView[i]
+            let centerMapPoint = mapPoints[i]
+            
+            var clusterPoints: [[String: Any]] = [centerPoint.data]
+            visited[i] = true
+            
+            // 查找邻居
+            for j in (i+1)..<pointsInView.count {
+                if visited[j] { continue }
+                
+                let neighborMapPoint = mapPoints[j]
+                
+                let dx = centerMapPoint.x - neighborMapPoint.x
+                let dy = centerMapPoint.y - neighborMapPoint.y
+                let distSq = dx*dx + dy*dy
+                
+                if distSq <= clusterRadiusSq {
+                    clusterPoints.append(pointsInView[j].data)
+                    visited[j] = true
+                }
+            }
+            
+            if clusterPoints.count == 1 {
+                // 单个点
+                let annotation = ClusterAnnotation(coordinate: CLLocationCoordinate2D(latitude: centerPoint.x, longitude: centerPoint.y), count: 1, pois: clusterPoints)
+                clusters.append(annotation)
+            } else {
+                // 聚合点：计算平均坐标 (这里简单使用中心点坐标，或者计算所有点的平均值)
+                // 高德示例通常使用第一个点的坐标作为聚合点坐标，或者计算重心。
+                // 为了视觉稳定，使用中心点坐标可能更好？不，使用重心更准确。
+                // 简单起见，使用 centerPoint (第一个点) 的坐标。
+                let annotation = ClusterAnnotation(coordinate: CLLocationCoordinate2D(latitude: centerPoint.x, longitude: centerPoint.y), count: clusterPoints.count, pois: clusterPoints)
+                clusters.append(annotation)
+            }
+        }
+        
+        return clusters
+    }
+}