expo-gaode-map-navigation 1.1.5-next.1 → 1.1.5-next.3

package/ios/map/cpp/GeometryEngine.hpp

@@ -0,0 +1,159 @@
+#pragma once
+
+#include <vector>
+#include <string>
+
+namespace gaodemap {
+
+struct GeoPoint {
+    double lat;
+    double lon;
+};
+
+double calculateDistance(double lat1, double lon1, double lat2, double lon2);
+bool isPointInCircle(double pointLat, double pointLon, double centerLat, double centerLon, double radiusMeters);
+bool isPointInPolygon(double pointLat, double pointLon, const std::vector<GeoPoint>& polygon);
+double calculatePolygonArea(const std::vector<GeoPoint>& polygon);
+double calculateRectangleArea(double swLat, double swLon, double neLat, double neLon);
+
+/**
+ * Ramer-Douglas-Peucker 轨迹抽稀算法
+ * @param points 原始轨迹点
+ * @param toleranceMeters 允许的误差（米），值越大点越少
+ * @return 简化后的轨迹点
+ */
+std::vector<GeoPoint> simplifyPolyline(const std::vector<GeoPoint>& points, double toleranceMeters);
+
+/**
+ * 计算路径总长度（米）
+ */
+double calculatePathLength(const std::vector<GeoPoint>& points);
+
+/**
+ * 获取路径上指定距离的点和方向
+ * @param points 路径点
+ * @param distanceMeters 距离起点的米数
+ * @param outLat 输出纬度
+ * @param outLon 输出经度
+ * @param outAngle 输出方向角度 (0-360)
+ * @return 是否成功找到点
+ */
+bool getPointAtDistance(const std::vector<GeoPoint>& points, double distanceMeters, double* outLat, double* outLon, double* outAngle);
+
+// Result structure for nearest point calculation
+struct NearestPointResult {
+    double latitude;
+    double longitude;
+    int index; // Index of the point in the path that starts the segment (or the point itself)
+    double distanceMeters;
+};
+
+// Find the nearest point on the path to a target point
+// Returns the nearest point on the polyline segments
+NearestPointResult getNearestPointOnPath(const std::vector<GeoPoint>& path, const GeoPoint& target);
+
+/**
+ * 计算多边形的质心
+ * @param polygon 多边形点集
+ * @return 质心坐标
+ */
+GeoPoint calculateCentroid(const std::vector<GeoPoint>& polygon);
+
+/**
+ * GeoHash 编码
+ * @param lat 纬度
+ * @param lon 经度
+ * @param precision 精度 (1-12)
+ * @return GeoHash 字符串
+ */
+std::string encodeGeoHash(double lat, double lon, int precision);
+
+/**
+ * 解析高德地图 API 返回的 Polyline 字符串
+ * 格式: "lng,lat;lng,lat;..."
+ * @param polylineStr 高德原始 polyline 字符串
+ * @return 解析后的点集
+ */
+std::vector<GeoPoint> parsePolyline(const std::string& polylineStr);
+
+struct PathBounds {
+    double north;
+    double south;
+    double east;
+    double west;
+    double centerLat;
+    double centerLon;
+};
+
+/**
+ * 计算路径的边界和中心点
+ * @param points 路径点
+ * @return 边界信息
+ */
+PathBounds calculatePathBounds(const std::vector<GeoPoint>& points);
+
+// --- 瓦片与坐标转换 ---
+
+struct TileResult {
+    int x;
+    int y;
+    int z;
+};
+
+struct PixelResult {
+    double x;
+    double y;
+};
+
+/**
+ * 经纬度转瓦片坐标
+ */
+TileResult latLngToTile(double lat, double lon, int zoom);
+
+/**
+ * 瓦片坐标转经纬度
+ */
+GeoPoint tileToLatLng(int x, int y, int zoom);
+
+/**
+ * 经纬度转像素坐标
+ */
+PixelResult latLngToPixel(double lat, double lon, int zoom);
+
+/**
+ * 像素坐标转经纬度
+ */
+GeoPoint pixelToLatLng(double x, double y, int zoom);
+
+// --- 批量地理围栏与热力图 ---
+
+/**
+ * 批量判断点是否在多个多边形内 (优化版)
+ * @param pointLat 点纬度
+ * @param pointLon 点经度
+ * @param polygons 多个多边形的集合
+ * @return 所在的第一个多边形的索引，若不在任何多边形内返回 -1
+ */
+int findPointInPolygons(double pointLat, double pointLon, const std::vector<std::vector<GeoPoint>>& polygons);
+
+struct HeatmapPoint {
+    double lat;
+    double lon;
+    double weight;
+};
+
+struct HeatmapGridCell {
+    double lat;
+    double lon;
+    double intensity;
+};
+
+/**
+ * 生成热力图网格数据
+ * @param points 原始点集
+ * @param gridSizeMeters 网格大小（米）
+ * @return 网格中心点及其强度
+ */
+std::vector<HeatmapGridCell> generateHeatmapGrid(const std::vector<HeatmapPoint>& points, double gridSizeMeters);
+
+} // namespace gaodemap

