QuadTrees | PHP Implementation of QuadTree datastructure | Dataset library

by MarkBaker PHP Version: Current License: MIT

X-Ray Key Features Code Snippets Community Discussions(7)Vulnerabilities Install Support

kandi X-RAY | QuadTrees Summary

QuadTrees is a PHP library typically used in Artificial Intelligence, Dataset applications. QuadTrees has no bugs, it has no vulnerabilities, it has a Permissive License and it has low support. You can download it from GitHub.

PHP Implementation of QuadTree datastructure

Support

Quality

Security

License

Reuse

Support

QuadTrees has a low active ecosystem.

It has 14 star(s) with 7 fork(s). There are 2 watchers for this library.

It had no major release in the last 6 months.

There are 1 open issues and 2 have been closed. There are no pull requests.

It has a neutral sentiment in the developer community.

The latest version of QuadTrees is current.

Quality

QuadTrees has no bugs reported.

Security

QuadTrees has no vulnerabilities reported, and its dependent libraries have no vulnerabilities reported.

License

QuadTrees is licensed under the MIT License. This license is Permissive.

Permissive licenses have the least restrictions, and you can use them in most projects.

Reuse

QuadTrees releases are not available. You will need to build from source code and install.

Installation instructions are not available. Examples and code snippets are available.

Top functions reviewed by kandi - BETA

kandi has reviewed QuadTrees and discovered the below as its top functions. This is intended to give you an instant insight into QuadTrees implemented functionality, and help decide if they suit your requirements.

Segment the bounding of the bounding box
Insert a point in the bucket
Searches for all points within a boundary .
Load a class
Register the autoloader
Determine if this bounding box is composed of bounds .
Returns whether the bounding box encompasses the bounding box .
Checks if this bounding box intersecting boundaries .
Get longitude .
Get the latitude .

Get all kandi verified functions for this library.

QuadTrees Key Features

No Key Features are available at this moment for QuadTrees.

QuadTrees Examples and Code Snippets

No Code Snippets are available at this moment for QuadTrees.

Community Discussions

Trending Discussions on QuadTrees

Using a spatial index to find points within range of each other

Subdivide Quadtree without the new operator

Are Linear Quadtrees the most efficient way to store grid division data

d3 v4 voronoi find nearest neighbours in a scatterplot svg filled with (dots / circles)

Do quadtrees automatically self sort?

Most efficient way to select point with the most surrounding points

QUESTION

Suggested way to print a custom quadtree in Haskell?

Asked 2020-Aug-30 at 12:26

Using quadtrees in a project like so:

...

ANSWER

Answered 2020-Aug-30 at 12:26

If your aim is just to get a well-interpretable graphical view, I recommend not going through plaintext at all but instead generating HTML and let your browser take care for laying it out in a convenient way. A particularly easy library with which to do that is yeamer (warning: it has quite heavy dependencies)

Source https://stackoverflow.com/questions/63656789

QUESTION

Using a spatial index to find points within range of each other

Asked 2019-Apr-05 at 14:21

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.

...

ANSWER

Answered 2019-Apr-03 at 14:30

A standard approach to this is the "sweep and prune" algorithm. Sort all the points by X coordinate, then iterate through them. As you do, maintain the lowest index of the point which is within the threshold distance (in X) of the current point. The points within that range are candidates for merging. You then do the same thing sorting by Y. Then you only need to check the Euclidean distance for those pairs which showed up in both the X and Y scans.

Note that with your current union-find approach, you can end up unioning points which are quite far from each other, if there are a bunch of nearby points "bridging" them. So your basic approach -- of unioning groups of points based on proximity -- can induce an arbitrary amount of distance error, not just the threshold distance.

Source https://stackoverflow.com/questions/55497134

QUESTION

Subdivide Quadtree without the new operator

Asked 2019-Jan-23 at 15:50

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 :

...

ANSWER

Answered 2019-Jan-23 at 15:50

I want to demonstrate a very simple memory pool. (In my comment, I recommended a list of vectors for this, and this is what I want to elaborate below.)

At first, I make some constraints which are used to simplify the concept:

Nodes provide a default constructor.
No inplace construction of nodes is required.
Nodes are created consecutively and freed all at once.

So, I start with a template class PoolT:

Source https://stackoverflow.com/questions/54325079

QUESTION

Are Linear Quadtrees the most efficient way to store grid division data

Asked 2018-May-31 at 13:57

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?

...

ANSWER

Answered 2018-May-31 at 13:57

I normally don't answer my own questions, but seeing that this question is still getting views with no responses I'll give my answer.

After almost 2 days of research I now understand much better what Linear Quadtrees are.

A Linear Quadtree is simply an array representation of a quad tree written in a specific traversal order.

Basically just choose a specific "order" you want to read the quad tree in and save it's values in that order.

So for example in the graph used in the question there are 4 levels of stacks because there are 4 block-sizes (32, 16, 8, 4).

Each stack can be read in order.

So assuming the entire graph was filled with a 32x32 block the "root" of the tree (the first node we read) would be filled with a "1" to represent that we need that block while all the children of the root would be "0" as there are no more blocks needed because graph is full.

So the linear quadtree would look like this in binary "10000000000000.... (84 0's)"

