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

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);
+
+}