@buley/hexgrid-3d 3.2.3 → 3.3.0

package/dist/math/SpatialIndex.js

@@ -1,36 +1,176 @@
 export class KDTree {
-    constructor(points, data) {
-        this.points = points;
-        this.data = data;
+    constructor(dimensions) {
+        this.root = null;
+        this.dimensions = dimensions;
     }
-    static build(points, data, _dimensions) {
-        return new KDTree(points, data);
+    static build(points, data) {
+        if (points.length !== data.length) {
+            throw new Error('points and data arrays must have the same length');
+        }
+        if (points.length === 0) {
+            const tree = new KDTree(0);
+            return tree;
+        }
+        const dimensions = points[0].length;
+        const tree = new KDTree(dimensions);
+        const indices = points.map((_, i) => i);
+        tree.root = tree.buildRecursive(points, data, indices, 0);
+        return tree;
+    }
+    static fromVector3(vectors, data) {
+        const points = vectors.map((v) => [v.x, v.y, v.z]);
+        return KDTree.build(points, data);
+    }
+    static fromVector2(vectors, data) {
+        const points = vectors.map((v) => [v.x, v.y]);
+        return KDTree.build(points, data);
+    }
+    buildRecursive(points, data, indices, depth) {
+        if (indices.length === 0)
+            return null;
+        const dim = depth % this.dimensions;
+        indices.sort((a, b) => points[a][dim] - points[b][dim]);
+        const mid = Math.floor(indices.length / 2);
+        const midIndex = indices[mid];
+        return {
+            point: points[midIndex],
+            data: data[midIndex],
+            splitDimension: dim,
+            left: this.buildRecursive(points, data, indices.slice(0, mid), depth + 1),
+            right: this.buildRecursive(points, data, indices.slice(mid + 1), depth + 1),
+        };
+    }
+    insert(point, data) {
+        if (this.dimensions === 0) {
+            this.dimensions = point.length;
+        }
+        this.root = this.insertRecursive(this.root, point, data, 0);
+    }
+    insertRecursive(node, point, data, depth) {
+        if (node === null) {
+            return {
+                point,
+                data,
+                left: null,
+                right: null,
+                splitDimension: depth % this.dimensions,
+            };
+        }
+        const dim = node.splitDimension;
+        if (point[dim] < node.point[dim]) {
+            node.left = this.insertRecursive(node.left, point, data, depth + 1);
+        }
+        else {
+            node.right = this.insertRecursive(node.right, point, data, depth + 1);
+        }
+        return node;
+    }
+    nearestNeighbor(target) {
+        if (this.root === null)
+            return null;
+        const best = { node: null, distance: Infinity };
+        this.nearestRecursive(this.root, target, best);
+        if (best.node === null)
+            return null;
+        return { data: best.node.data, distance: best.distance };
+    }
+    nearestRecursive(node, target, best) {
+        if (node === null)
+            return;
+        const dist = KDTree.distance(node.point, target);
+        if (dist < best.distance) {
+            best.distance = dist;
+            best.node = node;
+        }
+        const dim = node.splitDimension;
+        const diff = target[dim] - node.point[dim];
+        const first = diff < 0 ? node.left : node.right;
+        const second = diff < 0 ? node.right : node.left;
+        this.nearestRecursive(first, target, best);
+        if (Math.abs(diff) < best.distance) {
+            this.nearestRecursive(second, target, best);
+        }
     }
     kNearest(target, k) {
-        const results = this.points.map((point, index) => ({
-            data: this.data[index],
-            distance: KDTree.distance(point, target),
-        }));
-        return results.sort((a, b) => a.distance - b.distance).slice(0, k);
+        if (k <= 0)
+            return [];
+        const results = [];
+        this.collectAll(this.root, target, results);
+        results.sort((a, b) => a.distance - b.distance);
+        return results.slice(0, k);
     }
     rangeQuery(target, radius) {
-        return this.points
-            .map((point, index) => ({
-            data: this.data[index],
-            distance: KDTree.distance(point, target),
-        }))
-            .filter((result) => result.distance <= radius);
+        const results = [];
+        this.rangeRecursive(this.root, target, radius, results);
+        return results;
+    }
+    rangeRecursive(node, target, radius, results) {
+        if (node === null)
+            return;
+        const dist = KDTree.distance(node.point, target);
+        if (dist <= radius) {
+            results.push({ data: node.data, distance: dist });
+        }
+        const dim = node.splitDimension;
+        const diff = target[dim] - node.point[dim];
+        const first = diff < 0 ? node.left : node.right;
+        const second = diff < 0 ? node.right : node.left;
+        this.rangeRecursive(first, target, radius, results);
+        if (Math.abs(diff) <= radius) {
+            this.rangeRecursive(second, target, radius, results);
+        }
+    }
+    boxQuery(min, max) {
+        const results = [];
+        this.boxRecursive(this.root, min, max, results);
+        return results;
+    }
+    boxRecursive(node, min, max, results) {
+        if (node === null)
+            return;
+        let inside = true;
+        for (let i = 0; i < node.point.length; i++) {
+            if (node.point[i] < min[i] || node.point[i] > max[i]) {
+                inside = false;
+                break;
+            }
+        }
+        if (inside) {
+            const dist = KDTree.distance(node.point, min);
+            results.push({ data: node.data, distance: dist });
+        }
+        const dim = node.splitDimension;
+        if (min[dim] <= node.point[dim]) {
+            this.boxRecursive(node.left, min, max, results);
+        }
+        if (max[dim] >= node.point[dim]) {
+            this.boxRecursive(node.right, min, max, results);
+        }
+    }
+    collectAll(node, target, results) {
+        if (node === null)
+            return;
+        results.push({
+            data: node.data,
+            distance: KDTree.distance(node.point, target),
+        });
+        this.collectAll(node.left, target, results);
+        this.collectAll(node.right, target, results);
     }
     static distance(a, b) {
-        const dx = a[0] - b[0];
-        const dy = a[1] - b[1];
-        return Math.sqrt(dx * dx + dy * dy);
+        let sum = 0;
+        for (let i = 0; i < a.length; i++) {
+            const d = a[i] - b[i];
+            sum += d * d;
+        }
+        return Math.sqrt(sum);
     }
 }
 export class SpatialHashGrid {
-    constructor(cellSize, _dimensions) {
+    constructor(cellSize, dimensions = 3) {
         this.grid = new Map();
         this.cellSize = cellSize;
+        this.dimensions = dimensions;
     }
     insert(position, data) {
         const key = this.keyFor(position);
@@ -38,6 +178,28 @@ export class SpatialHashGrid {
         bucket.push({ data, position });
         this.grid.set(key, bucket);
     }
+    insertAll(entries) {
+        for (const entry of entries) {
+            this.insert(entry.position, entry.data);
+        }
+    }
+    remove(position, data) {
+        const key = this.keyFor(position);
+        const bucket = this.grid.get(key);
+        if (!bucket)
+            return false;
+        const index = bucket.findIndex((entry) => entry.data === data && this.positionsEqual(entry.position, position));
+        if (index === -1)
+            return false;
+        bucket.splice(index, 1);
+        if (bucket.length === 0) {
+            this.grid.delete(key);
+        }
+        return true;
+    }
+    clear() {
+        this.grid.clear();
+    }
     query(position, radius) {
         const cellsToCheck = this.nearbyKeys(position, radius);
         const results = [];
@@ -46,30 +208,74 @@ export class SpatialHashGrid {
             if (!bucket)
                 continue;
             for (const entry of bucket) {
-                const distance = Math.hypot(entry.position[0] - position[0], entry.position[1] - position[1]);
-                if (distance <= radius) {
+                const dist = this.distance(entry.position, position);
+                if (dist <= radius) {
                     results.push(entry);
                 }
             }
         }
         return results;
     }
+    nearest(position, searchRadius) {
+        const candidates = this.query(position, searchRadius);
+        if (candidates.length === 0)
+            return null;
+        let bestEntry = null;
+        let bestDist = Infinity;
+        for (const entry of candidates) {
+            const dist = this.distance(entry.position, position);
+            if (dist < bestDist) {
+                bestDist = dist;
+                bestEntry = entry;
+            }
+        }
+        return bestEntry;
+    }
+    positionsEqual(a, b) {
+        if (a.length !== b.length)
+            return false;
+        for (let i = 0; i < a.length; i++) {
+            if (a[i] !== b[i])
+                return false;
+        }
+        return true;
+    }
+    distance(a, b) {
+        let sum = 0;
+        for (let i = 0; i < a.length; i++) {
+            const d = a[i] - b[i];
+            sum += d * d;
+        }
+        return Math.sqrt(sum);
+    }
     keyFor(position) {
-        const x = Math.floor(position[0] / this.cellSize);
-        const y = Math.floor(position[1] / this.cellSize);
-        return `${x},${y}`;
+        const parts = [];
+        for (let i = 0; i < this.dimensions; i++) {
+            parts.push(Math.floor((position[i] ?? 0) / this.cellSize));
+        }
+        return parts.join(',');
     }
     nearbyKeys(position, radius) {
-        const minX = Math.floor((position[0] - radius) / this.cellSize);
-        const maxX = Math.floor((position[0] + radius) / this.cellSize);
-        const minY = Math.floor((position[1] - radius) / this.cellSize);
-        const maxY = Math.floor((position[1] + radius) / this.cellSize);
+        const mins = [];
+        const maxs = [];
+        for (let i = 0; i < this.dimensions; i++) {
+            const val = position[i] ?? 0;
+            mins.push(Math.floor((val - radius) / this.cellSize));
+            maxs.push(Math.floor((val + radius) / this.cellSize));
+        }
         const keys = [];
-        for (let x = minX; x <= maxX; x++) {
-            for (let y = minY; y <= maxY; y++) {
-                keys.push(`${x},${y}`);
+        const coords = new Array(this.dimensions).fill(0);
+        const generate = (dim) => {
+            if (dim === this.dimensions) {
+                keys.push(coords.join(','));
+                return;
             }
-        }
+            for (let v = mins[dim]; v <= maxs[dim]; v++) {
+                coords[dim] = v;
+                generate(dim + 1);
+            }
+        };
+        generate(0);
         return keys;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buley/hexgrid-3d",
-  "version": "3.2.3",
+  "version": "3.3.0",
   "description": "3D hexagonal grid visualization component for React",
   "type": "module",
   "main": "./dist/index.js",
@@ -67,7 +67,8 @@
   "peerDependencies": {
     "next": "^14.0.0",
     "react": "^18.0.0",
-    "react-dom": "^18.0.0"
+    "react-dom": "^18.0.0",
+    "three": "^0.183.1"
   },
   "devDependencies": {
     "@happy-dom/global-registrator": "^20.3.3",
@@ -77,6 +78,7 @@
     "@testing-library/user-event": "^14.6.1",
     "@types/jest": "^29.5.14",
     "@types/react": "^18.3.27",
+    "@types/three": "^0.183.1",
     "@types/react-dom": "^18.3.7",
     "happy-dom": "^20.3.3",
     "jest": "^29.7.0",