@maydon_tech/react-native-nitro-maps 0.1.0

package/cpp/KDBush.hpp

@@ -0,0 +1,238 @@
+#pragma once
+
+#include <vector>
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+
+namespace nitromap {
+
+/**
+ * KDBush — a fast static 2D spatial index for flat coordinate arrays.
+ * Port of the JavaScript kdbush library used by Mapbox Supercluster.
+ *
+ * Build:   O(n log n)
+ * Range:   O(√n + k)
+ * Within:  O(√n + k)
+ * Returns: flat array indices (not objects)
+ */
+class KDBush {
+public:
+    KDBush() : nodeSize_(64) {}
+
+    /**
+     * Build the index from a flat coordinate array.
+     * @param coords  Flat array [x0, y0, x1, y1, ...] of length numPoints*2
+     * @param numPoints  Number of points
+     * @param nodeSize  KD-tree leaf node size (default 64)
+     */
+    void build(const std::vector<double>& coords, size_t numPoints, int nodeSize = 64) {
+        nodeSize_ = nodeSize;
+        numPoints_ = numPoints;
+
+        // Copy coordinates
+        coords_.resize(numPoints * 2);
+        for (size_t i = 0; i < numPoints * 2; i++) {
+            coords_[i] = coords[i];
+        }
+
+        // Initialize indices [0, 1, 2, ...]
+        ids_.resize(numPoints);
+        for (size_t i = 0; i < numPoints; i++) {
+            ids_[i] = static_cast<int>(i);
+        }
+
+        // Sort in KD-tree order
+        if (numPoints > 0) {
+            sortKD(0, static_cast<int>(numPoints) - 1, 0);
+        }
+    }
+
+    /**
+     * Find all point indices within a bounding box.
+     * @return Vector of original point indices
+     */
+    std::vector<int> range(double minX, double minY, double maxX, double maxY) const {
+        std::vector<int> result;
+        if (numPoints_ == 0) return result;
+
+        std::vector<int> stack;
+        stack.push_back(0);
+        stack.push_back(static_cast<int>(numPoints_) - 1);
+        stack.push_back(0);
+
+        while (!stack.empty()) {
+            int axis = stack.back(); stack.pop_back();
+            int right = stack.back(); stack.pop_back();
+            int left = stack.back(); stack.pop_back();
+
+            if (right - left <= nodeSize_) {
+                // Linear scan of leaf
+                for (int i = left; i <= right; i++) {
+                    double x = coords_[2 * i];
+                    double y = coords_[2 * i + 1];
+                    if (x >= minX && x <= maxX && y >= minY && y <= maxY) {
+                        result.push_back(ids_[i]);
+                    }
+                }
+                continue;
+            }
+
+            int mid = (left + right) >> 1;
+            double x = coords_[2 * mid];
+            double y = coords_[2 * mid + 1];
+
+            if (x >= minX && x <= maxX && y >= minY && y <= maxY) {
+                result.push_back(ids_[mid]);
+            }
+
+            int nextAxis = (axis + 1) % 2;
+
+            if (axis == 0 ? minX <= x : minY <= y) {
+                stack.push_back(left);
+                stack.push_back(mid - 1);
+                stack.push_back(nextAxis);
+            }
+            if (axis == 0 ? maxX >= x : maxY >= y) {
+                stack.push_back(mid + 1);
+                stack.push_back(right);
+                stack.push_back(nextAxis);
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * Find all point indices within a circle.
+     * @return Vector of original point indices
+     */
+    std::vector<int> within(double qx, double qy, double r) const {
+        std::vector<int> result;
+        if (numPoints_ == 0) return result;
+
+        double r2 = r * r;
+
+        std::vector<int> stack;
+        stack.push_back(0);
+        stack.push_back(static_cast<int>(numPoints_) - 1);
+        stack.push_back(0);
+
+        while (!stack.empty()) {
+            int axis = stack.back(); stack.pop_back();
+            int right = stack.back(); stack.pop_back();
+            int left = stack.back(); stack.pop_back();
+
+            if (right - left <= nodeSize_) {
+                for (int i = left; i <= right; i++) {
+                    double dx = coords_[2 * i] - qx;
+                    double dy = coords_[2 * i + 1] - qy;
+                    if (dx * dx + dy * dy <= r2) {
+                        result.push_back(ids_[i]);
+                    }
+                }
+                continue;
+            }
+
+            int mid = (left + right) >> 1;
+            double x = coords_[2 * mid];
+            double y = coords_[2 * mid + 1];
+
+            double dx = x - qx;
+            double dy = y - qy;
+            if (dx * dx + dy * dy <= r2) {
+                result.push_back(ids_[mid]);
+            }
+
+            int nextAxis = (axis + 1) % 2;
+
+            if (axis == 0 ? qx - r <= x : qy - r <= y) {
+                stack.push_back(left);
+                stack.push_back(mid - 1);
+                stack.push_back(nextAxis);
+            }
+            if (axis == 0 ? qx + r >= x : qy + r >= y) {
+                stack.push_back(mid + 1);
+                stack.push_back(right);
+                stack.push_back(nextAxis);
+            }
+        }
+
+        return result;
+    }
+
+    size_t size() const { return numPoints_; }
+
+private:
+    void sortKD(int left, int right, int depth) {
+        if (right <= left) return;
+
+        int mid = (left + right) >> 1;
+        int axis = depth % 2;
+
+        // Select median using nth_element-style partitioning
+        select(left, right, mid, axis);
+
+        // Recurse
+        sortKD(left, mid - 1, depth + 1);
+        sortKD(mid + 1, right, depth + 1);
+    }
+
+    void select(int left, int right, int k, int axis) {
+        // Floyd-Rivest selection algorithm (simplified)
+        while (right > left) {
+            if (right - left > 600) {
+                int n = right - left + 1;
+                int m = k - left + 1;
+                double z = std::log(static_cast<double>(n));
+                double s = 0.5 * std::exp(2.0 * z / 3.0);
+                double sd = 0.5 * std::sqrt(z * s * (n - s) / n) * (2.0 * m - n < 0 ? -1.0 : 1.0);
+                int newLeft = std::max(left, static_cast<int>(k - m * s / n + sd));
+                int newRight = std::min(right, static_cast<int>(k + (n - m) * s / n + sd));
+                select(newLeft, newRight, k, axis);
+            }
+
+            double t = (axis == 0) ? coords_[2 * k] : coords_[2 * k + 1];
+            int i = left;
+            int j = right;
+
+            swapItem(left, k);
+            if (getVal(right, axis) > t) swapItem(left, right);
+
+            while (i < j) {
+                swapItem(i, j);
+                i++;
+                j--;
+                while (getVal(i, axis) < t) i++;
+                while (getVal(j, axis) > t) j--;
+            }
+
+            if (getVal(left, axis) == t) {
+                swapItem(left, j);
+            } else {
+                j++;
+                swapItem(j, right);
+            }
+
+            if (j <= k) left = j + 1;
+            if (k <= j) right = j - 1;
+        }
+    }
+
+    double getVal(int idx, int axis) const {
+        return coords_[2 * idx + axis];
+    }
+
+    void swapItem(int i, int j) {
+        std::swap(ids_[i], ids_[j]);
+        std::swap(coords_[2 * i], coords_[2 * j]);
+        std::swap(coords_[2 * i + 1], coords_[2 * j + 1]);
+    }
+
+    std::vector<double> coords_;
+    std::vector<int> ids_;
+    int nodeSize_;
+    size_t numPoints_;
+};
+
+} // namespace nitromap

package/cpp/QuadTree.hpp

@@ -0,0 +1,246 @@
+#pragma once
+
+#include <vector>
+#include <memory>
+#include <cmath>
+#include <algorithm>
+
+namespace nitromap {
+
+/**
+ * Point structure for QuadTree
+ */
+struct Point {
+    double x;  // longitude
+    double y;  // latitude
+    std::string id;
+
+    Point() : x(0), y(0), id("") {}
+    Point(double x, double y, const std::string& id) : x(x), y(y), id(id) {}
+};
+
+/**
+ * Bounding box for spatial queries
+ */
+struct BoundingBox {
+    double minX, minY, maxX, maxY;
+
+    BoundingBox() : minX(0), minY(0), maxX(0), maxY(0) {}
+    BoundingBox(double minX, double minY, double maxX, double maxY)
+        : minX(minX), minY(minY), maxX(maxX), maxY(maxY) {}
+
+    inline bool contains(const Point& p) const {
+        return p.x >= minX && p.x <= maxX && p.y >= minY && p.y <= maxY;
+    }
+
+    inline bool intersects(const BoundingBox& other) const {
+        return !(other.minX > maxX || other.maxX < minX ||
+                 other.minY > maxY || other.maxY < minY);
+    }
+
+    inline double centerX() const { return (minX + maxX) / 2.0; }
+    inline double centerY() const { return (minY + maxY) / 2.0; }
+    inline double width() const { return maxX - minX; }
+    inline double height() const { return maxY - minY; }
+};
+
+/**
+ * QuadTree for efficient spatial indexing
+ * Provides O(log n) insert and query operations
+ */
+class QuadTree {
+public:
+    static constexpr int MAX_POINTS = 4;
+    static constexpr int MAX_DEPTH = 12;
+
+    QuadTree(const BoundingBox& bounds, int depth = 0)
+        : bounds_(bounds), depth_(depth), divided_(false) {}
+
+    /**
+     * Insert a point into the QuadTree
+     * @return true if inserted successfully
+     */
+    bool insert(const Point& point) {
+        // Point outside bounds
+        if (!bounds_.contains(point)) {
+            return false;
+        }
+
+        // If we have capacity and haven't subdivided, add here
+        if (points_.size() < MAX_POINTS && !divided_) {
+            points_.push_back(point);
+            return true;
+        }
+
+        // Subdivide if we haven't already and we're not at max depth
+        if (!divided_ && depth_ < MAX_DEPTH) {
+            subdivide();
+        }
+
+        // If we've subdivided, try to insert into children
+        if (divided_) {
+            if (nw_->insert(point)) return true;
+            if (ne_->insert(point)) return true;
+            if (sw_->insert(point)) return true;
+            if (se_->insert(point)) return true;
+        }
+
+        // If we're at max depth, just add to this node
+        points_.push_back(point);
+        return true;
+    }
+
+    /**
+     * Query all points within a bounding box
+     * @param range The bounding box to query
+     * @param found Vector to store found points
+     */
+    void query(const BoundingBox& range, std::vector<Point>& found) const {
+        // Range doesn't intersect this quad
+        if (!bounds_.intersects(range)) {
+            return;
+        }
+
+        // Check points in this node
+        for (const auto& point : points_) {
+            if (range.contains(point)) {
+                found.push_back(point);
+            }
+        }
+
+        // Recurse into children
+        if (divided_) {
+            nw_->query(range, found);
+            ne_->query(range, found);
+            sw_->query(range, found);
+            se_->query(range, found);
+        }
+    }
+
+    /**
+     * Query all points within a radius of a center point
+     * Uses squared distance for efficiency (no sqrt)
+     */
+    void queryRadius(double centerX, double centerY, double radius,
+                     std::vector<Point>& found) const {
+        // Create bounding box around circle for initial filter
+        BoundingBox range(
+            centerX - radius, centerY - radius,
+            centerX + radius, centerY + radius
+        );
+
+        if (!bounds_.intersects(range)) {
+            return;
+        }
+
+        double radiusSquared = radius * radius;
+
+        // Check points in this node
+        for (const auto& point : points_) {
+            double dx = point.x - centerX;
+            double dy = point.y - centerY;
+            if (dx * dx + dy * dy <= radiusSquared) {
+                found.push_back(point);
+            }
+        }
+
+        // Recurse into children
+        if (divided_) {
+            nw_->queryRadius(centerX, centerY, radius, found);
+            ne_->queryRadius(centerX, centerY, radius, found);
+            sw_->queryRadius(centerX, centerY, radius, found);
+            se_->queryRadius(centerX, centerY, radius, found);
+        }
+    }
+
+    /**
+     * Get all points in the tree
+     */
+    void getAllPoints(std::vector<Point>& allPoints) const {
+        for (const auto& point : points_) {
+            allPoints.push_back(point);
+        }
+
+        if (divided_) {
+            nw_->getAllPoints(allPoints);
+            ne_->getAllPoints(allPoints);
+            sw_->getAllPoints(allPoints);
+            se_->getAllPoints(allPoints);
+        }
+    }
+
+    /**
+     * Clear all points from the tree
+     */
+    void clear() {
+        points_.clear();
+        divided_ = false;
+        nw_.reset();
+        ne_.reset();
+        sw_.reset();
+        se_.reset();
+    }
+
+    /**
+     * Get total number of points
+     */
+    size_t size() const {
+        size_t count = points_.size();
+        if (divided_) {
+            count += nw_->size() + ne_->size() + sw_->size() + se_->size();
+        }
+        return count;
+    }
+
+private:
+    void subdivide() {
+        double cx = bounds_.centerX();
+        double cy = bounds_.centerY();
+
+        // Northwest (top-left)
+        nw_ = std::make_unique<QuadTree>(
+            BoundingBox(bounds_.minX, cy, cx, bounds_.maxY),
+            depth_ + 1
+        );
+
+        // Northeast (top-right)
+        ne_ = std::make_unique<QuadTree>(
+            BoundingBox(cx, cy, bounds_.maxX, bounds_.maxY),
+            depth_ + 1
+        );
+
+        // Southwest (bottom-left)
+        sw_ = std::make_unique<QuadTree>(
+            BoundingBox(bounds_.minX, bounds_.minY, cx, cy),
+            depth_ + 1
+        );
+
+        // Southeast (bottom-right)
+        se_ = std::make_unique<QuadTree>(
+            BoundingBox(cx, bounds_.minY, bounds_.maxX, cy),
+            depth_ + 1
+        );
+
+        divided_ = true;
+
+        // Move existing points to children
+        std::vector<Point> oldPoints = std::move(points_);
+        points_.clear();
+
+        for (const auto& point : oldPoints) {
+            if (!nw_->insert(point) && !ne_->insert(point) &&
+                !sw_->insert(point) && !se_->insert(point)) {
+                // Shouldn't happen, but keep point here if it fails
+                points_.push_back(point);
+            }
+        }
+    }
+
+    BoundingBox bounds_;
+    int depth_;
+    bool divided_;
+    std::vector<Point> points_;
+    std::unique_ptr<QuadTree> nw_, ne_, sw_, se_;
+};
+
+} // namespace nitromap

package/ios/Clustering/ClusterEngineWrapper.h

@@ -0,0 +1,58 @@
+#import <Foundation/Foundation.h>
+#import <CoreLocation/CoreLocation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Single marker point returned from clustering
+@interface ClusterMarkerPoint : NSObject
+@property (nonatomic, copy) NSString *markerId;
+@property (nonatomic, assign) double latitude;
+@property (nonatomic, assign) double longitude;
+@end
+
+/// Cluster result containing multiple markers
+@interface ClusterData : NSObject
+@property (nonatomic, assign) double latitude;
+@property (nonatomic, assign) double longitude;
+@property (nonatomic, strong) NSArray<NSString *> *markerIds;
+@property (nonatomic, assign) NSInteger count;
+@property (nonatomic, assign) double iconSize;
+@end
+
+/// Full clustering result
+@interface ClusteringResult : NSObject
+@property (nonatomic, strong) NSArray<ClusterData *> *clusters;
+@property (nonatomic, strong) NSArray<ClusterMarkerPoint *> *singleMarkers;
+@end
+
+/// Objective-C++ wrapper for C++ ClusterEngine.
+/// Pure spatial grouping — no icon dimensions.
+@interface ClusterEngineWrapper : NSObject
+
+- (instancetype)init;
+
+/// Configuration
+- (void)setClusterRadius:(double)radiusPixels;
+- (void)setMinClusterSize:(NSInteger)size;
+- (void)setMaxZoom:(double)zoom;
+
+/// Marker management — only geographic data
+- (void)addMarkerWithId:(NSString *)markerId
+               latitude:(double)latitude
+              longitude:(double)longitude;
+- (void)removeMarkerWithId:(NSString *)markerId;
+- (void)clearMarkers;
+- (NSUInteger)markerCount;
+
+/// Perform clustering
+- (ClusteringResult *)clusterWithMinLat:(double)minLat
+                                 maxLat:(double)maxLat
+                                 minLon:(double)minLon
+                                 maxLon:(double)maxLon
+                                   zoom:(double)zoom
+                               mapWidth:(double)mapWidth
+                              mapHeight:(double)mapHeight;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Clustering/ClusterEngineWrapper.mm

@@ -0,0 +1,142 @@
+#import "ClusterEngineWrapper.h"
+#include "ClusterEngine.hpp"
+
+using namespace nitromap;
+
+// MARK: - ClusterMarkerPoint
+
+@implementation ClusterMarkerPoint
+@end
+
+// MARK: - ClusterData
+
+@implementation ClusterData
+@end
+
+// MARK: - ClusteringResult
+
+@implementation ClusteringResult
+@end
+
+// MARK: - ClusterEngineWrapper
+
+@interface ClusterEngineWrapper () {
+    std::unique_ptr<ClusterEngine> _engine;
+}
+@end
+
+@implementation ClusterEngineWrapper
+
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+        _engine = std::make_unique<ClusterEngine>();
+    }
+    return self;
+}
+
+- (void)setClusterRadius:(double)radiusPixels {
+    if (_engine) {
+        _engine->setClusterRadius(radiusPixels);
+    }
+}
+
+- (void)setMinClusterSize:(NSInteger)size {
+    if (_engine) {
+        _engine->setMinClusterSize(static_cast<int>(size));
+    }
+}
+
+- (void)setMaxZoom:(double)zoom {
+    if (_engine) {
+        _engine->setMaxZoom(zoom);
+    }
+}
+
+- (void)addMarkerWithId:(NSString *)markerId
+               latitude:(double)latitude
+              longitude:(double)longitude {
+    if (_engine && markerId) {
+        MarkerPoint marker(
+            [markerId UTF8String],
+            latitude,
+            longitude
+        );
+        _engine->addMarker(marker);
+    }
+}
+
+- (void)removeMarkerWithId:(NSString *)markerId {
+    if (_engine && markerId) {
+        _engine->removeMarker([markerId UTF8String]);
+    }
+}
+
+- (void)clearMarkers {
+    if (_engine) {
+        _engine->clearMarkers();
+    }
+}
+
+- (NSUInteger)markerCount {
+    if (_engine) {
+        return _engine->markerCount();
+    }
+    return 0;
+}
+
+/// Helper to convert C++ Cluster vector to NSArray<ClusterData*>
+static NSArray<ClusterData *> *convertClusters(const std::vector<Cluster>& cppClusters) {
+    NSMutableArray<ClusterData *> *clusters = [NSMutableArray arrayWithCapacity:cppClusters.size()];
+    for (const auto& cluster : cppClusters) {
+        ClusterData *clusterData = [[ClusterData alloc] init];
+        clusterData.latitude = cluster.latitude;
+        clusterData.longitude = cluster.longitude;
+        clusterData.count = cluster.count;
+        clusterData.iconSize = Cluster::iconSize(cluster.count);
+
+        NSMutableArray<NSString *> *markerIds = [NSMutableArray arrayWithCapacity:cluster.markerIds.size()];
+        for (const auto& markerId : cluster.markerIds) {
+            [markerIds addObject:[NSString stringWithUTF8String:markerId.c_str()]];
+        }
+        clusterData.markerIds = markerIds;
+        [clusters addObject:clusterData];
+    }
+    return clusters;
+}
+
+- (ClusteringResult *)clusterWithMinLat:(double)minLat
+                                 maxLat:(double)maxLat
+                                 minLon:(double)minLon
+                                 maxLon:(double)maxLon
+                                   zoom:(double)zoom
+                               mapWidth:(double)mapWidth
+                              mapHeight:(double)mapHeight {
+    ClusteringResult *result = [[ClusteringResult alloc] init];
+    result.clusters = @[];
+    result.singleMarkers = @[];
+
+    if (!_engine) {
+        return result;
+    }
+
+    ClusterResult cppResult = _engine->cluster(
+        minLat, maxLat, minLon, maxLon,
+        zoom, mapWidth, mapHeight
+    );
+
+    result.clusters = convertClusters(cppResult.clusters);
+
+    NSMutableArray<ClusterMarkerPoint *> *singleMarkers = [NSMutableArray arrayWithCapacity:cppResult.singleMarkers.size()];
+    for (const auto& marker : cppResult.singleMarkers) {
+        ClusterMarkerPoint *point = [[ClusterMarkerPoint alloc] init];
+        point.markerId = [NSString stringWithUTF8String:marker.id.c_str()];
+        point.latitude = marker.latitude;
+        point.longitude = marker.longitude;
+        [singleMarkers addObject:point];
+    }
+    result.singleMarkers = singleMarkers;
+
+    return result;
+}
+@end