The rotation matrix from one vector to another in 2D space

We may need to get the rotation matrix from one vector to another in 2D space, for example, when working with UV maps. This is often necessary to adjust one UV island to another.

.blend file on Patreon

To calculate the rotation matrix between two available vectors, first get the angle between these vectors.:

angle = src_vector.angle(dest_vector)

1	angle = src_vector.angle(dest_vector)

The angle is calculated in radians.

Then we need to understand in which direction we need to rotate. In 2D space, there can be two variants – the original vector is located “above” the second, so we need to rotate counterclockwise, or, if it is “below” – we need to rotate clockwise.

We can get the direction of rotation by the sign of the vector cross product of the two original vectors.

sign = src_vector.cross(dest_vector)

1	sign = src_vector.cross(dest_vector)

The cross product of two vectors in 2D space is a number whose sign indicates the rotation direction, which is exactly what we need.

If this number is less than zero, the rotation is clockwise. If the number is greater than zero, the rotation is counterclockwise.

As a result, we can regulate the rotation direction by setting the sign to the rotation angle.

if sign < 0.0:
    angle = -angle

1 2	if sign < 0.0: angle = -angle

Now, using the “Rotation()” method of the “Matrix” object from the “mathutils” module, we can get the rotation matrix.

matrix = Matrix.Rotation(angle, 2, 'Z')

1	matrix = Matrix.Rotation(angle, 2, 'Z')

In the first parameter, we passed the rotation angle. In the second, the size of the matrix – 2×2, which is exactly the matrix we need for rotation in 2D space. In the third parameter, we pass the rotation axis “Z”, which will always be directed perpendicular to the screen.

Let’s put everything together in one function.

def rotation_matrix(src_vector, dest_vector):
    angle = src_vector.angle(dest_vector)
    sign = src_vector.cross(dest_vector)
    if sign < 0.0:
        angle = -angle
    return Matrix.Rotation(angle, 2, 'Z')

def rotation_matrix(src_vector, dest_vector):

angle = src_vector.angle(dest_vector)

sign = src_vector.cross(dest_vector)

if sign < 0.0:

angle = -angle

return Matrix.Rotation(angle, 2, 'Z')

Let’s check how our function works for rotating a UV island.

For example, let’s assume that the island is rotated vertically, and we need to rotate it parallel to another island, which is rotated at an angle of 45 degrees.

Then the initial and final vectors for rotation will be as follows:

src_vector = Vector((0.0, 1.0))
dest_vector = Vector((1.0, 1.0))

1 2	src_vector = Vector((0.0, 1.0)) dest_vector = Vector((1.0, 1.0))

Based on these vectors, we will get the rotation matrix by calling our function.

rotation_matrix = rotation_matrix(src_vector, dest_vector)

# <Matrix 2x2 ( 0.7071, 0.7071)
#    (-0.7071, 0.7071)>

rotation_matrix = rotation_matrix(src_vector, dest_vector)

# <Matrix 2x2 ( 0.7071, 0.7071)

# (-0.7071, 0.7071)>

Create the bmesh object and get a pointer to the currently active UV-map layer.

bm = bmesh.from_edit_mesh(bpy.context.object.data)
uv_layer = bm.loops.layers.uv.active

1 2	bm = bmesh.from_edit_mesh(bpy.context.object.data) uv_layer = bm.loops.layers.uv.active

Loop through all the selected polygons (for simplicity, let our UV island be selected) and multiply the coordinates of all UV points by the resulting matrix.

for face in (_face for _face in bm.faces if _face.select):
    for loop in face.loops:
        loop[uv_layer].uv = rotation_matrix @ loop[uv_layer].uv

for face in (_face for _face in bm.faces if _face.select):

for loop in face.loops:

loop[uv_layer].uv = rotation_matrix @ loop[uv_layer].uv

And return the updated data from bmesh object back to the common scene mesh.

bmesh.update_edit_mesh(bpy.context.object.data)
bm.free()

1 2	bmesh.update_edit_mesh(bpy.context.object.data) bm.free()

As we can see, the entire selected island of the UV-Map has rotated exactly as we need – parallel to the other island.