Python in Blender 2.8 - testing if two objects overlap in the XY Plane?

Question

In Python is there a way to test if two objects overlap?

I am somewhat randomizing the location of two objects and I need to make sure that they do not overlap.

I have spent several hours (without success) trying to come up with my own algorithm, but I am now wondering if maybe I can use an existing function instead...

Thanks in advance for your suggestions!

Answer 1

There is a Python API to do that. BVHTree.overlap

It is nearly direct, we just need to convert objects vertices in world coordinates:

import bpy
from mathutils.bvhtree import BVHTree

# Get the objects
obj1 = bpy.data.objects["Cube"]
obj2 = bpy.data.objects["Suzanne"]

# Get their world matrix
mat1 = obj1.matrix_world
mat2 = obj2.matrix_world

# Get the geometry in world coordinates
vert1 = [mat1 @ v.co for v in obj1.data.vertices] 
poly1 = [p.vertices for p in obj1.data.polygons]

vert2 = [mat2 @ v.co for v in obj2.data.vertices] 
poly2 = [p.vertices for p in obj2.data.polygons]

# Create the BVH trees
bvh1 = BVHTree.FromPolygons( vert1, poly1 )
bvh2 = BVHTree.FromPolygons( vert2, poly2 )

# Test if overlap
if bvh1.overlap( bvh2 ):
    print( "Overlap" )
else:
    print( "No overlap" )

Answer 2

With all the objects being same-sized cubes on the same Z, you only need to worry about XY. Three possible levels to consider going about this, in increasing order of complexity:

1. Just rough it with circle separation. If you treat each object as if it were a circle, no Z-rotation will matter. A cube with half-width ('radius') 1 will fit inside a circle of radius sqrt(2) - with its corners touching that circle. In that case, the cheap and nasty quick way to detect all these sorts of overlaps is just using the distance formula between the object centers to see if that distance is less than two of these radii. Like...

   import bpy
   from math import sqrt
   
   def dist(a, b):
       dx = a.location[0] - b.location[0]
       dy = a.location[1] - b.location[1]
       return sqrt(dx*dx + dy*dy)
   
   minDist = 2 * circRadius
   
   cubes = [ob for ob in bpy.data.objects if ob.name.startswith("Cube")]
   
   for cube in cubes:
       for other in cubes:
           if other != cube:
               if dist(cube, other) < minDist:
                   print("%s and %s overlap." % (cube.name, other.name))
   

Note that this will report false positive overlaps on cubes that are closely aligned and close by each other, not touching, but still within the approximate circles.

2. If you want to get more 'proper' or accurate, that starts to get more into 'collision detection' topics. You may want to read up on how games check for overlaps, eg SAT (the separating axis theorem).

3. Blender definitely has utilities for doing this sort of thing internally. I don't know its internals well enough to know what's all in there, having not done this exact thing before, but it sounds like a common need. The boolean tool is bound to detect things exactly. Even just testing this basic stuff, I noticed in the Scripting workspace that there's internal modules like mathutils, mathutils.geometry, and that objects have functions such as closest_point_on_mesh, ray_cast, and so on. Familiarizing yourself with these and searching through/reading the API docs will pay dividends, if you need a more exact solution. For example, at a glance I also see spatial partitioning helpers such as mathutils.bvhtree, mathutils.kdtree, and others.

Answer 3

This link helped me alot , but addinf depsgraph helped me after using modifiers

    depsgraph = bpy.context.evaluated_depsgraph_get()
    
    
    #create bmesh objects
    bm1 = bmesh.new()
    bm2 = bmesh.new()
    
    #fill bmesh data from objects
    object_eval = obj1.evaluated_get(depsgraph)
    mesh_from_eval_obj1 = object_eval.to_mesh()
    bm1.from_mesh(mesh_from_eval_obj1)
    
    
    object_eval = obj2.evaluated_get(depsgraph)
    mesh_from_eval_obj2 = object_eval.to_mesh()
    bm2.from_mesh(mesh_from_eval_obj2)         

    #transform it here:
    bm1.transform(obj1.matrix_world)
    bm2.transform(obj2.matrix_world) 
    
    

    #make BVH tree from BMesh of objects
    obj_now_BVHtree = BVHTree.FromBMesh(bm1)
    obj_next_BVHtree = BVHTree.FromBMesh(bm2)           

    #get intersecting pairs
    inter = obj_now_BVHtree.overlap(obj_next_BVHtree)

    print("i got this far 1")

    #if list is empty, no objects are touching
    if inter != []:
        print(obj1.name  + " and " +obj2.name + " are touching!")
    else:
        print(obj1.name + " and " + obj2.name + " NOT touching!")
    
    return 0