This is obviously more than the 7 bits I mentioned in my question, but that's because there is no compression applied to this linear quad tree.

I really asked the wrong question. You need linear quad trees to represent a quad tree, so I really should have been asked "What is the best way to compress a linear quad tree", and the idea I gave in my question is the best way.

Create a lookup table with all the different quad-tree combinations and use a number to represent each combination.

Source https://stackoverflow.com/questions/50594994

QUESTION

d3 v4 voronoi find nearest neighbours in a scatterplot svg filled with (dots / circles)

Asked 2018-Mar-12 at 21:18

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

...

ANSWER

Answered 2018-Mar-12 at 19:10

voronoiDiagram.find(y, x, r) will only ever return, at most, once cell. From the API documentation:

Returns the nearest site to point [x, y]. If radius is specified, only sites within radius distance are considered. (link)

I've previously read that as being plural, apparently I've never looked closely (and I think there is a large amount of utility in being able to find all points within a given radius).

What we can do instead is create a function fairly easily that will:

start with voronoiDiagram.find() to find the cell the point falls in
find the neighbors of the found cell
for each neighbor, see if its point is within the specified radius
if a neighbors point is within the specified radius:
- add the neighbor to a list of cells with points within the specified radius,
- use the neighbor to repeat steps 2 through 4
stop when no more neighbors have been found within the specified radius, (keep a list of already checked cells to ensure none are checked twice).

The snippet below uses the above process (in the function findAll(x,y,r)) to show points within the specified distance as orange, the closest point will be red (I've set the function to differentiate between the two).

Source https://stackoverflow.com/questions/49229484

QUESTION

Do quadtrees automatically self sort?

Asked 2018-Jan-18 at 04:57

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.

...

ANSWER

Answered 2018-Jan-18 at 04:57

There are many ways I've seen people implement quad-trees for objects which move every frame, including using loose quad-trees for that purpose where the nodes are even allowed to have overlapping AABBs which expand and shrink as objects stored in the leaves move around.

That said, I've found it simple enough to update non-loose versions reasonably cheaply (not as cheap as a spatial hash or grid, however, but cheap enough to maintain steady frame rates with a boatload of entities moving around with collision detection).

Simple way is just remove the element from the tree prior to moving it, move it, then reinsert it to the tree. When you remove an element, check the node(s) to which it belongs. If they become empty (no elements stored, no children), then remove them from the parent. If the parent becomes empty (no child nodes stored in that node and, if you store elements in the branches, then no elements in that node), then remove the parent from the grandparent, and repeat.

Trick to making this fast is to avoid excessive memory allocations. It helps if you use a free list for the nodes, e.g. Another way to potentially speed things up is to detect when an object will not move from one node to another.

For example, you can expand an entity's bounding box or sphere by the time step multiplied by its speed and test if that expanded bounding box/sphere overlaps new nodes. If not, you don't need to remove the element from the tree, move it, and reinsert. You can just go ahead and simply move it. Or you can just store its previous position, move it, and then see if it would belong in different nodes. If so, remove the element as though it had the previous position and then reinsert with the new position. I haven't really found this necessary though with the way I can do most of this stuff with just index manipulation and no heap allocations/deallocations.

Source https://stackoverflow.com/questions/48155414

QUESTION

Most efficient way to select point with the most surrounding points

Asked 2017-Jun-11 at 20:05

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

Question

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.

What I've tried

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)?

EDIT

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

(Semi-)Solution

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!

Problem

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.

Refined question

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!

...

ANSWER

Answered 2017-Jun-04 at 05:59

I would start by creating something like a https://en.wikipedia.org/wiki/K-d_tree, where you have a tree with points at the leaves and each node information about its descendants. At each node I would keep a count of the number of descendants, and a bounding box enclosing those descendants.

Now for each point I would recursively search the tree. At each node I visit, either all of the bounding box is within R of the current point, all of the bounding box is more than R away from the current point, or some of it is inside R and some outside R. In the first case I can use the count of the number of descendants of the current node to increase the count of points within R of the current point and return up one level of the recursion. In the second case I can simply return up one level of the recursion without incrementing anything. It is only in the intermediate case that I need to continue recursing down the tree.

So I can work out for each point the number of neighbours within R without checking every other point, and pick the point with the highest count.

If the points are spread out evenly then I think you will end up constructing a k-d tree where the lower levels are close to a regular grid, and I think if the grid is of size A x A then in the worst case R is large enough so that its boundary is a circle that intersects O(A) low level cells, so I think that if you have O(n) points you could expect this to cost about O(n * sqrt(n)).

Source https://stackoverflow.com/questions/44350170

Community Discussions, Code Snippets contain sources that include Stack Exchange Network

Vulnerabilities

No vulnerabilities reported

Install QuadTrees

You can download it from GitHub.
PHP requires the Visual C runtime (CRT). The Microsoft Visual C++ Redistributable for Visual Studio 2019 is suitable for all these PHP versions, see visualstudio.microsoft.com. You MUST download the x86 CRT for PHP x86 builds and the x64 CRT for PHP x64 builds. The CRT installer supports the /quiet and /norestart command-line switches, so you can also script it.

Support

For any new features, suggestions and bugs create an issue on GitHub. If you have any questions check and ask questions on community page Stack Overflow .

Find more information at: