To work with geometry in Blender using the Python API, it is often necessary to find the center point of a polygon. This may be necessary for organizing various bindings, aligning objects along a polygon, positioning, and in many other cases.
.blend file on Patreon
For example, let’s take the simplest case – a plane (shift + a – Mesh – Plane), which consists of one polygon. Let it be the active object of the scene.
|
1 2 3 |
active_object = bpy.context.active_object # bpy.data.objects['Plane'] |
Let’s find the coordinates of the center of the plane polygon.
We can get a pointer to the single polygon that makes up our plane through the “data.polygons” property of the object. And through the polygon, we can get pointers to the corner vertices that actually form it.
|
1 2 3 4 5 |
bpy.context.object.data.polygons[0] # bpy.data.meshes['Plane'].polygons[0] bpy.context.object.data.polygons[0].vertices[:] # (0, 1, 3, 2) |
However, this way we do not get pointers to the vertices themselves, but only their indices. To get vertices by their indices, we can use the “vertices” property of the object. And get the coordinates of the vertices through their “co” property.
|
1 2 3 |
vertices_co = [bpy.context.active_object.data.vertices[v_id].co for v_id in bpy.context.active_object.data.polygons[0].vertices] # [Vector((-1.0, -1.0, 0.0)), Vector((1.0, -1.0, 0.0)), Vector((1.0, 1.0, 0.0)), Vector((-1.0, 1.0, 0.0))] |
The coordinates we got are local. To get to global coordinates, we need to multiply them by the object’s world transformation matrix.
|
1 2 3 |
vertices_co_global = [active_object.matrix_world @ _co for _co in vertices_co] # [Vector((2.3434910774230957, -1.6085408926010132, 1.797777771949768)), Vector((4.28888463973999, -1.1446053981781006, 1.8122127056121826)), Vector((3.869182586669922, 0.5870418548583984, 2.720644235610962)), Vector((1.9237890243530273, 0.12310633063316345, 2.706209421157837))] |
Now let’s define a function that will get a list of coordinates as input and return the center point calculated for them.
|
1 2 3 4 5 6 7 8 9 |
def centroid(vertices): x_list = [vertex[0] for vertex in vertices] y_list = [vertex[1] for vertex in vertices] z_list = [vertex[2] for vertex in vertices] length = len(vertices) x = sum(x_list) / length y = sum(y_list) / length z = sum(z_list) / length return Vector((x, y, z)) |
In this function, we first sum up all the coordinates separately for each of the coordinate axes, and then divide by the number of vertices. The average value for each axis gives us the overall center point of the polygon, which we return as a vector.
To get the center point of our polygon, we call the function and pass it the previously obtained vertex coordinates in parameter.
|
1 2 3 |
center = centroid(vertices_co_global) # <Vector (3.1063, -0.5107, 3.1063)> |
To check it, let’s place the 3D cursor at the point with the obtained coordinates.
|
1 |
bpy.context.scene.cursor.location = center |
As we can see, the cursor has moved exactly to the center of the plane.
Bonus: the center of a polygon in 2D space
If we need to determine the center of a polygon in 2D space, for example, when working with UV maps, we can easily modify our function. We just need to remove the Z-coordinates from the calculations.
|
1 2 3 4 5 6 7 |
def centroid2d(vertices): x_list = [vertex[0] for vertex in vertices] y_list = [vertex[1] for vertex in vertices] length = len(vertices) x = sum(x_list) / length y = sum(y_list) / length return Vector((x, y)) |