@maydon_tech/react-native-nitro-maps 0.1.0

package/android/src/main/java/com/margelo/nitro/nitromap/providers/MapProviderInterface.kt

@@ -0,0 +1,70 @@
+package com.margelo.nitro.nitromap.providers
+
+import android.view.View
+import com.margelo.nitro.core.Promise
+import com.margelo.nitro.nitromap.*
+
+/** Interface for map providers (Google, Yandex) Mirrors iOS MapProviderProtocol */
+interface MapProviderInterface {
+
+    // MARK: - View
+    val mapView: View
+
+    // MARK: - Setup
+    fun setup()
+    fun onResume()
+    fun onPause()
+    fun onDestroy()
+
+    // MARK: - Properties
+    var initialRegion: Region?
+    var showsUserLocation: Boolean?
+    var showsMyLocationButton: Boolean?
+    var zoomEnabled: Boolean?
+    var scrollEnabled: Boolean?
+    var rotateEnabled: Boolean?
+    var pitchEnabled: Boolean?
+    var mapType: MapType?
+    var clusterConfig: ClusterConfig?
+    var darkMode: Boolean?
+    var customMapStyle: Array<MapStyleElement>?
+
+    // MARK: - Callbacks
+    var onMapReady: (() -> Unit)?
+    var onPress: ((event: MapPressEvent) -> Unit)?
+    var onLongPress: ((event: MapPressEvent) -> Unit)?
+    var onRegionChange: ((event: RegionChangeEvent) -> Unit)?
+    var onRegionChangeComplete: ((event: RegionChangeEvent) -> Unit)?
+    var onMarkerPress: ((event: MarkerPressEvent) -> Unit)?
+    var onMarkerDragStart: ((event: MarkerDragEvent) -> Unit)?
+    var onMarkerDrag: ((event: MarkerDragEvent) -> Unit)?
+    var onMarkerDragEnd: ((event: MarkerDragEvent) -> Unit)?
+    var onClusterPress: ((event: ClusterPressEvent) -> Unit)?
+    var onError: ((error: MapError) -> Unit)?
+
+    // MARK: - Camera Methods
+    fun animateToRegion(region: Region, duration: Double)
+    fun animateCamera(camera: Camera, duration: Double)
+    fun setCamera(camera: Camera)
+    fun getCamera(): Promise<Camera>
+    fun fitToCoordinates(coordinates: Array<Coordinate>, padding: EdgePadding, animated: Boolean)
+    fun getMapBoundaries(): Promise<MapBoundaries>
+    fun getCurrentRegion(): Region
+
+    // MARK: - Marker Methods
+    fun addMarker(marker: MarkerData)
+    fun addMarkers(markers: Array<MarkerData>)
+    fun updateMarker(marker: MarkerData)
+    fun removeMarker(id: String)
+    fun clearMarkers()
+    fun selectMarker(id: String)
+
+    // MARK: - Clustering
+    fun setClusteringEnabled(enabled: Boolean)
+    fun refreshClusters()
+    fun performClustering()
+
+    // MARK: - Styling
+    fun setMapStyle(style: Array<MapStyleElement>?)
+    fun setIsDarkMode(enabled: Boolean)
+}

package/cpp/ClusterEngine.hpp

