expo-gaode-map-navigation 1.1.5 → 1.1.7

package/ios/map/overlays/PolylineViewModule.swift

@@ -1,37 +1,43 @@
 import ExpoModulesCore
 
-public class NaviPolylineViewModule: Module {
+public class PolylineViewModule: Module {
     public func definition() -> ModuleDefinition {
-        Name("NaviPolylineView")
+        Name("PolylineView")
         
-        View(NaviPolylineView.self) {
+        View(PolylineView.self) {
             Events("onPolylinePress")
             
-            Prop("points") { (view: NaviPolylineView, points: [[String: Double]]) in
-                view.setPoints(points)
-            }
+            Prop("points") { (view: PolylineView, points: [[String: Double]]) in
+            view.setPoints(points)
+        }
             
-            Prop("strokeWidth") { (view: NaviPolylineView, width: Double) in
+            Prop("strokeWidth") { (view: PolylineView, width: Double) in
                 view.setStrokeWidth(Float(width))
             }
             
-            Prop("strokeColor") { (view: NaviPolylineView, color: String) in
+            Prop("strokeColor") { (view: PolylineView, color: String?) in
                 view.setStrokeColor(color)
             }
             
-            Prop("texture") { (view: NaviPolylineView, url: String?) in
+            Prop("texture") { (view: PolylineView, url: String?) in
                 view.setTexture(url)
             }
             
-            Prop("dotted") { (view: NaviPolylineView, dotted: Bool) in
+            Prop("dotted") { (view: PolylineView, dotted: Bool) in
                 view.setDotted(dotted)
             }
+
+            Prop("simplificationTolerance") { (view: PolylineView, tolerance: Double) in
+                view.setSimplificationTolerance(tolerance)
+            }
             
-            OnViewDidUpdateProps { (view: NaviPolylineView) in
+            OnViewDidUpdateProps { (view: PolylineView) in
+                // 属性更新完成后，如果还没连接地图，尝试连接
                 if !view.isMapConnected() {
+                    // 查找父视图 ExpoGaodeMapView
                     var parent = view.superview
                     while parent != nil {
-                        if let mapView = parent as? NaviMapView {
+                        if let mapView = parent as? ExpoGaodeMapView {
                             view.setMap(mapView.mapView)
                             return
                         }

package/ios/map/utils/ClusterNative.h

@@ -0,0 +1,96 @@
+#import <Foundation/Foundation.h>
+#import <CoreLocation/CoreLocation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface ClusterNative : NSObject
+
++ (NSArray<NSNumber *> *)clusterPointsWithLatitudes:(NSArray<NSNumber *> *)latitudes
+                                       longitudes:(NSArray<NSNumber *> *)longitudes
+                                      radiusMeters:(double)radiusMeters NS_SWIFT_NAME(clusterPoints(latitudes:longitudes:radiusMeters:));
+
++ (BOOL)isPointInCircleWithPointLat:(double)pointLat
+                          pointLon:(double)pointLon
+                         centerLat:(double)centerLat
+                         centerLon:(double)centerLon
+                       radiusMeters:(double)radiusMeters NS_SWIFT_NAME(isPointInCircle(pointLat:pointLon:centerLat:centerLon:radiusMeters:));
+
++ (BOOL)isPointInPolygonWithPointLat:(double)pointLat
+                           pointLon:(double)pointLon
+                          latitudes:(NSArray<NSNumber *> *)latitudes
+                         longitudes:(NSArray<NSNumber *> *)longitudes NS_SWIFT_NAME(isPointInPolygon(pointLat:pointLon:latitudes:longitudes:));
+
++ (double)calculatePolygonAreaWithLatitudes:(NSArray<NSNumber *> *)latitudes
+                                  longitudes:(NSArray<NSNumber *> *)longitudes NS_SWIFT_NAME(calculatePolygonArea(latitudes:longitudes:));
+
++ (double)calculateRectangleAreaWithSouthWestLat:(double)swLat
+                                     southWestLon:(double)swLon
+                                    northEastLat:(double)neLat
+                                    northEastLon:(double)neLon NS_SWIFT_NAME(calculateRectangleArea(swLat:swLon:neLat:neLon:));
+
++ (double)calculateDistanceWithLat1:(double)lat1
+                               lon1:(double)lon1
+                               lat2:(double)lat2
+                               lon2:(double)lon2 NS_SWIFT_NAME(calculateDistance(lat1:lon1:lat2:lon2:));
+
++ (NSArray<NSNumber *> *)simplifyPolylineWithLatitudes:(NSArray<NSNumber *> *)latitudes
+                                           longitudes:(NSArray<NSNumber *> *)longitudes
+                                      toleranceMeters:(double)toleranceMeters NS_SWIFT_NAME(simplifyPolyline(latitudes:longitudes:tolerance:));
+
++ (double)calculatePathLengthWithLatitudes:(NSArray<NSNumber *> *)latitudes
+                                longitudes:(NSArray<NSNumber *> *)longitudes NS_SWIFT_NAME(calculatePathLength(latitudes:longitudes:));
+
++ (NSDictionary * _Nullable)getPointAtDistanceWithLatitudes:(NSArray<NSNumber *> *)latitudes
+                                               longitudes:(NSArray<NSNumber *> *)longitudes
+                                           distanceMeters:(double)distanceMeters NS_SWIFT_NAME(getPointAtDistance(latitudes:longitudes:distanceMeters:));
+
++ (NSDictionary * _Nullable)getNearestPointOnPathWithLatitudes:(NSArray<NSNumber *> *)latitudes
+                                                    longitudes:(NSArray<NSNumber *> *)longitudes
+                                                     targetLat:(double)targetLat
+                                                     targetLon:(double)targetLon NS_SWIFT_NAME(getNearestPointOnPath(latitudes:longitudes:targetLat:targetLon:));
+
++ (NSDictionary * _Nullable)calculateCentroidWithLatitudes:(NSArray<NSNumber *> *)latitudes
+                                               longitudes:(NSArray<NSNumber *> *)longitudes NS_SWIFT_NAME(calculateCentroid(latitudes:longitudes:));
+
++ (NSDictionary * _Nullable)calculatePathBoundsWithLatitudes:(NSArray<NSNumber *> *)latitudes
+                                                longitudes:(NSArray<NSNumber *> *)longitudes NS_SWIFT_NAME(calculatePathBounds(latitudes:longitudes:));
+
++ (NSString *)encodeGeoHashWithLat:(double)lat
+                               lon:(double)lon
+                         precision:(int)precision NS_SWIFT_NAME(encodeGeoHash(lat:lon:precision:));
+
++ (uint32_t)parseColorWithString:(NSString *)colorString NS_SWIFT_NAME(parseColor(colorString:));
+
++ (CLLocationCoordinate2D)coordinateForMapPointWithX:(double)x y:(double)y NS_SWIFT_NAME(coordinateForMapPoint(x:y:));
+
+/**
+ * 解析高德地图 API 返回的 Polyline 字符串
+ * 格式: "lng,lat;lng,lat;..."
+ * @param polylineStr 高德原始 polyline 字符串
+ * @return 扁平化的坐标数组 [lat1, lon1, lat2, lon2, ...]
+ */
++ (NSArray<NSNumber *> *)parsePolyline:(NSString *)polylineStr NS_SWIFT_NAME(parsePolyline(polylineStr:));
+
+// --- 瓦片与坐标转换 ---
++ (NSDictionary *)latLngToTileWithLat:(double)lat lon:(double)lon zoom:(int)zoom NS_SWIFT_NAME(latLngToTile(lat:lon:zoom:));
++ (NSDictionary *)tileToLatLngWithX:(int)x y:(int)y zoom:(int)zoom NS_SWIFT_NAME(tileToLatLng(x:y:zoom:));
++ (NSDictionary *)latLngToPixelWithLat:(double)lat lon:(double)lon zoom:(int)zoom NS_SWIFT_NAME(latLngToPixel(lat:lon:zoom:));
++ (NSDictionary *)pixelToLatLngWithX:(double)x y:(double)y zoom:(int)zoom NS_SWIFT_NAME(pixelToLatLng(x:y:zoom:));
+
+// --- 批量地理围栏与网格聚合 ---
++ (int)findPointInPolygonsWithPointLat:(double)pointLat
+                              pointLon:(double)pointLon
+                              polygons:(NSArray<NSArray<NSDictionary *> *> *)polygons NS_SWIFT_NAME(findPointInPolygons(pointLat:pointLon:polygons:));
+
+/**
+ * 生成网格聚合数据 (常用于展示网格聚合图或大规模点数据处理)
+ * 将大量散点按照网格大小进行聚合，返回每个网格的中心点和强度
+ */
++ (NSArray<NSDictionary *> *)generateHeatmapGridWithLatitudes:(NSArray<NSNumber *> *)latitudes
+                                                   longitudes:(NSArray<NSNumber *> *)longitudes
+                                                      weights:(NSArray<NSNumber *> *)weights
+                                              gridSizeMeters:(double)gridSizeMeters NS_SWIFT_NAME(generateHeatmapGrid(latitudes:longitudes:weights:gridSizeMeters:));
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/map/utils/ClusterNative.mm

@@ -0,0 +1,377 @@
+#import "ClusterNative.h"
+
+#if __has_include(<MAMapKit/MAMapKit.h>)
+#import <MAMapKit/MAMapKit.h>
+#define HAS_MAMAPKIT 1
+#else
+#define HAS_MAMAPKIT 0
+#endif
+
+#include <vector>
+#include <string>
+
+#include "../cpp/ClusterEngine.hpp"
+#include "../cpp/GeometryEngine.hpp"
+#include "../cpp/ColorParser.hpp"
+
+@implementation ClusterNative
+
++ (NSArray<NSNumber *> *)clusterPointsWithLatitudes:(NSArray<NSNumber *> *)latitudes
+                                       longitudes:(NSArray<NSNumber *> *)longitudes
+                                      radiusMeters:(double)radiusMeters {
+    if (latitudes.count == 0 || latitudes.count != longitudes.count) {
+        return @[@0];
+    }
+
+    std::vector<gaodemap::ClusterPoint> points;
+    points.reserve(latitudes.count);
+
+    for (NSUInteger i = 0; i < latitudes.count; i++) {
+        gaodemap::ClusterPoint point;
+        point.lat = latitudes[i].doubleValue;
+        point.lon = longitudes[i].doubleValue;
+        point.index = (int)i;
+        points.push_back(point);
+    }
+
+    const auto clusters = gaodemap::clusterPoints(points, radiusMeters);
+
+    NSMutableArray<NSNumber *> *result = [NSMutableArray array];
+    [result addObject:@(clusters.size())];
+
+    for (const auto &cluster : clusters) {
+        [result addObject:@(cluster.centerIndex)];
+        [result addObject:@(cluster.indices.size())];
+        for (int idx : cluster.indices) {
+            [result addObject:@(idx)];
+        }
+    }
+
+    return result;
+}
+
++ (BOOL)isPointInCircleWithPointLat:(double)pointLat
+                          pointLon:(double)pointLon
+                         centerLat:(double)centerLat
+                         centerLon:(double)centerLon
+                       radiusMeters:(double)radiusMeters {
+    return gaodemap::isPointInCircle(pointLat, pointLon, centerLat, centerLon, radiusMeters);
+}
+
++ (BOOL)isPointInPolygonWithPointLat:(double)pointLat
+                           pointLon:(double)pointLon
+                          latitudes:(NSArray<NSNumber *> *)latitudes
+                         longitudes:(NSArray<NSNumber *> *)longitudes {
+    if (latitudes.count < 3 || latitudes.count != longitudes.count) {
+        return NO;
+    }
+
+    std::vector<gaodemap::GeoPoint> polygon;
+    polygon.reserve(latitudes.count);
+
+    for (NSUInteger i = 0; i < latitudes.count; i++) {
+        polygon.push_back({latitudes[i].doubleValue, longitudes[i].doubleValue});
+    }
+
+    return gaodemap::isPointInPolygon(pointLat, pointLon, polygon);
+}
+
++ (double)calculatePolygonAreaWithLatitudes:(NSArray<NSNumber *> *)latitudes
+                                  longitudes:(NSArray<NSNumber *> *)longitudes {
+    if (latitudes.count < 3 || latitudes.count != longitudes.count) {
+        return 0.0;
+    }
+
+    std::vector<gaodemap::GeoPoint> polygon;
+    polygon.reserve(latitudes.count);
+
+    for (NSUInteger i = 0; i < latitudes.count; i++) {
+        polygon.push_back({latitudes[i].doubleValue, longitudes[i].doubleValue});
+    }
+
+    return gaodemap::calculatePolygonArea(polygon);
+}
+
++ (double)calculateRectangleAreaWithSouthWestLat:(double)swLat
+                                     southWestLon:(double)swLon
+                                    northEastLat:(double)neLat
+                                    northEastLon:(double)neLon {
+    return gaodemap::calculateRectangleArea(swLat, swLon, neLat, neLon);
+}
+
++ (double)calculateDistanceWithLat1:(double)lat1
+                               lon1:(double)lon1
+                               lat2:(double)lat2
+                               lon2:(double)lon2 {
+    return gaodemap::calculateDistance(lat1, lon1, lat2, lon2);
+}
+
++ (NSArray<NSNumber *> *)simplifyPolylineWithLatitudes:(NSArray<NSNumber *> *)latitudes
+                                           longitudes:(NSArray<NSNumber *> *)longitudes
+                                      toleranceMeters:(double)toleranceMeters {
+    if (latitudes.count == 0 || latitudes.count != longitudes.count) {
+        return @[];
+    }
+
+    std::vector<gaodemap::GeoPoint> points;
+    points.reserve(latitudes.count);
+
+    for (NSUInteger i = 0; i < latitudes.count; i++) {
+        points.push_back({latitudes[i].doubleValue, longitudes[i].doubleValue});
+    }
+
+    const auto simplified = gaodemap::simplifyPolyline(points, toleranceMeters);
+
+    NSMutableArray<NSNumber *> *result = [NSMutableArray arrayWithCapacity:simplified.size() * 2];
+    for (const auto &p : simplified) {
+        [result addObject:@(p.lat)];
+        [result addObject:@(p.lon)];
+    }
+
+    return result;
+}
+
++ (double)calculatePathLengthWithLatitudes:(NSArray<NSNumber *> *)latitudes
+                                longitudes:(NSArray<NSNumber *> *)longitudes {
+    if (latitudes.count != longitudes.count || latitudes.count < 2) {
+        return 0.0;
+    }
+    
+    std::vector<gaodemap::GeoPoint> points;
+    points.reserve(latitudes.count);
+    for (NSUInteger i = 0; i < latitudes.count; i++) {
+        points.push_back({[latitudes[i] doubleValue], [longitudes[i] doubleValue]});
+    }
+    
+    return gaodemap::calculatePathLength(points);
+}
+
++ (NSDictionary * _Nullable)getPointAtDistanceWithLatitudes:(NSArray<NSNumber *> *)latitudes
+                                               longitudes:(NSArray<NSNumber *> *)longitudes
+                                           distanceMeters:(double)distanceMeters {
+    if (latitudes.count != longitudes.count || latitudes.count < 2) {
+        return nil;
+    }
+    
+    std::vector<gaodemap::GeoPoint> points;
+    points.reserve(latitudes.count);
+    for (NSUInteger i = 0; i < latitudes.count; i++) {
+        points.push_back({[latitudes[i] doubleValue], [longitudes[i] doubleValue]});
+    }
+    
+    double outLat, outLon, outAngle;
+    if (gaodemap::getPointAtDistance(points, distanceMeters, &outLat, &outLon, &outAngle)) {
+        return @{
+            @"latitude": @(outLat),
+            @"longitude": @(outLon),
+            @"angle": @(outAngle)
+        };
+    }
+    
+    return nil;
+}
+
++ (NSDictionary * _Nullable)getNearestPointOnPathWithLatitudes:(NSArray<NSNumber *> *)latitudes
+                                                    longitudes:(NSArray<NSNumber *> *)longitudes
+                                                     targetLat:(double)targetLat
+                                                     targetLon:(double)targetLon {
+    if (latitudes.count != longitudes.count || latitudes.count < 2) {
+        return nil;
+    }
+    
+    std::vector<gaodemap::GeoPoint> points;
+    points.reserve(latitudes.count);
+    for (NSUInteger i = 0; i < latitudes.count; i++) {
+        points.push_back({[latitudes[i] doubleValue], [longitudes[i] doubleValue]});
+    }
+    
+    gaodemap::GeoPoint target = {targetLat, targetLon};
+    gaodemap::NearestPointResult result = gaodemap::getNearestPointOnPath(points, target);
+    
+    return @{
+        @"latitude": @(result.latitude),
+        @"longitude": @(result.longitude),
+        @"index": @(result.index),
+        @"distanceMeters": @(result.distanceMeters)
+    };
+}
+
++ (NSDictionary * _Nullable)calculateCentroidWithLatitudes:(NSArray<NSNumber *> *)latitudes
+                                               longitudes:(NSArray<NSNumber *> *)longitudes {
+    if (latitudes.count != longitudes.count || latitudes.count < 3) {
+        return nil;
+    }
+    
+    std::vector<gaodemap::GeoPoint> polygon;
+    polygon.reserve(latitudes.count);
+    for (NSUInteger i = 0; i < latitudes.count; i++) {
+        polygon.push_back({[latitudes[i] doubleValue], [longitudes[i] doubleValue]});
+    }
+    
+    gaodemap::GeoPoint centroid = gaodemap::calculateCentroid(polygon);
+    
+    return @{
+        @"latitude": @(centroid.lat),
+        @"longitude": @(centroid.lon)
+    };
+}
+
++ (NSDictionary * _Nullable)calculatePathBoundsWithLatitudes:(NSArray<NSNumber *> *)latitudes
+                                                longitudes:(NSArray<NSNumber *> *)longitudes {
+    if (latitudes.count != longitudes.count || latitudes.count == 0) {
+        return nil;
+    }
+    
+    std::vector<gaodemap::GeoPoint> points;
+    points.reserve(latitudes.count);
+    for (NSUInteger i = 0; i < latitudes.count; i++) {
+        points.push_back({[latitudes[i] doubleValue], [longitudes[i] doubleValue]});
+    }
+    
+    gaodemap::PathBounds bounds = gaodemap::calculatePathBounds(points);
+    
+    return @{
+        @"north": @(bounds.north),
+        @"south": @(bounds.south),
+        @"east": @(bounds.east),
+        @"west": @(bounds.west),
+        @"center": @{
+            @"latitude": @(bounds.centerLat),
+            @"longitude": @(bounds.centerLon)
+        }
+    };
+}
+
++ (NSString *)encodeGeoHashWithLat:(double)lat
+                               lon:(double)lon
+                         precision:(int)precision {
+    std::string geoHash = gaodemap::encodeGeoHash(lat, lon, precision);
+    return [NSString stringWithUTF8String:geoHash.c_str()];
+}
+
++ (uint32_t)parseColorWithString:(NSString *)colorString {
+    if (!colorString) return 0;
+    std::string colorStr = [colorString UTF8String];
+    return gaodemap::parseColor(colorStr);
+}
+
++ (CLLocationCoordinate2D)coordinateForMapPointWithX:(double)x y:(double)y {
+#if HAS_MAMAPKIT
+    MAMapPoint point;
+    point.x = x;
+    point.y = y;
+    return MACoordinateForMapPoint(point);
+#else
+    return CLLocationCoordinate2DMake(0, 0);
+#endif
+}
+
++ (NSArray<NSNumber *> *)parsePolyline:(NSString *)polylineStr {
+    if (!polylineStr || polylineStr.length == 0) {
+        return @[];
+    }
+
+    std::string cppPolylineStr([polylineStr UTF8String]);
+    const auto points = gaodemap::parsePolyline(cppPolylineStr);
+
+    NSMutableArray<NSNumber *> *result = [NSMutableArray arrayWithCapacity:points.size() * 2];
+    for (const auto &p : points) {
+        [result addObject:@(p.lat)];
+        [result addObject:@(p.lon)];
+    }
+
+    return result;
+}
+
+// --- 瓦片与坐标转换 ---
+
++ (NSDictionary *)latLngToTileWithLat:(double)lat lon:(double)lon zoom:(int)zoom {
+    gaodemap::TileResult result = gaodemap::latLngToTile(lat, lon, zoom);
+    return @{
+        @"x": @(result.x),
+        @"y": @(result.y),
+        @"z": @(result.z)
+    };
+}
+
++ (NSDictionary *)tileToLatLngWithX:(int)x y:(int)y zoom:(int)zoom {
+    gaodemap::GeoPoint result = gaodemap::tileToLatLng(x, y, zoom);
+    return @{
+        @"latitude": @(result.lat),
+        @"longitude": @(result.lon)
+    };
+}
+
++ (NSDictionary *)latLngToPixelWithLat:(double)lat lon:(double)lon zoom:(int)zoom {
+    gaodemap::PixelResult result = gaodemap::latLngToPixel(lat, lon, zoom);
+    return @{
+        @"x": @(result.x),
+        @"y": @(result.y)
+    };
+}
+
++ (NSDictionary *)pixelToLatLngWithX:(double)x y:(double)y zoom:(int)zoom {
+    gaodemap::GeoPoint result = gaodemap::pixelToLatLng(x, y, zoom);
+    return @{
+        @"latitude": @(result.lat),
+        @"longitude": @(result.lon)
+    };
+}
+
+// --- 批量地理围栏与热力图 ---
+
++ (int)findPointInPolygonsWithPointLat:(double)pointLat
+                              pointLon:(double)pointLon
+                              polygons:(NSArray<NSArray<NSDictionary *> *> *)polygons {
+    if (polygons.count == 0) return -1;
+
+    std::vector<std::vector<gaodemap::GeoPoint>> cppPolygons;
+    cppPolygons.reserve(polygons.count);
+
+    for (NSArray<NSDictionary *> *polygon in polygons) {
+        std::vector<gaodemap::GeoPoint> cppPolygon;
+        cppPolygon.reserve(polygon.count);
+        for (NSDictionary *point in polygon) {
+            cppPolygon.push_back({
+                [point[@"latitude"] doubleValue],
+                [point[@"longitude"] doubleValue]
+            });
+        }
+        cppPolygons.push_back(std::move(cppPolygon));
+    }
+
+    return gaodemap::findPointInPolygons(pointLat, pointLon, cppPolygons);
+}
+
++ (NSArray<NSDictionary *> *)generateHeatmapGridWithLatitudes:(NSArray<NSNumber *> *)latitudes
+                                                   longitudes:(NSArray<NSNumber *> *)longitudes
+                                                      weights:(NSArray<NSNumber *> *)weights
+                                              gridSizeMeters:(double)gridSizeMeters {
+    if (latitudes.count == 0 || latitudes.count != longitudes.count || latitudes.count != weights.count) {
+        return @[];
+    }
+
+    std::vector<gaodemap::HeatmapPoint> points;
+    points.reserve(latitudes.count);
+    for (NSUInteger i = 0; i < latitudes.count; i++) {
+        points.push_back({
+            [latitudes[i] doubleValue],
+            [longitudes[i] doubleValue],
+            [weights[i] doubleValue]
+        });
+    }
+
+    auto cells = gaodemap::generateHeatmapGrid(points, gridSizeMeters);
+    
+    NSMutableArray *result = [NSMutableArray arrayWithCapacity:cells.size()];
+    for (const auto &c : cells) {
+        [result addObject:@{
+            @"latitude": @(c.lat),
+            @"longitude": @(c.lon),
+            @"intensity": @(c.intensity)
+        }];
+    }
+    return result;
+}
+
+@end

package/ios/map/utils/ColorParser.swift

@@ -27,6 +27,17 @@ class ColorParser {
      * 解析字符串颜色值
      */
     private static func parseColorString(_ colorString: String) -> UIColor? {
+        // Try native parser first
+        let nativeColor = ClusterNative.parseColor(colorString: colorString)
+        if nativeColor != 0 {
+            // ARGB -> UIColor
+            let a = CGFloat((nativeColor >> 24) & 0xFF) / 255.0
+            let r = CGFloat((nativeColor >> 16) & 0xFF) / 255.0
+            let g = CGFloat((nativeColor >> 8) & 0xFF) / 255.0
+            let b = CGFloat(nativeColor & 0xFF) / 255.0
+            return UIColor(red: r, green: g, blue: b, alpha: a)
+        }
+
         let trimmedString = colorString.trimmingCharacters(in: .whitespacesAndNewlines)
         
         // 处理 rgba() 格式
@@ -97,7 +108,7 @@ class ColorParser {
      */
     private static func parseHexColor(_ hexString: String) -> UIColor? {
         var hex = hexString.trimmingCharacters(in: CharacterSet.alphanumerics.inverted)
-        var alpha: CGFloat = 1.0
+        let alpha: CGFloat = 1.0
         
         // 处理 #RGB 格式
         if hex.count == 3 {

package/ios/map/utils/CppBridging.mm

@@ -0,0 +1,13 @@
+#include <vector>
+#include <string>
+#include <cmath>
+#include <algorithm>
+#include <sstream>
+#include <map>
+
+// 直接包含 C++ 实现文件，强制编译
+// 这种方式规避了 CocoaPods 对外部源文件的处理问题
+#include "../cpp/ClusterEngine.cpp"
+#include "../cpp/GeometryEngine.cpp"
+#include "../cpp/ColorParser.cpp"
+#include "../cpp/QuadTree.cpp"

package/ios/map/utils/GeometryUtils.swift

@@ -0,0 +1,34 @@
+import CoreLocation
+
+/**
+ * 几何计算工具类 (iOS)
+ * 
+ * 桥接 ClusterNative (C++) 实现的几何计算功能
+ */
+public enum GeometryUtils {
+    
+    /**
+     * 轨迹抽稀 (RDP 算法)
+     * @param points 原始轨迹点
+     * @param tolerance 允许误差 (米)
+     * @return 简化后的轨迹点
+     */
+    public static func simplifyPolyline(_ points: [CLLocationCoordinate2D], tolerance: Double) -> [CLLocationCoordinate2D] {
+        if points.count < 3 || tolerance <= 0 {
+            return points
+        }
+        
+        let lats = points.map { NSNumber(value: $0.latitude) }
+        let lons = points.map { NSNumber(value: $0.longitude) }
+        
+        let result = ClusterNative.simplifyPolyline(latitudes: lats, longitudes: lons, tolerance: tolerance)
+        
+        var simplified: [CLLocationCoordinate2D] = []
+        for i in stride(from: 0, to: result.count, by: 2) {
+            if i + 1 < result.count {
+                simplified.append(CLLocationCoordinate2D(latitude: result[i].doubleValue, longitude: result[i+1].doubleValue))
+            }
+        }
+        return simplified
+    }
+}