QuadTrees | High Performance Quad Tree Implementations for C # ( Point | Dataset library

I'm trying to find a spatial index structure suitable for a particular problem : using a union-find data structure, I want to connect\associate points that are within a certain range of each other. I have a lot of points and I'm trying to optimize an existing solution by using a better spatial index.

Right now, I'm using a simple 2D grid indexing each square of width [threshold distance] of my point map, and I look for potential unions by searching for points in adjacent squares in the grid.

Then I compute the squared Euclidean distance to the adjacent cells combinations, which I compare to my squared threshold, and I use the union-find structure (optimized using path compression and etc.) to build groups of points.

Here is some illustration of the method. The single black points actually represent the set of points that belong to a cell of the grid, and the outgoing colored arrows represent the actual distance comparisons with the outside points.

(I'm also checking for potential connected points that belong to the same cells).

By using this pattern I make sure I'm not doing any distance comparison twice by using a proper "neighbor cell" pattern that doesn't overlap with already tested stuff when I iterate over the grid cells.

Issue is : this approach is not even close to being fast enough, and I'm trying to replace the "spatial grid index" method with something that could maybe be faster.

I've looked into quadtrees as a suitable spatial index for this problem, but I don't think it is suitable to solve it (I don't see any way of performing repeated "neighbours" checks for a particular cell more effectively using a quadtree), but maybe I'm wrong on that.

Therefore, I'm looking for a better algorithm\data structure to effectively index my points and query them for proximity.

Thanks in advance.

In every implementation of Quadtrees I've seen, the subdivision method always uses the new operator to create the child cells.

Is there a way to avoid that? Because I recreate my Quadtree every frame to update it easily, but using new and delete about 200 ~ 300 times per frame is going to kill my performance.

This is my Implementation :

Let's say you have a 32x32 grid that could be randomly subdivided using any of the block sizes below:

32x32, 16x16, 8x8, 4x4

How many times the grid is subdivided and in what way the subdivisions happen is determined at random.

Visually it could look something like this:

This type of data can be represented using a quad tree.

My question is:

If I was trying to use the least amount of bytes possible to represent the graph above, would a Linear Quad-tree be the most efficient way of doing this?

The only other alternative I could think of would be to make all the possible combinations of the graph, and use a single number to represent each combination.

So for the graph there are 4 levels of branching (32x32, 16x16, 8x8, 4x4) this would give us 4^0 + 4^1 + 4^2 + 4^3 possible combinations which is equal to 85 combinations.

Therefore the smallest way I can think of to store the graph would be to use 7 bits (1010101 is the number 85 in binary) to represent the possible combinations.

Would Linear Quadtrees equal this in terms of storage efficiency, or would they take up more or less space?

I am trying to find the nearest neighbors in a scatterplot using the data attached below, with the help of this snippet -

Let's say I have a quadtree. Let's say I have a moving object inside it.

I understand a quadtree auto sorts itself when you add and delete nodes, but what happens when a node, let's say in his update function moves to the left of another unrelated node? Or basically this node teleports?

What happens to the quadtree? Do I need to rebuild it?

I just can't understand in my mind if quadtrees do automatically self sort when you just update a node data, or if I need to rebuild the entire tree when updating the nodes.

N.B: there's a major edit at the bottom of the question - check it out

Say I have a set of points:

I want to find the point with the most points surrounding it, within radius (ie a circle) or within (ie a square) of the point for 2 dimensions. I'll refer to it as the densest point function.

For the diagrams in this question, I'll represent the surrounding region as circles. In the image above, the middle point's surrounding region is shown in green. This middle point has the most surrounding points of all the points within radius and would be returned by the densest point function.

A viable way to solve this problem would be to use a range searching solution; this answer explains further and that it has " worst-case time". Using this, I could get the number of points surrounding each point and choose the point with largest surrounding point count.

However, if the points were extremely densely packed (in the order of a million), as such:

then each of these million points () would need to have a range search performed. The worst-case time , where is the number of points returned in the range, is true for the following point tree types:

• kd-trees of two dimensions (which are actually slightly worse, at ),
• 2d-range trees,
• Quadtrees, which have a worst-case time of

So, for a group of points within radius of all points within the group, it gives complexity of for each point. This yields over a trillion operations!

Any ideas on a more efficient, precise way of achieving this, so that I could find the point with the most surrounding points for a group of points, and in a reasonable time (preferably or less)?

Turns out that the method above is correct! I just need help implementing it.

If I use a 2d-range tree:

• A range reporting query costs , for returned points,
• For a range tree with fractional cascading (also known as layered range trees) the complexity is ,
• For 2 dimensions, that is ,
• Furthermore, if I perform a range counting query (i.e., I do not report each point), then it costs .

I'd perform this on every point - yielding the complexity I desired!

However, I cannot figure out how to write the code for a counting query for a 2d layered range tree.

I've found a great resource (from page 113 onwards) about range trees, including 2d-range tree psuedocode. But I can't figure out how to introduce fractional cascading, nor how to correctly implement the counting query so that it is of O(log n) complexity.

I've also found two range tree implementations here and here in Java, and one in C++ here, although I'm not sure this uses fractional cascading as it states above the countInRange method that

It returns the number of such points in worst case * O(log(n)^d) time. It can also return the points that are in the rectangle in worst case * O(log(n)^d + k) time where k is the number of points that lie in the rectangle.

which suggests to me it does not apply fractional cascading.

To answer the question above therefore, all I need to know is if there are any libraries with 2d-range trees with fractional cascading that have a range counting query of complexity so I don't go reinventing any wheels, or can you help me to write/modify the resources above to perform a query of that complexity?

Also not complaining if you can provide me with any other methods to achieve a range counting query of 2d points in in any other way!