@@ -0,0 +1,411 @@
+#pragma once
+
+#include <vector>
+#include <unordered_map>
+#include <string>
+#include <cmath>
+#include <algorithm>
+
+#include "KDBush.hpp"
+
+namespace nitromap {
+
+// ============================================================================
+// DATA STRUCTURES
+// ============================================================================
+
+/**
+ * Marker point — pure geographic data for spatial grouping.
+ * No icon dimensions: collision detection uses real rendered sizes in Swift.
+ */
+struct MarkerPoint {
+    std::string id;
+    double latitude;
+    double longitude;
+
+    MarkerPoint() : id(""), latitude(0), longitude(0) {}
+    MarkerPoint(const std::string& id, double lat, double lon)
+        : id(id), latitude(lat), longitude(lon) {}
+};
+
+/**
+ * Cluster containing multiple markers
+ */
+struct Cluster {
+    double latitude;
+    double longitude;
+    std::vector<std::string> markerIds;
+    int count;
+
+    Cluster() : latitude(0), longitude(0), count(0) {}
+
+    /// Returns cluster icon diameter in screen points.
+    /// Used as a hint; actual collision uses rendered icon size in Swift.
+    static double iconSize(int count) {
+        return count < 10 ? 44.0 : (count < 100 ? 52.0 : 60.0);
+    }
+};
+
+/**
+ * Result of clustering operation
+ */
+struct ClusterResult {
+    std::vector<Cluster> clusters;
+    std::vector<MarkerPoint> singleMarkers;
+
+    void clear() {
+        clusters.clear();
+        singleMarkers.clear();
+    }
+};
+
+
+// ============================================================================
+// MERCATOR PROJECTION (same as Supercluster)
+// ============================================================================
+
+/// Longitude to Mercator X [0..1]
+inline double lngX(double lng) {
+    return lng / 360.0 + 0.5;
+}
+
+/// Latitude to Mercator Y [0..1]
+inline double latY(double lat) {
+    double sinLat = std::sin(lat * M_PI / 180.0);
+    double y = 0.5 - 0.25 * std::log((1.0 + sinLat) / (1.0 - sinLat)) / M_PI;
+    return y < 0.0 ? 0.0 : (y > 1.0 ? 1.0 : y);
+}
+
+/// Mercator X [0..1] to Longitude
+inline double xLng(double x) {
+    return (x - 0.5) * 360.0;
+}
+
+/// Mercator Y [0..1] to Latitude
+inline double yLat(double y) {
+    double y2 = (180.0 - y * 360.0) * M_PI / 180.0;
+    return 360.0 * std::atan(std::exp(y2)) / M_PI - 90.0;
+}
+
+// ============================================================================
+// FLAT ARRAY LAYOUT per zoom level
+// ============================================================================
+
+// Each item uses STRIDE doubles:
+// [mercatorX, mercatorY, numPoints, originIndex]
+static constexpr int STRIDE = 4;
+static constexpr int OFF_X = 0;
+static constexpr int OFF_Y = 1;
+static constexpr int OFF_NUM = 2;
+static constexpr int OFF_ORIGIN = 3;
+
+// ============================================================================
+// CLUSTER ENGINE — Supercluster algorithm with KDBush
+//
+// Phase 1 (load-time, O(n log n)):
+//   Project all markers to Mercator [0..1]. Build KDBush at maxZoom+1.
+//   Cluster bottom-up from maxZoom to minZoom. Each zoom level gets
+//   its own flat data array + KDBush index.
+//
+// Phase 2 (render-time, O(√n + k)):
+//   getClusters() range-queries the KDBush at floor(zoom).
+//
+// Collision detection happens in Swift using real rendered icon sizes.
+// ============================================================================
+
+class ClusterEngine {
+public:
+    ClusterEngine()
+        : minZoom_(0), maxZoom_(16), radiusPixels_(80.0),
+          minClusterSize_(2), extent_(512.0), loaded_(false), markersChanged_(false) {}
+
+    ~ClusterEngine() = default;
+
+    // --- Configuration ---
+    void setClusterRadius(double radiusInPixels) {
+        if (radiusPixels_ != radiusInPixels) {
+            radiusPixels_ = radiusInPixels;
+            markersChanged_ = true;
+        }
+    }
+    void setMinClusterSize(int size) {
+        if (minClusterSize_ != size) {
+            minClusterSize_ = size;
+            markersChanged_ = true;
+        }
+    }
+    void setMaxZoom(double zoom) {
+        int z = static_cast<int>(zoom);
+        if (maxZoom_ != z) {
+            maxZoom_ = z;
+            markersChanged_ = true;
+        }
+    }
+
+    // --- Marker management ---
+    void addMarker(const MarkerPoint& marker) {
+        markers_[marker.id] = marker;
+        markersChanged_ = true;
+    }
+
+    void addMarkers(const std::vector<MarkerPoint>& markers) {
+        for (const auto& m : markers) markers_[m.id] = m;
+        markersChanged_ = true;
+    }
+
+    void removeMarker(const std::string& id) {
+        markers_.erase(id);
+        markersChanged_ = true;
+    }
+
+    void clearMarkers() {
+        markers_.clear();
+        markersChanged_ = true;
+    }
+
+    size_t markerCount() const { return markers_.size(); }
+
+    // --- Main API ---
+    ClusterResult getClusters(
+        double visMinLat, double visMaxLat,
+        double visMinLon, double visMaxLon,
+        double zoom, double mapW, double mapH
+    );
+
+    // Backward compat
+    ClusterResult cluster(
+        double visMinLat, double visMaxLat,
+        double visMinLon, double visMaxLon,
+        double zoom, double mapW, double mapH
+    ) {
+        return getClusters(visMinLat, visMaxLat, visMinLon, visMaxLon, zoom, mapW, mapH);
+    }
+
+private:
+    void buildHierarchy();
+
+    // --- Input ---
+    std::unordered_map<std::string, MarkerPoint> markers_;
+    std::vector<std::string> inputIds_;
+
+    // --- Per zoom level: flat data + spatial index ---
+    std::vector<std::vector<double>> zoomData_;
+    std::vector<std::vector<std::vector<int>>> zoomMembers_;
+    std::vector<KDBush> zoomIndex_;
+
+    // --- Config ---
+    int minZoom_, maxZoom_;
+    double radiusPixels_;
+    int minClusterSize_;
+    double extent_;
+    bool loaded_, markersChanged_;
+};
+
+// ============================================================================
+// IMPLEMENTATION
+// ============================================================================
+
+inline void ClusterEngine::buildHierarchy() {
+    if (markers_.empty()) {
+        zoomData_.clear();
+        zoomMembers_.clear();
+        zoomIndex_.clear();
+        loaded_ = true;
+        markersChanged_ = false;
+        return;
+    }
+
+    int numZooms = maxZoom_ + 2;
+    zoomData_.resize(numZooms);
+    zoomMembers_.resize(numZooms);
+    zoomIndex_.resize(numZooms);
+
+    // --- Step 1: Project all markers to Mercator space ---
+    inputIds_.clear();
+    inputIds_.reserve(markers_.size());
+
+    auto& baseData = zoomData_[maxZoom_ + 1];
+    auto& baseMembers = zoomMembers_[maxZoom_ + 1];
+    baseData.clear();
+    baseMembers.clear();
+
+    // Sort marker IDs for deterministic iteration order.
+    // std::unordered_map has non-deterministic iteration which causes
+    // different cluster results on each rebuild.
+    std::vector<std::string> sortedIds;
+    sortedIds.reserve(markers_.size());
+    for (const auto& pair : markers_) {
+        sortedIds.push_back(pair.first);
+    }
+    std::sort(sortedIds.begin(), sortedIds.end());
+
+    int idx = 0;
+    for (const auto& id : sortedIds) {
+        const auto& m = markers_[id];
+        double mx = lngX(m.longitude);
+        double my = latY(m.latitude);
+
+        baseData.push_back(mx);                              // OFF_X
+        baseData.push_back(my);                              // OFF_Y
+        baseData.push_back(1.0);                             // OFF_NUM
+        baseData.push_back(static_cast<double>(idx));        // OFF_ORIGIN
+
+        baseMembers.push_back({idx});
+        inputIds_.push_back(m.id);
+        idx++;
+    }
+
+    // Build KDBush at maxZoom+1
+    size_t baseCount = baseMembers.size();
+    {
+        std::vector<double> coords(baseCount * 2);
+        for (size_t i = 0; i < baseCount; i++) {
+            coords[2 * i]     = baseData[i * STRIDE + OFF_X];
+            coords[2 * i + 1] = baseData[i * STRIDE + OFF_Y];
+        }
+        zoomIndex_[maxZoom_ + 1].build(coords, baseCount);
+    }
+
+    // --- Step 2: Cluster bottom-up from maxZoom to minZoom ---
+    for (int z = maxZoom_; z >= minZoom_; z--) {
+        double r = radiusPixels_ / (extent_ * std::pow(2.0, z));
+
+        auto& prevData = zoomData_[z + 1];
+        auto& prevMembers = zoomMembers_[z + 1];
+        auto& nextData = zoomData_[z];
+        auto& nextMembers = zoomMembers_[z];
+        nextData.clear();
+        nextMembers.clear();
+
+        size_t prevCount = prevMembers.size();
+        std::vector<bool> used(prevCount, false);
+
+        for (size_t i = 0; i < prevCount; i++) {
+            if (used[i]) continue;
+            used[i] = true;
+
+            size_t k = i * STRIDE;
+            double px = prevData[k + OFF_X];
+            double py = prevData[k + OFF_Y];
+            int numPointsOrigin = static_cast<int>(prevData[k + OFF_NUM]);
+
+            std::vector<int> neighborIndices = zoomIndex_[z + 1].within(px, py, r);
+
+            int numPoints = numPointsOrigin;
+            std::vector<size_t> toMerge;
+
+            for (int ni : neighborIndices) {
+                size_t si = static_cast<size_t>(ni);
+                if (si == i || used[si]) continue;
+                numPoints += static_cast<int>(prevData[si * STRIDE + OFF_NUM]);
+                toMerge.push_back(si);
+            }
+
+            if (numPoints >= minClusterSize_ && !toMerge.empty()) {
+                // Form a cluster — weighted centroid
+                double wx = px * numPointsOrigin;
+                double wy = py * numPointsOrigin;
+                std::vector<int> allMembers = prevMembers[i];
+
+                for (size_t ni : toMerge) {
+                    used[ni] = true;
+                    size_t nk = ni * STRIDE;
+                    int np = static_cast<int>(prevData[nk + OFF_NUM]);
+                    wx += prevData[nk + OFF_X] * np;
+                    wy += prevData[nk + OFF_Y] * np;
+                    for (int mi : prevMembers[ni]) {
+                        allMembers.push_back(mi);
+                    }
+                }
+
+                double cx = wx / numPoints;
+                double cy = wy / numPoints;
+
+                nextData.push_back(cx);                              // OFF_X
+                nextData.push_back(cy);                              // OFF_Y
+                nextData.push_back(static_cast<double>(numPoints));  // OFF_NUM
+                nextData.push_back(prevData[k + OFF_ORIGIN]);        // OFF_ORIGIN
+                nextMembers.push_back(std::move(allMembers));
+
+            } else {
+                // Keep as individual item
+                for (int s = 0; s < STRIDE; s++) {
+                    nextData.push_back(prevData[k + s]);
+                }
+                nextMembers.push_back(prevMembers[i]);
+            }
+        }
+
+        // Build KDBush for this zoom level
+        size_t nextCount = nextMembers.size();
+        std::vector<double> coords(nextCount * 2);
+        for (size_t i = 0; i < nextCount; i++) {
+            coords[2 * i]     = nextData[i * STRIDE + OFF_X];
+            coords[2 * i + 1] = nextData[i * STRIDE + OFF_Y];
+        }
+        zoomIndex_[z].build(coords, nextCount);
+    }
+
+    loaded_ = true;
+    markersChanged_ = false;
+}
+
+inline ClusterResult ClusterEngine::getClusters(
+    double visMinLat, double visMaxLat,
+    double visMinLon, double visMaxLon,
+    double zoom, double mapW, double mapH
+) {
+    ClusterResult result;
+    if (markers_.empty()) return result;
+    if (markersChanged_ || !loaded_) buildHierarchy();
+    if (zoomIndex_.empty()) return result;
+
+    // Clamp zoom
+    int z = static_cast<int>(std::floor(zoom));
+    if (z > maxZoom_) z = maxZoom_ + 1;
+    if (z < minZoom_) z = minZoom_;
+
+    // Convert bounds to Mercator
+    double minX = lngX(visMinLon);
+    double maxX = lngX(visMaxLon);
+    double minY = latY(visMaxLat);
+    double maxY = latY(visMinLat);
+
+    // Range query on KDBush
+    std::vector<int> indices = zoomIndex_[z].range(minX, minY, maxX, maxY);
+
+    auto& zData = zoomData_[z];
+    auto& zMembers = zoomMembers_[z];
+
+    for (int idx : indices) {
+        size_t i = static_cast<size_t>(idx);
+        size_t k = i * STRIDE;
+        int numPoints = static_cast<int>(zData[k + OFF_NUM]);
+
+        if (numPoints >= minClusterSize_) {
+            Cluster cluster;
+            cluster.latitude = yLat(zData[k + OFF_Y]);
+            cluster.longitude = xLng(zData[k + OFF_X]);
+            cluster.count = numPoints;
+            for (int mi : zMembers[i]) {
+                if (mi >= 0 && mi < static_cast<int>(inputIds_.size())) {
+                    cluster.markerIds.push_back(inputIds_[mi]);
+                }
+            }
+            result.clusters.push_back(std::move(cluster));
+        } else {
+            for (int mi : zMembers[i]) {
+                if (mi >= 0 && mi < static_cast<int>(inputIds_.size())) {
+                    auto it = markers_.find(inputIds_[mi]);
+                    if (it != markers_.end()) {
+                        result.singleMarkers.push_back(it->second);
+                    }
+                }
+            }
+        }
+    }
+
+    return result;
+}
+
+} // namespace nitromap