Optional
maxEntries:
number
An optional argument to RBush defines the maximum
number of entries in a tree node. 9 (used
by default) is a reasonable choice for most
applications. Higher value means faster insertion and
slower search, and vice versa.
Returns true if there are any items
intersecting the given bounding box, otherwise
false.
The bounding box in which to search.
Compares the minimum x coordinate of two items. Returns -1
if a's x-coordinate is smaller, 1 if
b's x coordinate is smaller, or 0 if
they're equal.
By default, RBush assumes the format of data
points to be an object with minX,
minY, maxX, and maxY.
However, you can specify a custom item format by overriding
toBBox(), compareMinX(), and
compareMinY().
class MyRBush<T> extends RBush<T> {
toBBox([x, y]) { return { minX: x, minY: y, maxX: x, maxY: y }; }
compareMinX(a, b) { return a.x - b.x; }
compareMinY(a, b) { return a.y - b.y; }
}
const tree = new MyRBush<[number, number]>();
tree.insert([20, 50]); // accepts [x, y] points
Compares the minimum y coordinate of two items. Returns -1
if a's x-coordinate is smaller, 1 if
b's x coordinate is smaller, or 0 if
they're equal.
By default, RBush assumes the format of data
points to be an object with minX,
minY, maxX, and maxY.
However, you can specify a custom item format by overriding
toBBox(), compareMinX(), and
compareMinY().
class MyRBush<T> extends RBush<T> {
toBBox([x, y]) { return { minX: x, minY: y, maxX: x, maxY: y }; }
compareMinX(a, b) { return a.x - b.x; }
compareMinY(a, b) { return a.y - b.y; }
}
const tree = new MyRBush<[number, number]>();
tree.insert([20, 50]); // accepts [x, y] points
Imports previously exported data into the tree (i.e., data
that was emitted by toJSON()).
Importing and exporting as JSON allows you to use RBush on both the server (using Node.js) and the browser combined, e.g. first indexing the data on the server and and then importing the resulting tree data on the client for searching.
Note that the maxEntries option from the
constructor must be the same in both trees for export/import
to work properly.
The previously exported JSON data.
Bulk-inserts the given items into the tree.
Bulk insertion is usually ~2-3 times faster than inserting items one by one. After bulk loading (bulk insertion into an empty tree), subsequent query performance is also ~20-30% better.
Note that when you do bulk insertion into an existing tree, it bulk-loads the given data into a separate tree and inserts the smaller tree into the larger tree. This means that bulk insertion works very well for clustered data (where items in one update are close to each other), but makes query performance worse if the data is scattered.
The items to load.
Removes a previously inserted item, comparing by reference.
To remove all items, use clear().
The item to remove.
Optional
equals:
((a,
b) => boolean)
A custom function that allows comparing by value instead. Useful when you have only a copy of the object you need removed (e.g. loaded from server).
Returns the bounding box for the provided item.
By default, RBush assumes the format of data
points to be an object with minX,
minY, maxX, and maxY.
However, you can specify a custom item format by overriding
toBBox(), compareMinX(), and
compareMinY().
The item whose bounding box should be returned.
class MyRBush<T> extends RBush<T> {
toBBox([x, y]) { return { minX: x, minY: y, maxX: x, maxY: y }; }
compareMinX(a, b) { return a.x - b.x; }
compareMinY(a, b) { return a.y - b.y; }
}
const tree = new MyRBush<[number, number]>();
tree.insert([20, 50]); // accepts [x, y] points
Exports the tree's contents as a JSON object.
Importing and exporting as JSON allows you to use RBush on both the server (using Node.js) and the browser combined, e.g. first indexing the data on the server and and then importing the resulting tree data on the client for searching.
Note that the maxEntries option from the
constructor must be the same in both trees for export/import
to work properly.
Generated using TypeDoc
Constructs an
RBush, a high-performance 2D spatial index for points and rectangles. Based on an optimized R-tree data structure with bulk-insertion support.