Aligning one plane to another is a common task in 3D modeling. The easiest way to align planes is by using their normal vectors – we need to rotate the original plane so that its normal vector coincides with the normal vector of the plane for which the alignment is performed. Therefore, the task of rotating one plane to another can be reduced to the problem of rotating the normal vector of the first place to the normal vector of the second plane.
.blend file on Patreon
One of the ways for rotating a vector is to use transformation matrices.
Let’s consider an example of finding a matrix for rotating one vector to another.
We can start from a source object – the first plane
|
1 |
from_object = bpy.data.objects['Plane'] |
We can get the normal to it by finding the cross product for two vectors from its origin to any pair of its vertices.
|
1 |
from_vector = (from_object.data.vertices[0].co).cross(from_object.data.vertices[1].co) |
Since the matrices work relative to the zero point, we need to get the global coordinates of the normal vector by multiplying it by the world matrix of the plane.
|
1 2 3 |
from_vector_co_global = from_object.matrix_world @ from_vector # <Vector (-0.1758, 0.3288, 0.7108)> |
The same for the second plane, to which we need to rotate the first plane
|
1 |
to_object = bpy.data.objects['Plane.001'] |
Get its normal vector in the global coordinate system.
|
1 2 3 4 |
to_vector = (to_object.data.vertices[0].co).cross(to_object.data.vertices[1].co) to_vector_co_global = to_object.matrix_world @ to_vector # <Vector (0.5103, 0.2496, 0.4829)> |
Now we have two vectors. Let’s calculate the transformation matrix for the rotation from the first vector to the second.
We can use some Blender Python API functions for this.
Define a function that will take two vectors as parameters and return the rotation matrix from one vector to the other.
|
1 2 3 4 5 |
def get_matrix_base(src_vector, dest_vector): angle = src_vector.angle(dest_vector) # rad axis = src_vector.cross(dest_vector) axis.normalize() return Matrix.Rotation(angle, 4, axis) |
Here we first find the angle between the two vectors.
Then we determine the axis around which we will rotate the first vector so that it comes to the second. This is very easy to do because these two vectors form the plane in which the rotation will be performed. The rotation axis is the normal to this plane. And as we did before, we can get it through the cross product of two vectors.
And finally, we get the matrix we need by calling the Matrix.Rotation function.
Or we can use an optimized trigonometry function (by Inigo Quilez) to get the rotation matrix.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
def get_matrix_optimized(src_vector, dest_vector): # get transform matrix to rotate one vector to another src_vector.normalize() dest_vector.normalize() v = dest_vector.cross(src_vector) c = dest_vector.dot(src_vector) if isclose(c, -1.0, rel_tol=0.0001): # vectors are collinear and opposite-directional - matrix just for inverse transform_matrix = Matrix( ((-1.0, 0.0, 0.0), (0.0, -1.0, 0.0), (0.0, 0.0, -1.0)) ) else: k = 1.0 / (1.0 + c) transform_matrix = Matrix( ((v.x * v.x * k + c, v.y * v.x * k - v.z, v.z * v.x * k + v.y), (v.x * v.y * k + v.z, v.y * v.y * k + c, v.z * v.y * k - v.x), (v.x * v.z * k - v.y, v.y * v.z * k + v.x, v.z * v.z * k + c)) ) # convert to 4x4 matrix for Blender transformations transform_matrix = transform_matrix.to_4x4() # convert from left-hand orientation to Blender right-hand orientation transform_matrix.transpose() # return final transformation matrix return transform_matrix |
Although it looks more complicated, it performs fewer operations and takes into account the special case when the vectors from the input parameters can be collinear.
To use it in Blender, we need to modify it a bit: since the calculations result in a 3×3 matrix, we need to transform it into the standard Blender transformation matrix – 4×4. Also, all calculations in it are made for the left-hand orientation of the axes, but Blender uses the right-hand one. Therefore, before using the resulting matrix, we need to transpose it.
By calling the first or second function with the previously calculated normal vectors, we will get the transformation matrix we need.
|
1 2 3 4 5 6 |
matrix = get_matrix_optimized(from_vector_co_global, to_vector_co_global) # <Matrix 4x4 ( 0.5614, 0.3388, 0.7550, 0.0000) # (-0.3686, 0.9192, -0.1384, 0.0000) # (-0.7409, -0.2006, 0.6410, 0.0000) # ( 0.0000, 0.0000, 0.0000, 1.0000)> |
Now we can add the resulting matrix to the world transformation matrix of our first plane.
|
1 |
from_object.matrix_world = matrix @ from_object.matrix_world |
And we will see that our first plane will be aligned by the second plane.