KDTree | Simple C++ KD-Tree implementation | Dataset library

There might be away to avoid looping all together that I haven't figured out yet, but an easy solution you can apply is to place your values needed into arrays, and then perform vectorized operations on those arrays. I did some tests and this averaged around 40% decrease in execution time.

The API of scipy's KdTree wants a 2D array of coordinates as input and not any sort of object array. In this array the rows are the points and the cols the coordinates of those points.

In the question you link to, he doesn't mean that there is a third dimension but a third index. Suppose you are looking for a single nearest neighbor and you query using some point, the function will return a distance and an index. The index is a reference into the array with which you built the tree. The distance is the difference in distance between your query point and the tree point.

So to use this tree you could keep two arrays. One with the object coordinates and a second one with the objects. They should be in the same order, so that when a query returns an index, they mean the same thing in both arrays.

PS. This is my first answer, so also be gentle :D

You're almost there :) The problem is that you are using the points in the mesh to build the tree, but then extracting cells. Of course these are unrelated in the sense that indices for points will give you nonsense when applied as indices of cells.

Either you have to extract_points:

Based on feedback from a helpful user, I eventually arrived at a less hack'y solution. Unfortunately, the discussion went AWOL because of an unhelpful user, who responded with pip install -U numpy, waited for me to figure it out, edited their answer and requested I accept it. Upon being denied, the answer and comment thread vanished. I don't even remember your name, helpful user, so I can't credit you for the tip.

Apparently ReadTheDocs uses an old pip, and requiring pip>=19.0 makes scikit-learn not install from source. As such, I added that line to docs/requirements.txt, which I had previously set up to be a ReadTheDocs requirement file. This resulted in some progress - now rather than scikit-learn complaining about numpy, it was numba. Still, some synapses connected, and I just handled any dependency problems that arose via docs/requirements.txt, the final contents of which are:

It's hard to diagnose your problem without the minimal reproducible example. But what I see is that your system has both libGL and libOpenGL. This may mean that libGL is just a proxy for libglvnd and doesn't contain any of the GL API functions.

But you shouldn't rush to link directly to libOpenGL. Different systems may be configured differently. Instead, the correct way of locating OpenGL objects with CMake is to use find_package(OpenGL) and then include OpenGL::GL in your target_link_libraries.

Example dummy project:

• CMakeLists.txt

The result set appears to be stateful - it's always showing you the nearest overall neighbor of all the points. For instance, if you loop from 5 to 10 you get 5 50 for each iteration

Reinitialize the result set each iteration and you'll get your desired behavior:

The function query_ball_point will return the correct set of points for any version of the search tree. The leafsize parameter does not impact the results of the query, only the performance of the results.

Imagine two trees shown below for the same data (but different leafsize parameters) and a query searching for all points inside the red circle.

In both cases, the code will only return the two points that lie inside the red circle. This is done by checking all points in all boxes of the tree that intersect the circle. This leads to a different amount of work (i.e., different performance) in each case. For the left tree (corresponding to a larger leafsize), the algorithm has to check if 13 points are inside the circle (6 in the upper intersecting box and 7 in the lower intersecting box). In the right tree (which has a smaller leaf size), only three points get processed (one in the upper intersecting box and two in the lower intersecting box).

Following this logic, you may think it just makes sense to always use a small leaf size: this will minimize the number of actual comparisons at the end of the algorithm (do decide if the points actually lie in the query region). But it isn't that simple: the smaller leaf size will generate a deeper tree adding cost to the construction time and to the tree traversal time. Getting the right balance of tree-traversal performance with the leaf-level comparisons really depends on the type of data going into the tree and the specific leaf-level comparisons you are doing. Which is why scipy provides the leafsize parameter as an argument so you can tune things to perform best on a particular algorithm.

Here are a few hints:

• Use gcc instead of llvm or clang for painless openmp-support on macOS. Note that apple's default gcc is just an alias for Apple clang as you'll see with gcc --version. You can install the real gcc with homebrew: brew install gcc.

• Then use export CC='gcc-10' (the newest version should be gcc 10.x) inside the same terminal window to use homebrew's gcc temporarily as your C compiler.

• There's no need to set CXXFLAGS or CFLAGS. The required flags are set by distutils/setuptools inside the setup.py.

• You won't be able to compile dmc_cuda_module on macOS 10.14.6. The latest macOS version nvidia offers cuda drivers for is 10.13.6. So you might uncomment this part of the setup.py and hope for the best you don't need this module...

• Some of the Extensions inside the setup.py aren't including the numpy headers while using the numpy C-API. On macOS it's necessary to include the numpy headers for each Extension, see this comment. So you have to add include_dirs=[numpy_include_dir] to those Extensions.

• Edit: As discussed in the chat: The error was due to the conda env ignoring the CC variable. After installing python+pip via homebrew and the required python packages via pip, this answer's steps worked for the OP.

All in all, here's a setup.py that worked for me (macOS 10.5.7, gcc-10):