package/ios/map/cpp/QuadTree.cpp

@@ -0,0 +1,92 @@
+#include "QuadTree.hpp"
+
+namespace gaodemap {
+
+bool BoundingBox::contains(double lat, double lon) const {
+    return lat >= minLat && lat <= maxLat && lon >= minLon && lon <= maxLon;
+}
+
+bool BoundingBox::intersects(const BoundingBox& other) const {
+    return !(other.minLat > maxLat || other.maxLat < minLat || 
+             other.minLon > maxLon || other.maxLon < minLon);
+}
+
+QuadTree::QuadTree(const BoundingBox& bounds, int capacity)
+    : bounds(bounds), capacity(capacity) {}
+
+bool QuadTree::insert(const ClusterPoint& point) {
+    if (!bounds.contains(point.lat, point.lon)) {
+        return false;
+    }
+
+    if (points.size() < capacity && !subdivided) {
+        points.push_back(point);
+        return true;
+    }
+
+    if (!subdivided) {
+        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;
+
+    // Point might be exactly on the boundary of the QuadTree but not accepted by children?
+    // In our logic, children cover the full range of the parent.
+    // However, floating point precision might be tricky.
+    // As a fallback, if we are subdivided but children didn't take it (rare), 
+    // we can keep it here or force insert.
+    // Given the subdivision logic, it should cover all space.
+    return false;
+}
+
+void QuadTree::subdivide() {
+    double midLat = (bounds.minLat + bounds.maxLat) / 2.0;
+    double midLon = (bounds.minLon + bounds.maxLon) / 2.0;
+
+    northWest = std::make_unique<QuadTree>(BoundingBox{midLat, bounds.minLon, bounds.maxLat, midLon}, capacity);
+    northEast = std::make_unique<QuadTree>(BoundingBox{midLat, midLon, bounds.maxLat, bounds.maxLon}, capacity);
+    southWest = std::make_unique<QuadTree>(BoundingBox{bounds.minLat, bounds.minLon, midLat, midLon}, capacity);
+    southEast = std::make_unique<QuadTree>(BoundingBox{bounds.minLat, midLon, midLat, bounds.maxLon}, capacity);
+
+    subdivided = true;
+    
+    // Redistribute existing points
+    for (const auto& p : points) {
+        northWest->insert(p) || northEast->insert(p) || 
+        southWest->insert(p) || southEast->insert(p);
+    }
+    points.clear();
+}
+
+void QuadTree::query(const BoundingBox& range, std::vector<ClusterPoint>& found) const {
+    if (!bounds.intersects(range)) {
+        return;
+    }
+
+    for (const auto& p : points) {
+        if (range.contains(p.lat, p.lon)) {
+            found.push_back(p);
+        }
+    }
+
+    if (subdivided) {
+        northWest->query(range, found);
+        northEast->query(range, found);
+        southWest->query(range, found);
+        southEast->query(range, found);
+    }
+}
+
+void QuadTree::clear() {
+    points.clear();
+    northWest.reset();
+    northEast.reset();
+    southWest.reset();
+    southEast.reset();
+    subdivided = false;
+}
+
+}

package/ios/map/cpp/QuadTree.hpp

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <vector>
+#include <memory>
+#include "ClusterEngine.hpp"
+
+namespace gaodemap {
+
+struct BoundingBox {
+    double minLat;
+    double minLon;
+    double maxLat;
+    double maxLon;
+
+    bool contains(double lat, double lon) const;
+    bool intersects(const BoundingBox& other) const;
+};
+
+class QuadTree {
+public:
+    QuadTree(const BoundingBox& bounds, int capacity = 20);
+    ~QuadTree() = default;
+
+    bool insert(const ClusterPoint& point);
+    void query(const BoundingBox& range, std::vector<ClusterPoint>& found) const;
+    void clear();
+
+private:
+    BoundingBox bounds;
+    int capacity;
+    std::vector<ClusterPoint> points;
+    bool subdivided = false;
+
+    std::unique_ptr<QuadTree> northWest;
+    std::unique_ptr<QuadTree> northEast;
+    std::unique_ptr<QuadTree> southWest;
+    std::unique_ptr<QuadTree> southEast;
+
+    void subdivide();
+};
+
+}

package/ios/map/cpp/README.md

@@ -0,0 +1,55 @@
+# C++ 共享核心库 (Shared Core)
+
+该目录包含了 `expo-gaode-map` 跨平台核心逻辑的 C++ 实现。这些代码被 Android 和 iOS 平台共享，以确保计算逻辑的一致性并提升高性能计算场景（如点聚合、几何计算）的处理速度。
+
+## 模块说明
+
+### 1. GeometryEngine (几何引擎)
+[GeometryEngine.hpp](file:///Users/wangqiang/Desktop/expo-gaode-map/packages/core/shared/cpp/GeometryEngine.hpp)
+提供地理空间相关的数学计算：
+- **距离计算**: 基于 Haversine 公式计算经纬度点之间的球面距离。
+- **点位判断**: 判断点是否在多边形 (Point-in-Polygon) 或圆形内。
+- **面积计算**: 计算多边形或矩形的地理面积。
+- **轨迹处理**:
+    - **抽稀算法**: 实现 Ramer-Douglas-Peucker 算法，用于简化复杂的折线轨迹。
+    - **路径长度**: 计算折线段的总长度。
+    - **路径插值**: 获取路径上指定距离的点坐标及其切线方向。
+- **GeoHash**: 支持经纬度到 GeoHash 字符串的编码。
+- **质心计算**: 计算多边形的几何质心。
+
+### 2. ClusterEngine (点聚合引擎)
+[ClusterEngine.hpp](file:///Users/wangqiang/Desktop/expo-gaode-map/packages/core/shared/cpp/ClusterEngine.hpp)
+负责大规模地图标记点的聚合计算：
+- 使用 **QuadTree** 进行空间索引优化。
+- 支持基于半径的聚合逻辑。
+- 高性能处理，适用于数千甚至数万个点的实时聚合。
+
+### 3. QuadTree (四叉树)
+[QuadTree.hpp](file:///Users/wangqiang/Desktop/expo-gaode-map/packages/core/shared/cpp/QuadTree.hpp)
+为地理坐标提供高效的空间索引结构：
+- **空间分割**: 自动将空间划分为四个象限。
+- **范围查询**: 快速检索指定矩形区域内的所有点位。
+- 被 `ClusterEngine` 用于加速近邻点搜索。
+
+### 4. ColorParser (颜色解析器)
+[ColorParser.hpp](file:///Users/wangqiang/Desktop/expo-gaode-map/packages/core/shared/cpp/ColorParser.hpp)
+跨平台的颜色字符串解析工具：
+- 支持 **Hex** 格式 (如 `#RRGGBB`, `#AARRGGBB`, `#RGB`)。
+- 支持 **RGB/RGBA** 函数格式 (如 `rgba(255, 0, 0, 0.5)`)。
+- 支持 **命名颜色** (如 `red`, `blue`, `transparent`)。
+- 统一输出为 `0xAARRGGBB` 格式的 32 位整数。
+
+## 测试
+
+测试用例位于 `tests/` 目录。
+
+### 运行测试
+在 macOS/Linux 环境下，可以通过以下命令运行 C++ 单元测试：
+
+```bash
+cd tests
+chmod +x run.sh
+./run.sh
+```
+
+该脚本会使用 `clang++` 编译源代码并运行生成的测试二进制文件，验证各核心模块的逻辑准确性。

package/ios/map/cpp/tests/benchmark_js.js

@@ -0,0 +1,41 @@
+
+const parsePolylineJS = (polylineStr) => {
+  if (!polylineStr || typeof polylineStr !== 'string') return [];
+  try {
+    const points = polylineStr.split(';');
+    return points.map(point => {
+      const [lng, lat] = point.split(',').map(Number);
+      return { latitude: lat, longitude: lng };
+    }).filter(p => !isNaN(p.latitude) && !isNaN(p.longitude));
+  } catch (error) {
+    return [];
+  }
+};
+
+const benchmark = () => {
+  console.log("Running JS benchmark (10,000 points)...");
+  
+  // 生成 10,000 个点的测试字符串
+  let largePoly = "";
+  for (let i = 0; i < 10000; i++) {
+    largePoly += "116.4074,39.9042;";
+  }
+
+  const start = Date.now();
+  
+  // 运行 100 次以获得更准确的平均值
+  for (let i = 0; i < 100; i++) {
+    const result = parsePolylineJS(largePoly);
+    if (result.length !== 10000) {
+      console.error(`Error: Expected 10000 points, got ${result.length}`);
+    }
+  }
+  
+  const end = Date.now();
+  const totalTime = end - start;
+  
+  console.log(`Total time for 100 iterations: ${totalTime} ms`);
+  console.log(`Average time per parse (10,000 points): ${totalTime / 100} ms`);
+};
+
+benchmark();

package/ios/map/cpp/tests/run.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+set -e
+
+# Compile the test
+clang++ -std=c++17 \
+    test_main.cpp \
+    ../GeometryEngine.cpp \
+    ../ColorParser.cpp \
+    ../ClusterEngine.cpp \
+    ../QuadTree.cpp \
+    -o test_runner
+
+# Run the test
+./test_runner
+
+# Clean up
+rm test_runner

package/ios/map/cpp/tests/test_main.cpp

@@ -0,0 +1,276 @@
+#include <iostream>
+#include <vector>
+#include <cmath>
+#include <cassert>
+#include <iomanip>
+#include <algorithm>
+#include <chrono>
+
+#include "../GeometryEngine.hpp"
+#include "../ColorParser.hpp"
+#include "../QuadTree.hpp"
+#include "../ClusterEngine.hpp"
+
+using namespace gaodemap;
+
+// Helper to compare doubles with epsilon
+bool approxEqual(double a, double b, double epsilon = 1e-6) {
+    return std::abs(a - b) < epsilon;
+}
+
+void testDistance() {
+    std::cout << "Running testDistance..." << std::endl;
+    // Beijing
+    double lat1 = 39.9042;
+    double lon1 = 116.4074;
+    // ~1km East
+    double lat2 = 39.9042;
+    double lon2 = 116.4191; 
+
+    double dist = calculateDistance(lat1, lon1, lat2, lon2);
+    std::cout << "Distance: " << dist << " meters" << std::endl;
+    
+    // Expect roughly 1000m. 
+    assert(dist > 990 && dist < 1010);
+    
+    // Same point should be 0
+    assert(approxEqual(calculateDistance(lat1, lon1, lat1, lon1), 0.0));
+    
+    std::cout << "PASSED" << std::endl;
+}
+
+void testColorParser() {
+    std::cout << "Running testColorParser..." << std::endl;
+    
+    // Red
+    assert(parseColor("red") == 0xFFFF0000);
+    assert(parseColor("#FF0000") == 0xFFFF0000);
+    assert(parseColor("#ff0000") == 0xFFFF0000);
+    
+    // Blue
+    assert(parseColor("blue") == 0xFF0000FF);
+    
+    // RGB
+    assert(parseColor("rgb(0, 255, 0)") == 0xFF00FF00);
+    
+    // RGBA
+    uint32_t rgba = parseColor("rgba(255, 0, 0, 0.5)");
+    assert((rgba & 0x00FFFFFF) == 0x00FF0000); 
+    uint32_t alpha = (rgba >> 24) & 0xFF;
+    assert(alpha >= 127 && alpha <= 128);
+
+    // Invalid colors
+    assert(parseColor("notacolor") == 0); 
+    assert(parseColor("#XYZ") == 0);
+    assert(parseColor("") == 0);
+
+    std::cout << "PASSED" << std::endl;
+}
+
+void testPointInPolygon() {
+    std::cout << "Running testPointInPolygon..." << std::endl;
+    
+    // Simple square (0,0) to (1,1)
+    std::vector<GeoPoint> polygon = {
+        {0, 0},
+        {1, 0},
+        {1, 1},
+        {0, 1}
+    };
+    
+    assert(isPointInPolygon(0.5, 0.5, polygon) == true);
+    assert(isPointInPolygon(1.5, 0.5, polygon) == false);
+    assert(isPointInPolygon(-0.1, 0.5, polygon) == false);
+    
+    // Triangle
+    std::vector<GeoPoint> triangle = {
+        {0, 0},
+        {2, 0},
+        {1, 2}
+    };
+    assert(isPointInPolygon(1, 1, triangle) == true);
+    assert(isPointInPolygon(1, 2.1, triangle) == false);
+
+    std::cout << "PASSED" << std::endl;
+}
+
+void testGeometryEngineExtended() {
+    std::cout << "Running testGeometryEngineExtended..." << std::endl;
+
+    // 1. testPointInCircle
+    assert(isPointInCircle(39.9, 116.4, 39.9, 116.4, 100) == true);
+    assert(isPointInCircle(40.0, 116.4, 39.9, 116.4, 1000) == false); // ~11km diff
+
+    // 2. testArea
+    std::vector<GeoPoint> rect = {
+        {0, 0}, {0, 1}, {1, 1}, {1, 0}
+    };
+    double area = calculatePolygonArea(rect);
+    std::cout << "Polygon Area: " << area << " m^2" << std::endl;
+    assert(area > 0);
+    
+    double rectArea = calculateRectangleArea(0, 0, 1, 1);
+    assert(approxEqual(area, rectArea));
+
+    // 3. simplifyPolyline
+    std::vector<GeoPoint> line = {
+        {0, 0}, {0.1, 0.0001}, {0.2, 0}, {0.3, 0.0001}, {0.4, 0}
+    };
+    auto simplified = simplifyPolyline(line, 1000); // 1km tolerance
+    assert(simplified.size() < line.size());
+    assert(simplified.front().lat == 0);
+    assert(simplified.back().lat == 0.4);
+
+    // 4. calculatePathLength
+    double length = calculatePathLength({{0,0}, {0,1}});
+    assert(length > 111000 && length < 112000); // 1 degree lat is ~111km
+
+    // 5. getPointAtDistance
+    double outLat, outLon, outAngle;
+    bool found = getPointAtDistance({{0,0}, {1,0}}, 55500, &outLat, &outLon, &outAngle);
+    assert(found);
+    assert(outLat > 0.4 && outLat < 0.6);
+    assert(approxEqual(outLon, 0.0));
+
+    // 6. getNearestPointOnPath
+    std::vector<GeoPoint> path = {{0,0}, {2,0}};
+    GeoPoint target = {1, 1};
+    auto nearest = getNearestPointOnPath(path, target);
+    assert(approxEqual(nearest.latitude, 1.0));
+    assert(approxEqual(nearest.longitude, 0.0));
+    assert(nearest.index == 0);
+
+    // 7. calculateCentroid
+    std::vector<GeoPoint> square = {{0,0}, {1,0}, {1,1}, {0,1}};
+    auto centroid = calculateCentroid(square);
+    assert(approxEqual(centroid.lat, 0.5));
+    assert(approxEqual(centroid.lon, 0.5));
+
+    // 8. encodeGeoHash
+    std::string hash = encodeGeoHash(39.9042, 116.4074, 5);
+    assert(hash.length() == 5);
+    assert(hash == "wx4g0"); // Common geohash for Beijing center
+
+    // 9. parsePolyline
+    std::string polyStr = "116.4074,39.9042;116.4191,39.9042";
+    auto parsed = parsePolyline(polyStr);
+    assert(parsed.size() == 2);
+    assert(approxEqual(parsed[0].lat, 39.9042));
+    assert(approxEqual(parsed[0].lon, 116.4074));
+    assert(approxEqual(parsed[1].lat, 39.9042));
+    assert(approxEqual(parsed[1].lon, 116.4191));
+
+    // Test empty
+    assert(parsePolyline("").empty());
+    // Test invalid
+    assert(parsePolyline("invalid").empty());
+    // Test trailing semicolon
+    assert(parsePolyline("116.4074,39.9042;").size() == 1);
+
+    std::cout << "PASSED" << std::endl;
+}
+
+void benchmarkParsePolyline() {
+    std::cout << "Running benchmarkParsePolyline (10,000 points)..." << std::endl;
+    
+    // 生成 10,000 个点的测试字符串
+    std::string largePoly;
+    largePoly.reserve(300000); // 预分配约 300KB
+    for (int i = 0; i < 10000; ++i) {
+        largePoly += "116.4074,39.9042;";
+    }
+
+    auto start = std::chrono::high_resolution_clock::now();
+    
+    // 运行 100 次以获得更准确的平均值
+    for (int i = 0; i < 100; ++i) {
+        auto result = parsePolyline(largePoly);
+        if (result.size() != 10000) {
+            std::cerr << "Error: Expected 10000 points, got " << result.size() << std::endl;
+        }
+    }
+    
+    auto end = std::chrono::high_resolution_clock::now();
+    std::chrono::duration<double, std::milli> duration = end - start;
+    
+    std::cout << "Total time for 100 iterations: " << duration.count() << " ms" << std::endl;
+    std::cout << "Average time per parse (10,000 points): " << duration.count() / 100.0 << " ms" << std::endl;
+    std::cout << "PASSED" << std::endl;
+}
+
+void testQuadTree() {
+    std::cout << "Running testQuadTree..." << std::endl;
+
+    BoundingBox bounds{0, 0, 10, 10};
+    QuadTree tree(bounds, 2); // Small capacity to force subdivision
+
+    tree.insert({1, 1, 1});
+    tree.insert({2, 2, 2});
+    tree.insert({8, 8, 3});
+    tree.insert({9, 9, 4});
+
+    std::vector<ClusterPoint> found;
+    tree.query({0, 0, 3, 3}, found);
+    assert(found.size() == 2);
+    
+    found.clear();
+    tree.query({7, 7, 10, 10}, found);
+    assert(found.size() == 2);
+
+    found.clear();
+    tree.query({4, 4, 6, 6}, found);
+    assert(found.size() == 0);
+
+    std::cout << "PASSED" << std::endl;
+}
+
+void testClusterEngine() {
+    std::cout << "Running testClusterEngine..." << std::endl;
+
+    std::vector<ClusterPoint> points = {
+        {39.9042, 116.4074, 0}, // Beijing 1
+        {39.9043, 116.4075, 1}, // Beijing 2 (very close)
+        {31.2304, 121.4737, 2}, // Shanghai 1
+        {31.2305, 121.4738, 3}  // Shanghai 2 (very close)
+    };
+
+    // Cluster with 1km radius
+    auto clusters = clusterPoints(points, 1000);
+    
+    // Should have 2 clusters
+    assert(clusters.size() == 2);
+    
+    for (const auto& c : clusters) {
+        assert(c.indices.size() == 2);
+    }
+
+    // Cluster with 1m radius (should be 4 clusters)
+    auto clustersSmall = clusterPoints(points, 1);
+    assert(clustersSmall.size() == 4);
+
+    std::cout << "PASSED" << std::endl;
+}
+
+int main() {
+    std::cout << "========================================" << std::endl;
+    std::cout << "STARTING C++ SHARED CODE TESTS" << std::endl;
+    std::cout << "========================================" << std::endl;
+
+    try {
+        testDistance();
+        testColorParser();
+        testPointInPolygon();
+        testGeometryEngineExtended();
+        benchmarkParsePolyline();
+        testQuadTree();
+        testClusterEngine();
+        
+        std::cout << "========================================" << std::endl;
+        std::cout << "ALL TESTS PASSED SUCCESSFULLY" << std::endl;
+        std::cout << "========================================" << std::endl;
+        return 0;
+    } catch (const std::exception& e) {
+        std::cerr << "TEST FAILED: " << e.what() << std::endl;
+        return 1;
+    }
+}