octree | Fast radius neighbor search with an Octree

The error message is a clue. Your method is returning a vector, so you can't return a pointer.

You can either change the return type of your method or create and return an empty vector.

Without knowing the structure of your data, I don't have an absolute answer for how to return the parent, but you could either retain parent knowledge in your class or pass the parent to the method as an optional argument.

Two important points could explain you observation:

• The first CUDA function call implicitly initialize the runtime (quite slow).
• The actual content of the arrays to be sorted can/often impact performance of a sort (regarding the algorithm used in the Thrust implementation). Once data are sorted, they can be sorted faster because they are already sorted.
• Thrust make few synchronizations (ie. it calls cudaDeviceSynchronize) in many provided functions in order to ensure returned data transferred from the GPU can be safely read from the CPU side. It also internally use such kind of synchronization when multiple interdependent CUDA kernels are submitted regarding the result of the computed data (you can see that with the Nvidia profiler). Regarding the previous asynchronous CUDA calls made before this function, the over-synchronization can add an unwanted overhead.

I made what i wanted, size can be computed from amount of splits. https://github.com/markusgod/cubic-octree

What is the correct way to clear a class instance of its recursive pointers to a same class instance

It depends on what "clearing" means in the context.

You should consider using for instead of foreach for Lists, as explained e.g. here when you code for performance. Still, I think your problem is more a structural one than related to such details.

I would advise you to have a look at Quadtrees, for example by this implementation to split your total area into segments and associate each particle with a segment. To find neighbours you just have to traverse the tree.

As you are calling the method erase that accepts only one iterator (not a range of iterators) and the algorithm std::remove_if is called with the second iterator of the range of container elements specified like

Assuming that what you call "resource consuming" is too high running-time, the number of triangles must be significant. So the first thing to do is to reduce the number of triangles to be tested against.

You mentioned oct-trees. More generally, a hierarchy of bounding volumes is the way to go. (https://en.wikipedia.org/wiki/Bounding_volume_hierarchy.) Speedups will be tremendous for million triangles. In your particular case, I would probably opt for a binary tree of bounding spheres.

Note that before implementing this, you will already obtain a speedup by precomputing the bounding sphere of every triangle (the center of the sphere is the center of the circumscribed circle, i.e. the intersection of the mediator planes and the plane of the triangle). Then non-intersecting triangles are detected by comparing the distance between the centers to the sum of radii.

Regarding the exact intersection test between the sphere and a triangle, I am afraid that there is no free lunch. Using the "inflating/deflating" method, the center of the sphere can be inside either the right prism over the triangle, one of three truncated cylindres around the edges or one of three spheres around the vertices.

Whatever approach you take, you will have to deal with that complexity of the case analysis.

I asked the same question in forums.xamarin.com and someone answered the question and I'll share it here :

In iOS every texture needs to have a power of two resolution, like 256 x 256 or 1024 x 512. Check if that is the issue. Additionally check that your using the latest UrhoSharp version.

Also make sure that the image is set as BundleResource in the iOS project.

In your file dev/src_client/CMakeLists.txt, this line: