Python: Best particles self-collision / triangle collision algorithm

Question

I'm starting to work on this particle engine for Blender in Python: http://www.youtube.com/watch?v=uoK4QV3jg58&feature=channel_video_title

All data is processed by my script, Blender is just there for the visual. My problem is for now, in the video above, I calculate distance between each particle for all particles to detect if they're colliding with each other.

I'm starting to read about:

• Octree
• kdTree
• BVHTree
• AABBtree
• ...and many more

Kdtree seems to be very efficient for searching nearest neighbours but only for a static cloud. My particles always move and so must regenerate the kdTree each iteration, consuming too much process I think. I read many games use AABB tree. I'm a bit lost... I don't know what to choose. What I want is :

• Detect collision between a very large amount of particles (250 000 or more)
• No need to be realtime (anyway with 250 000 particles it's not really possible). 20min per frame for 2 million particles is not a problem for me.
• My particles are always spheres
• Detect collision between particles and polygonal objects
• Algorithm to reduce distance calculations necessary (avoiding things like calculating all particles for each other particle or polygon even when they're far away)
• My particles are dynamic and my polygon objects can be dynamic or static.

If somebody can tell me what is the best guess and where I can find Python documentation and example for it.

Answer 1

If "everything is dynamic", then you lose the benefits of data structures with fast-lookups and slow-insertions.

Ideally, you can find some structure in your data to simplify the running time. Perhaps the moving polygons all move in the same direction, so you can you use them as a frame of reference, effectively making them static. Perhaps the movements are small, so the data structure can be updated in-place rather than rebuilt from scratch on each pass. Or the particles and polygons have movements confined to small neighborhoods so that the computationally intractable large problem can be reduced to smaller problems.

Saying that "everything moves" without any additional contraint is akin to saying that the data is completely random from iteration-to-iteration; hence, the key to your problem is identifying whether any computation from the previous iteration is reusable. That will dictate the appropriate data structure and algorithm.