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

package/android/src/main/cpp/CMakeLists.txt

@@ -1,11 +1,11 @@
 cmake_minimum_required(VERSION 3.22.1)
 
-project(gaodecluster)
+project(gaodecluster_nav)
 
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
-add_library(gaodecluster SHARED
+add_library(gaodecluster_nav SHARED
     cluster_jni.cpp
     ../../../../shared/cpp/ClusterEngine.cpp
     ../../../../shared/cpp/QuadTree.cpp
@@ -13,12 +13,12 @@ add_library(gaodecluster SHARED
     ../../../../shared/cpp/ColorParser.cpp
 )
 
-target_include_directories(gaodecluster PRIVATE
+target_include_directories(gaodecluster_nav PRIVATE
     ../../../../shared/cpp
 )
 
 find_library(log-lib log)
 
-target_link_libraries(gaodecluster
+target_link_libraries(gaodecluster_nav
     ${log-lib}
 )

package/android/src/main/java/expo/modules/gaodemap/map/utils/ClusterNative.kt

@@ -2,7 +2,7 @@ package expo.modules.gaodemap.map.utils
 
 object ClusterNative {
     init {
-        System.loadLibrary("gaodecluster")
+        System.loadLibrary("gaodecluster_nav")
     }
 
     external fun clusterPoints(

package/android/src/main/java/expo/modules/gaodemap/map/utils/ColorParser.kt

@@ -6,7 +6,7 @@ import androidx.core.graphics.toColorInt
 object ColorParser {
     init {
         try {
-            System.loadLibrary("gaodecluster")
+            System.loadLibrary("gaodecluster_nav")
         } catch (_: Throwable) {
             // Ignore if already loaded
         }

package/android/src/main/java/expo/modules/gaodemap/map/utils/GeometryUtils.kt

@@ -12,7 +12,7 @@ import kotlin.math.*
 object GeometryUtils {
 
     init {
-        System.loadLibrary("gaodecluster")
+        System.loadLibrary("gaodecluster_nav")
     }
 
     private external fun nativeIsPointInCircle(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-gaode-map-navigation",
-  "version": "1.1.5-next.3",
+  "version": "1.1.5-next.4",
   "description": "高德地图导航功能模块 - 路径规划、导航引导，独立版本包含完整地图功能",
   "author": "<TomWq> (https://github.com/TomWq)",
   "repository": "https://github.com/TomWq/expo-gaode-map",
@@ -36,6 +36,7 @@
     "build",
     "android",
     "ios",
+    "shared",
     "app.plugin.js",
     "expo-module.config.json",
     "plugin/build"

package/shared/cpp/ClusterEngine.cpp

@@ -0,0 +1,110 @@
+#include "ClusterEngine.hpp"
+#include "QuadTree.hpp"
+#include <cmath>
+#include <algorithm>
+
+namespace gaodemap {
+
+// Removed duplicate toRadians definition, using inline or shared utility in future
+// For now, let's keep it static but rename to avoid conflict in unity build
+static inline double cluster_toRadians(double degrees) {
+    return degrees * 0.017453292519943295;
+}
+
+static double haversineMeters(const ClusterPoint& a, const ClusterPoint& b) {
+    const double lat1 = cluster_toRadians(a.lat);
+    const double lat2 = cluster_toRadians(b.lat);
+    const double dLat = lat2 - lat1;
+    const double dLon = cluster_toRadians(b.lon - a.lon);
+
+    const double sinHalfLat = std::sin(dLat * 0.5);
+    const double sinHalfLon = std::sin(dLon * 0.5);
+
+    const double h = sinHalfLat * sinHalfLat + std::cos(lat1) * std::cos(lat2) * sinHalfLon * sinHalfLon;
+    const double c = 2.0 * std::atan2(std::sqrt(h), std::sqrt(1.0 - h));
+
+    return 6371000.0 * c;
+}
+
+std::vector<ClusterOutput> clusterPoints(const std::vector<ClusterPoint>& points, double radiusMeters) {
+    std::vector<ClusterOutput> clusters;
+
+    if (points.empty() || radiusMeters <= 0.0) {
+        return clusters;
+    }
+
+    // 1. Build QuadTree
+    // Determine bounds
+    double minLat = 90.0, maxLat = -90.0, minLon = 180.0, maxLon = -180.0;
+    int maxIndex = -1;
+    
+    for (const auto& p : points) {
+        if (p.lat < minLat) minLat = p.lat;
+        if (p.lat > maxLat) maxLat = p.lat;
+        if (p.lon < minLon) minLon = p.lon;
+        if (p.lon > maxLon) maxLon = p.lon;
+        if (p.index > maxIndex) maxIndex = p.index;
+    }
+    
+    // Add some buffer
+    BoundingBox worldBounds{minLat - 1.0, minLon - 1.0, maxLat + 1.0, maxLon + 1.0};
+    QuadTree tree(worldBounds);
+    
+    for (const auto& p : points) {
+        tree.insert(p);
+    }
+
+    // 2. Cluster
+    // Use maxIndex to size the visited array correctly.
+    // If points is empty, maxIndex is -1, but we checked empty above.
+    // Ensure vector size is at least maxIndex + 1
+    std::vector<bool> globalVisited((maxIndex >= 0 ? maxIndex + 1 : 0), false);
+    
+    // Approximate degrees for radius (very rough, improves performance)
+    // 1 degree lat ~= 111km. 
+    double latDegree = radiusMeters / 111000.0;
+    
+    for (const auto& p : points) {
+        if (p.index < 0 || p.index >= globalVisited.size()) continue; // Safety check
+        if (globalVisited[p.index]) continue;
+
+        ClusterOutput cluster;
+        cluster.centerIndex = p.index;
+        cluster.indices.push_back(p.index);
+        globalVisited[p.index] = true;
+
+        // Query QuadTree
+        // Adjust lonDegree based on current latitude
+        // cos can be 0 at poles, handle it
+        double cosLat = std::cos(cluster_toRadians(p.lat));
+        double lonDegree;
+        if (std::abs(cosLat) < 0.00001) {
+             lonDegree = 360.0; // At poles, everything is close in longitude
+        } else {
+             lonDegree = radiusMeters / (111000.0 * std::abs(cosLat));
+        }
+        
+        // Bounding box for query
+        BoundingBox range{p.lat - latDegree, p.lon - lonDegree, p.lat + latDegree, p.lon + lonDegree};
+        
+        std::vector<ClusterPoint> neighbors;
+        tree.query(range, neighbors);
+
+        for (const auto& neighbor : neighbors) {
+            if (neighbor.index < 0 || neighbor.index >= globalVisited.size()) continue;
+            if (globalVisited[neighbor.index]) continue;
+            
+            // Precise check
+            if (haversineMeters(p, neighbor) <= radiusMeters) {
+                cluster.indices.push_back(neighbor.index);
+                globalVisited[neighbor.index] = true;
+            }
+        }
+        
+        clusters.push_back(std::move(cluster));
+    }
+
+    return clusters;
+}
+
+}

package/shared/cpp/ClusterEngine.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <vector>
+
+namespace gaodemap {
+
+struct ClusterPoint {
+    double lat;
+    double lon;
+    int index;
+};
+
+struct ClusterOutput {
+    int centerIndex;
+    std::vector<int> indices;
+};
+
+std::vector<ClusterOutput> clusterPoints(const std::vector<ClusterPoint>& points, double radiusMeters);
+
+}

package/shared/cpp/ColorParser.cpp

@@ -0,0 +1,135 @@
+#include "ColorParser.hpp"
+#include <algorithm>
+#include <sstream>
+#include <vector>
+#include <map>
+#include <cmath>
+
+namespace gaodemap {
+
+static uint32_t argb(uint8_t a, uint8_t r, uint8_t g, uint8_t b) {
+    return (static_cast<uint32_t>(a) << 24) |
+           (static_cast<uint32_t>(r) << 16) |
+           (static_cast<uint32_t>(g) << 8) |
+           static_cast<uint32_t>(b);
+}
+
+static uint32_t parseHex(const std::string& hexStr) {
+    std::string cleanHex = hexStr;
+    if (cleanHex.empty()) return 0;
+    if (cleanHex[0] == '#') {
+        cleanHex = cleanHex.substr(1);
+    }
+
+    uint32_t val = 0;
+    try {
+        val = static_cast<uint32_t>(std::stoul(cleanHex, nullptr, 16));
+    } catch (...) {
+        return 0;
+    }
+
+    if (cleanHex.length() == 6) {
+        // RRGGBB -> 0xFFRRGGBB
+        return 0xFF000000 | val;
+    } else if (cleanHex.length() == 8) {
+        // AARRGGBB -> AARRGGBB (Android style)
+        // Wait, web usually uses #RRGGBBAA.
+        // Android Color.parseColor("#RRGGBB") or "#AARRGGBB".
+        // Let's assume Android style #AARRGGBB for consistency with existing Kotlin code.
+        return val;
+    } else if (cleanHex.length() == 3) {
+        // RGB -> RRGGBB
+        uint32_t r = (val >> 8) & 0xF;
+        uint32_t g = (val >> 4) & 0xF;
+        uint32_t b = val & 0xF;
+        return 0xFF000000 | (r << 20) | (r << 16) | (g << 12) | (g << 8) | (b << 4) | b;
+    } else if (cleanHex.length() == 4) {
+        // ARGB -> AARRGGBB
+        uint32_t a = (val >> 12) & 0xF;
+        uint32_t r = (val >> 8) & 0xF;
+        uint32_t g = (val >> 4) & 0xF;
+        uint32_t b = val & 0xF;
+        return (a << 28) | (a << 24) | (r << 20) | (r << 16) | (g << 12) | (g << 8) | (b << 4) | b;
+    }
+    
+    return 0;
+}
+
+static uint32_t parseRgba(const std::string& str) {
+    // rgba(r, g, b, a) or rgb(r, g, b)
+    bool hasAlpha = str.find("rgba") == 0;
+    size_t start = str.find('(');
+    size_t end = str.find(')');
+    if (start == std::string::npos || end == std::string::npos) return 0;
+
+    std::string content = str.substr(start + 1, end - start - 1);
+    std::stringstream ss(content);
+    std::string segment;
+    std::vector<std::string> parts;
+    
+    while (std::getline(ss, segment, ',')) {
+        parts.push_back(segment);
+    }
+
+    if (parts.size() < 3) return 0;
+
+    try {
+        int r = std::stoi(parts[0]);
+        int g = std::stoi(parts[1]);
+        int b = std::stoi(parts[2]);
+        int a = 255;
+
+        if (hasAlpha && parts.size() >= 4) {
+            float alphaFloat = std::stof(parts[3]);
+            a = static_cast<int>(alphaFloat * 255.0f);
+        }
+
+        return argb(
+            static_cast<uint8_t>(std::max(0, std::min(255, a))),
+            static_cast<uint8_t>(std::max(0, std::min(255, r))),
+            static_cast<uint8_t>(std::max(0, std::min(255, g))),
+            static_cast<uint8_t>(std::max(0, std::min(255, b)))
+        );
+    } catch (...) {
+        return 0;
+    }
+}
+
+static const std::map<std::string, uint32_t> NAMED_COLORS = {
+    {"red", 0xFFFF0000},
+    {"blue", 0xFF0000FF},
+    {"green", 0xFF00FF00},
+    {"yellow", 0xFFFFFF00},
+    {"black", 0xFF000000},
+    {"white", 0xFFFFFFFF},
+    {"gray", 0xFF888888},
+    {"grey", 0xFF888888},
+    {"cyan", 0xFF00FFFF},
+    {"magenta", 0xFFFF00FF},
+    {"transparent", 0x00000000}
+};
+
+uint32_t parseColor(const std::string& colorString) {
+    std::string str = colorString;
+    // Remove whitespace
+    str.erase(std::remove_if(str.begin(), str.end(), ::isspace), str.end());
+    // Lowercase for named colors check
+    std::string lowerStr = str;
+    std::transform(lowerStr.begin(), lowerStr.end(), lowerStr.begin(), ::tolower);
+
+    if (NAMED_COLORS.count(lowerStr)) {
+        return NAMED_COLORS.at(lowerStr);
+    }
+
+    if (lowerStr.find("rgb") == 0) {
+        return parseRgba(str); // pass original str with potential spaces if needed, but we removed them
+    }
+
+    if (lowerStr.find("#") == 0 || std::all_of(lowerStr.begin(), lowerStr.end(), ::isxdigit)) {
+        return parseHex(str);
+    }
+
+    return 0; // Default black -> Default failure (0)
+}
+
+}

package/shared/cpp/ColorParser.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <string>
+#include <cstdint>
+
+namespace gaodemap {
+
+// Returns color as ARGB integer (0xAARRGGBB)
+// Returns 0 (transparent/black) if parsing fails, but 0 is also valid (transparent).
+// Maybe return a bool success? Or default to Black (0xFF000000) or Transparent (0x00000000).
+// Android defaults to Black in existing code.
+uint32_t parseColor(const std::string& colorString);
+
+}

package/shared/cpp/GeometryEngine.cpp

@@ -0,0 +1,574 @@
+#include "GeometryEngine.hpp"
+
+#include <cmath>
+#include <map>
+#include <algorithm>
+
+namespace gaodemap {
+
+static constexpr double kEarthRadiusMeters = 6371000.0;
+static constexpr double kPi = 3.14159265358979323846;
+static constexpr double kDegreesToRadians = kPi / 180.0;
+static constexpr double kRadiansToDegrees = 180.0 / kPi;
+
+static inline double geo_toRadians(double degrees) {
+    return degrees * kDegreesToRadians;
+}
+
+static inline double geo_toDegrees(double radians) {
+    return radians * kRadiansToDegrees;
+}
+
+double calculateDistance(double lat1, double lon1, double lat2, double lon2) {
+    const double radLat1 = geo_toRadians(lat1);
+    const double radLat2 = geo_toRadians(lat2);
+    const double dLat = radLat2 - radLat1;
+    const double dLon = geo_toRadians(lon2 - lon1);
+
+    const double sinHalfLat = std::sin(dLat * 0.5);
+    const double sinHalfLon = std::sin(dLon * 0.5);
+    const double h = sinHalfLat * sinHalfLat + std::cos(radLat1) * std::cos(radLat2) * sinHalfLon * sinHalfLon;
+    const double c = 2.0 * std::atan2(std::sqrt(h), std::sqrt(1.0 - h));
+
+    return kEarthRadiusMeters * c;
+}
+
+static double haversineMeters(double lat1, double lon1, double lat2, double lon2) {
+    return calculateDistance(lat1, lon1, lat2, lon2);
+}
+
+// 计算方位角 (Bearing)
+static double calculateBearing(double lat1, double lon1, double lat2, double lon2) {
+    double phi1 = geo_toRadians(lat1);
+    double phi2 = geo_toRadians(lat2);
+    double lam1 = geo_toRadians(lon1);
+    double lam2 = geo_toRadians(lon2);
+
+    double y = std::sin(lam2 - lam1) * std::cos(phi2);
+    double x = std::cos(phi1) * std::sin(phi2) -
+               std::sin(phi1) * std::cos(phi2) * std::cos(lam2 - lam1);
+    double theta = std::atan2(y, x);
+
+    return std::fmod(geo_toDegrees(theta) + 360.0, 360.0);
+}
+
+bool isPointInCircle(double pointLat, double pointLon, double centerLat, double centerLon, double radiusMeters) {
+    if (radiusMeters <= 0.0) {
+        return false;
+    }
+    const double distance = haversineMeters(pointLat, pointLon, centerLat, centerLon);
+    return distance <= radiusMeters;
+}
+
+bool isPointInPolygon(double pointLat, double pointLon, const std::vector<GeoPoint>& polygon) {
+    const size_t n = polygon.size();
+    if (n < 3) {
+        return false;
+    }
+
+    bool inside = false;
+    size_t j = n - 1;
+    for (size_t i = 0; i < n; ++i) {
+        const double xi = polygon[i].lat;
+        const double yi = polygon[i].lon;
+        const double xj = polygon[j].lat;
+        const double yj = polygon[j].lon;
+
+        const double intersect = ((yi > pointLon) != (yj > pointLon)) &&
+            (pointLat < (xj - xi) * (pointLon - yi) / (yj - yi) + xi);
+        if (intersect) {
+            inside = !inside;
+        }
+        j = i;
+    }
+
+    return inside;
+}
+
+double calculatePolygonArea(const std::vector<GeoPoint>& polygon) {
+    const size_t n = polygon.size();
+    if (n < 3) {
+        return 0.0;
+    }
+
+    double total = 0.0;
+    for (size_t i = 0; i < n; ++i) {
+        const GeoPoint& p1 = polygon[i];
+        const GeoPoint& p2 = polygon[(i + 1) % n];
+
+        const double lat1 = geo_toRadians(p1.lat);
+        const double lat2 = geo_toRadians(p2.lat);
+        const double lon1 = geo_toRadians(p1.lon);
+        const double lon2 = geo_toRadians(p2.lon);
+
+        total += (lon2 - lon1) * (2.0 + std::sin(lat1) + std::sin(lat2));
+    }
+
+    const double area = std::abs(total) * (kEarthRadiusMeters * kEarthRadiusMeters) * 0.5;
+    return area;
+}
+
+double calculateRectangleArea(double swLat, double swLon, double neLat, double neLon) {
+    std::vector<GeoPoint> rectangle;
+    rectangle.reserve(4);
+    rectangle.push_back({swLat, swLon});
+    rectangle.push_back({swLat, neLon});
+    rectangle.push_back({neLat, neLon});
+    rectangle.push_back({neLat, swLon});
+    return calculatePolygonArea(rectangle);
+}
+
+// 简单的 2D 点结构，用于本地坐标投影计算
+struct Point2D {
+    double x;
+    double y;
+    size_t index; // 原始索引
+};
+
+// 计算点到线段的垂直距离的平方
+static double getSqSegDist(const Point2D& p, const Point2D& p1, const Point2D& p2) {
+    double x = p1.x;
+    double y = p1.y;
+    double dx = p2.x - x;
+    double dy = p2.y - y;
+
+    if (dx != 0 || dy != 0) {
+        double t = ((p.x - x) * dx + (p.y - y) * dy) / (dx * dx + dy * dy);
+        if (t > 1) {
+            x = p2.x;
+            y = p2.y;
+        } else if (t > 0) {
+            x += dx * t;
+            y += dy * t;
+        }
+    }
+
+    dx = p.x - x;
+    dy = p.y - y;
+
+    return dx * dx + dy * dy;
+}
+
+// RDP 递归函数
+static void simplifyDPStep(const std::vector<Point2D>& points, size_t first, size_t last, double sqTolerance, std::vector<size_t>& simplified) {
+    double maxSqDist = sqTolerance;
+    size_t index = 0;
+
+    for (size_t i = first + 1; i < last; i++) {
+        double sqDist = getSqSegDist(points[i], points[first], points[last]);
+        if (sqDist > maxSqDist) {
+            index = i;
+            maxSqDist = sqDist;
+        }
+    }
+
+    if (maxSqDist > sqTolerance) {
+        if (index - first > 1) simplifyDPStep(points, first, index, sqTolerance, simplified);
+        simplified.push_back(index);
+        if (last - index > 1) simplifyDPStep(points, index, last, sqTolerance, simplified);
+    }
+}
+
+std::vector<GeoPoint> simplifyPolyline(const std::vector<GeoPoint>& points, double toleranceMeters) {
+    if (points.size() <= 2) {
+        return points;
+    }
+
+    // 1. 投影到平面坐标 (Equirectangular Projection approximation)
+    // 以第一个点为原点
+    double refLat = points[0].lat;
+    double refLon = points[0].lon;
+    double refLatRad = geo_toRadians(refLat);
+    double metersPerDegreeLat = 111319.9;
+    double metersPerDegreeLon = 111319.9 * std::cos(refLatRad);
+
+    std::vector<Point2D> projectedPoints;
+    projectedPoints.reserve(points.size());
+    for (size_t i = 0; i < points.size(); ++i) {
+        double x = (points[i].lon - refLon) * metersPerDegreeLon;
+        double y = (points[i].lat - refLat) * metersPerDegreeLat;
+        projectedPoints.push_back({x, y, i});
+    }
+
+    // 2. 运行 RDP 算法
+    double sqTolerance = toleranceMeters * toleranceMeters;
+    std::vector<size_t> simplifiedIndices;
+    simplifiedIndices.push_back(0); // 总是保留第一个点
+    
+    simplifyDPStep(projectedPoints, 0, projectedPoints.size() - 1, sqTolerance, simplifiedIndices);
+    
+    simplifiedIndices.push_back(projectedPoints.size() - 1); // 总是保留最后一个点
+
+    // 3. 构建结果
+    std::vector<GeoPoint> result;
+    result.reserve(simplifiedIndices.size());
+    
+    for (size_t idx : simplifiedIndices) {
+        result.push_back(points[idx]);
+    }
+
+    return result;
+}
+
+double calculatePathLength(const std::vector<GeoPoint>& points) {
+    if (points.size() < 2) return 0.0;
+    
+    double total = 0.0;
+    for (size_t i = 0; i < points.size() - 1; ++i) {
+        total += calculateDistance(points[i].lat, points[i].lon, points[i+1].lat, points[i+1].lon);
+    }
+    return total;
+}
+
+bool getPointAtDistance(const std::vector<GeoPoint>& points, double distanceMeters, double* outLat, double* outLon, double* outAngle) {
+    if (points.size() < 2 || distanceMeters < 0) return false;
+    
+    if (distanceMeters == 0) {
+        *outLat = points[0].lat;
+        *outLon = points[0].lon;
+        *outAngle = calculateBearing(points[0].lat, points[0].lon, points[1].lat, points[1].lon);
+        return true;
+    }
+    
+    double covered = 0.0;
+    for (size_t i = 0; i < points.size() - 1; ++i) {
+        double d = calculateDistance(points[i].lat, points[i].lon, points[i+1].lat, points[i+1].lon);
+        if (covered + d >= distanceMeters) {
+            double remaining = distanceMeters - covered;
+            double fraction = remaining / d;
+            
+            // 简单的线性插值 (Linear Interpolation)
+            // 对于小距离段，这比球形插值快得多且误差可忽略
+            *outLat = points[i].lat + (points[i+1].lat - points[i].lat) * fraction;
+            *outLon = points[i].lon + (points[i+1].lon - points[i].lon) * fraction;
+            *outAngle = calculateBearing(points[i].lat, points[i].lon, points[i+1].lat, points[i+1].lon);
+            return true;
+        }
+        covered += d;
+    }
+    
+    // 如果超出总长度，返回最后一个点
+    const GeoPoint& last = points.back();
+    const GeoPoint& prev = points[points.size() - 2];
+    *outLat = last.lat;
+    *outLon = last.lon;
+    *outAngle = calculateBearing(prev.lat, prev.lon, last.lat, last.lon);
+    return true;
+}
+
+// Helper: Square of Euclidean distance
+static double distSq(double x1, double y1, double x2, double y2) {
+    double dx = x1 - x2;
+    double dy = y1 - y2;
+    return dx * dx + dy * dy;
+}
+
+NearestPointResult getNearestPointOnPath(const std::vector<GeoPoint>& path, const GeoPoint& target) {
+    NearestPointResult result = {0.0, 0.0, 0, std::numeric_limits<double>::max()};
+    
+    if (path.empty()) {
+        return result;
+    }
+    
+    if (path.size() == 1) {
+        result.latitude = path[0].lat;
+        result.longitude = path[0].lon;
+        result.index = 0;
+        result.distanceMeters = calculateDistance(target.lat, target.lon, path[0].lat, path[0].lon);
+        return result;
+    }
+
+    double minDistance = std::numeric_limits<double>::max();
+    
+    for (size_t i = 0; i < path.size() - 1; ++i) {
+        double ax = path[i].lat;
+        double ay = path[i].lon;
+        double bx = path[i+1].lat;
+        double by = path[i+1].lon;
+        
+        // Project target (px, py) onto segment AB
+        // Note: This treats lat/lon as cartesian for projection, which is an approximation
+        // but generally sufficient for "snapping" to a path.
+        // For distance calculation, we use Haversine.
+        
+        double px = target.lat;
+        double py = target.lon;
+        
+        double l2 = distSq(ax, ay, bx, by);
+        double t = 0.0;
+        if (l2 > 0) {
+            t = ((px - ax) * (bx - ax) + (py - ay) * (by - ay)) / l2;
+            if (t < 0) t = 0;
+            else if (t > 1) t = 1;
+        }
+        
+        double projLat = ax + t * (bx - ax);
+        double projLon = ay + t * (by - ay);
+        
+        double dist = calculateDistance(target.lat, target.lon, projLat, projLon);
+        
+        if (dist < minDistance) {
+            minDistance = dist;
+            result.latitude = projLat;
+            result.longitude = projLon;
+            result.index = static_cast<int>(i);
+            result.distanceMeters = dist;
+        }
+    }
+    
+    return result;
+}
+
+GeoPoint calculateCentroid(const std::vector<GeoPoint>& polygon) {
+    if (polygon.empty()) {
+        return {0.0, 0.0};
+    }
+    
+    // 简单多边形质心公式
+    // Cx = (1/6A) * Σ (xi + xi+1) * (xi * yi+1 - xi+1 * yi)
+    // Cy = (1/6A) * Σ (yi + yi+1) * (xi * yi+1 - xi+1 * yi)
+    
+    double signedArea = 0.0;
+    double cx = 0.0;
+    double cy = 0.0;
+    
+    size_t n = polygon.size();
+    // 确保多边形闭合
+    bool closed = (polygon[0].lat == polygon[n-1].lat && polygon[0].lon == polygon[n-1].lon);
+    size_t limit = closed ? n - 1 : n;
+    
+    for (size_t i = 0; i < limit; ++i) {
+        double x0 = polygon[i].lat;
+        double y0 = polygon[i].lon;
+        double x1 = polygon[(i + 1) % n].lat;
+        double y1 = polygon[(i + 1) % n].lon;
+        
+        double a = x0 * y1 - x1 * y0;
+        signedArea += a;
+        cx += (x0 + x1) * a;
+        cy += (y0 + y1) * a;
+    }
+    
+    if (std::abs(signedArea) < 1e-9) {
+        // 退化为计算所有点的平均值
+        double sumLat = 0.0;
+        double sumLon = 0.0;
+        for(const auto& p : polygon) {
+            sumLat += p.lat;
+            sumLon += p.lon;
+        }
+        return {sumLat / n, sumLon / n};
+    }
+    
+    signedArea *= 0.5;
+    cx /= (6.0 * signedArea);
+    cy /= (6.0 * signedArea);
+    
+    return {cx, cy};
+}
+
+std::string encodeGeoHash(double lat, double lon, int precision) {
+    if (precision < 1) precision = 1;
+    if (precision > 12) precision = 12;
+    
+    static const char BASE32[] = "0123456789bcdefghjkmnpqrstuvwxyz";
+    std::string hash = "";
+    
+    double minLat = -90.0, maxLat = 90.0;
+    double minLon = -180.0, maxLon = 180.0;
+    
+    int bit = 0;
+    int ch = 0;
+    bool isEven = true;
+    
+    while (hash.length() < precision) {
+        if (isEven) {
+            double mid = (minLon + maxLon) / 2.0;
+            if (lon > mid) {
+                ch |= (1 << (4 - bit));
+                minLon = mid;
+            } else {
+                maxLon = mid;
+            }
+        } else {
+            double mid = (minLat + maxLat) / 2.0;
+            if (lat > mid) {
+                ch |= (1 << (4 - bit));
+                minLat = mid;
+            } else {
+                maxLat = mid;
+            }
+        }
+        
+        isEven = !isEven;
+        
+        if (bit < 4) {
+            bit++;
+        } else {
+            hash += BASE32[ch];
+            bit = 0;
+            ch = 0;
+        }
+    }
+    
+    return hash;
+}
+
+std::vector<GeoPoint> parsePolyline(const std::string& polylineStr) {
+    std::vector<GeoPoint> points;
+    if (polylineStr.empty()) {
+        return points;
+    }
+
+    size_t start = 0;
+    size_t end = polylineStr.find(';');
+    
+    while (true) {
+        std::string segment = polylineStr.substr(start, end - start);
+        if (!segment.empty()) {
+            size_t comma = segment.find(',');
+            if (comma != std::string::npos) {
+                try {
+                    double lon = std::stod(segment.substr(0, comma));
+                    double lat = std::stod(segment.substr(comma + 1));
+                    points.push_back({lat, lon});
+                } catch (...) {
+                    // 忽略无效的坐标对
+                }
+            }
+        }
+        
+        if (end == std::string::npos) {
+            break;
+        }
+        
+        start = end + 1;
+        end = polylineStr.find(';', start);
+    }
+    
+    return points;
+}
+
+PathBounds calculatePathBounds(const std::vector<GeoPoint>& points) {
+    PathBounds bounds = { -90.0, 90.0, -180.0, 180.0, 0.0, 0.0 };
+    
+    if (points.empty()) {
+        return bounds;
+    }
+    
+    double minLat = 90.0;
+    double maxLat = -90.0;
+    double minLon = 180.0;
+    double maxLon = -180.0;
+    
+    for (const auto& p : points) {
+        if (p.lat < minLat) minLat = p.lat;
+        if (p.lat > maxLat) maxLat = p.lat;
+        if (p.lon < minLon) minLon = p.lon;
+        if (p.lon > maxLon) maxLon = p.lon;
+    }
+    
+    bounds.north = maxLat;
+    bounds.south = minLat;
+    bounds.east = maxLon;
+    bounds.west = minLon;
+    bounds.centerLat = (maxLat + minLat) / 2.0;
+    bounds.centerLon = (maxLon + minLon) / 2.0;
+    
+    return bounds;
+}
+
+// --- 瓦片与坐标转换 ---
+
+TileResult latLngToTile(double lat, double lon, int zoom) {
+    double n = std::pow(2.0, zoom);
+    int x = static_cast<int>((lon + 180.0) / 360.0 * n);
+    double latRad = geo_toRadians(lat);
+    int y = static_cast<int>((1.0 - std::asinh(std::tan(latRad)) / kPi) / 2.0 * n);
+    return {x, y, zoom};
+}
+
+GeoPoint tileToLatLng(int x, int y, int zoom) {
+    double n = std::pow(2.0, zoom);
+    double lon = static_cast<double>(x) / n * 360.0 - 180.0;
+    double latRad = std::atan(std::sinh(kPi * (1.0 - 2.0 * static_cast<double>(y) / n)));
+    double lat = latRad * kRadiansToDegrees;
+    return {lat, lon};
+}
+
+PixelResult latLngToPixel(double lat, double lon, int zoom) {
+    double n = std::pow(2.0, zoom) * 256.0; // 假设瓦片大小为 256x256
+    double x = (lon + 180.0) / 360.0 * n;
+    double latRad = geo_toRadians(lat);
+    double y = (1.0 - std::asinh(std::tan(latRad)) / kPi) / 2.0 * n;
+    return {x, y};
+}
+
+GeoPoint pixelToLatLng(double x, double y, int zoom) {
+    double n = std::pow(2.0, zoom) * 256.0;
+    double lon = x / n * 360.0 - 180.0;
+    double latRad = std::atan(std::sinh(kPi * (1.0 - 2.0 * y / n)));
+    double lat = latRad * kRadiansToDegrees;
+    return {lat, lon};
+}
+
+// --- 批量地理围栏与热力图 ---
+
+int findPointInPolygons(double pointLat, double pointLon, const std::vector<std::vector<GeoPoint>>& polygons) {
+    for (size_t i = 0; i < polygons.size(); ++i) {
+        if (isPointInPolygon(pointLat, pointLon, polygons[i])) {
+            return static_cast<int>(i);
+        }
+    }
+    return -1;
+}
+
+std::vector<HeatmapGridCell> generateHeatmapGrid(const std::vector<HeatmapPoint>& points, double gridSizeMeters) {
+    if (points.empty()) return {};
+
+    // 1. 计算范围
+    double minLat = 90.0, maxLat = -90.0, minLon = 180.0, maxLon = -180.0;
+    for (const auto& p : points) {
+        if (p.lat < minLat) minLat = p.lat;
+        if (p.lat > maxLat) maxLat = p.lat;
+        if (p.lon < minLon) minLon = p.lon;
+        if (p.lon > maxLon) maxLon = p.lon;
+    }
+
+    // 2. 将米转换为大概的经纬度步长
+    // (这是一个近似值，但在热力图分桶中通常足够)
+    double latDegreeDist = 111320.0; // 每纬度度数大约 111km
+    double lonDegreeDist = 111320.0 * std::cos(geo_toRadians((minLat + maxLat) / 2.0));
+    
+    double latStep = gridSizeMeters / latDegreeDist;
+    double lonStep = gridSizeMeters / lonDegreeDist;
+
+    if (latStep <= 0 || lonStep <= 0) return {};
+
+    // 3. 将点分配到网格中
+    std::map<std::pair<int, int>, double> grid;
+    for (const auto& p : points) {
+        int latIdx = static_cast<int>((p.lat - minLat) / latStep);
+        int lonIdx = static_cast<int>((p.lon - minLon) / lonStep);
+        grid[{latIdx, lonIdx}] += p.weight;
+    }
+
+    // 4. 创建结果单元格
+    std::vector<HeatmapGridCell> cells;
+    cells.reserve(grid.size());
+    for (const auto& entry : grid) {
+        int latIdx = entry.first.first;
+        int lonIdx = entry.first.second;
+        double intensity = entry.second;
+        
+        cells.push_back({
+            minLat + (latIdx + 0.5) * latStep,
+            minLon + (lonIdx + 0.5) * lonStep,
+            intensity
+        });
+    }
+
+    return cells;
+}
+
+} // namespace gaodemap

package/shared/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/shared/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/shared/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/shared/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++` 编译源代码并运行生成的测试二进制文件，验证各核心模块的逻辑准确性。