Face location, rotation world matrix with x, y, z and bmesh

Question

I'm trying to adapt the excellent information in this post https://blender.stackexchange.com/a/119342/18323 to also include x,y rotations of faces and for a case where any modifiers are taken into account with bpy.context.evaluated_depsgraph_get() ...it's close but the rotations are slightly off when scaling non-uniformly? What have I missed?

import bmesh
import mathutils
obj = bpy.context.object
Remove empties
bpy.data.batch_remove((o for o in bpy.context.scene.objects if o.type == 'EMPTY'))
norm_length = 1
#Get the object scale and matrix_world data
bpy.ops.object.mode_set(mode='OBJECT')
#Create a bmesh of the object
bm = bmesh.new() # create an empty BMesh
dg = bpy.context.evaluated_depsgraph_get()
bm.from_object(obj, dg)
mw = obj.matrix_world
def create_rotation_matrix_from_face(mx, face):
N = mx.inverted_safe().transposed().to_3x3().normalized()
normal = N @ face.normal
tangent = N @ face.calc_tangent_edge_pair()
binormal = normal.cross(tangent)
rot = mathutils.Matrix()
rot[0].xyz = -tangent
rot[1].xyz = -binormal
rot[2].xyz = normal
return rot.transposed()


#Calculate normal transformations for the selected faces in the bmesh
for face in bm.faces:
    mat = create_rotation_matrix_from_face(mw, face)
    loc = mw @ face.calc_center_median()
    rot = mat.to_track_quat().to_euler()
bpy.ops.object.empty_add(
        location = loc,
        rotation = rot
    )
mt = bpy.context.object
mt.empty_display_type = 'ARROWS'
mt.empty_display_size = norm_length
mt.select_set(True)    


bpy.context.view_layer.objects.active = obj
obj.select_set(True)
bm.free()  # free and prevent further access to bmesh

Answer 1

From the bmesh directly.

Suggest to get the global normals from an evaluated bmesh, may as well apply the transform (world matrix) and update the normals.

import bpy
import bmesh
from bpy import context
norm_length = 2
bpy.ops.object.mode_set()
bpy.data.batch_remove((o for o in context.scene.objects if o.type == 'EMPTY'))
ob = context.object
dg = context.evaluated_depsgraph_get()
bm = bmesh.new()
bm.from_object(ob, dg)
bm.transform(ob.matrix_world)
bm.normal_update()
for f in bm.faces:
    n = f.normal
    mt = bpy.data.objects.new(f"n{f.index}", None)
    mt.location = f.calc_center_median()
    mt.rotation_euler =  n.to_track_quat().to_euler()
    mt.empty_display_type = 'SINGLE_ARROW'
    mt.empty_display_size = norm_length
    context.collection.objects.link(mt)
bpy.ops.object.mode_set(mode='EDIT')

Or to create a World Matrix from face tangent.

as in question then, for unit scale empties, using normalized vectors

n = f.normal
t = f.calc_tangent_edge_pair().normalized()
bt = n.cross(t).normalized()
M = Matrix([t, bt, n]).transposed().to_4x4()
M.translation = f.calc_center_median()
mt = bpy.data.objects.new("n{f.index}", None)
mt.matrix_world = M

or unnormalized

n = f.normal
t = f.calc_tangent_edge_pair()
bt = n.cross(t)

The results shown from cube with following transform

Answer 2

Using a ray cast, this is snapping cursor on face centers (pressing F), with rotation (F + shift). in object mode, edit mode, with subdivision modifier My script was on a active object following the cursor but I simplified for the example. this is quite the same

import bpy
import bmesh
from mathutils import Matrix
from bpy_extras import view3d_utils
class ModalOperator(bpy.types.Operator):
    bl_idname = "object.modal_operator"
    bl_label = "Simple Modal Operator"
def ray_cast(self, context, event):

    scene = context.scene
    region = context.region
    rv3d = context.region_data
    coord = event.mouse_region_x, event.mouse_region_y
    viewlayer = context.view_layer
    if bpy.app.version >= (2, 91, 0): #well actually under 2.93 but I let it
        viewlayer = viewlayer.depsgraph
    # get the ray from the viewport and mouse
    view_vector = view3d_utils.region_2d_to_vector_3d(region, rv3d, coord)
    ray_origin = view3d_utils.region_2d_to_origin_3d(region, rv3d, coord)

    return scene.ray_cast(viewlayer, ray_origin, view_vector)


def face_center(self, context, event):

    result, location, normal, index, object, matrix = self.ray_cast(
        context, event)

    if object:
        subsurf = [mod for mod in object.modifiers if mod.type == 'SUBSURF']
        if subsurf:
            depsgraph = context.evaluated_depsgraph_get()
            if context.mode == 'OBJECT':
                object_eval = object.evaluated_get(depsgraph)
                face = object_eval.data.polygons[index]
            else:
                mesh_from_eval = bpy.data.meshes.new_from_object(
                    object_eval)
                face = mesh_from_eval.polygons[index]                    
        else:
            face = object.data.polygons[index]

        mw = object.matrix_world
        me=object.data
        loc = mw @ face.center

        if object.mode == 'OBJECT':

            if event.shift: # + rotation copy
                bm = bmesh.new()
                bm.from_mesh(me)
                bm.transform(mw)
                bm.normal_update() # if the obj has rotation

                bm.faces.ensure_lookup_table()
                f = bm.faces[index]
                n = f.normal
                t = f.calc_tangent_edge_pair().normalized()
                bt = n.cross(t).normalized()

                M = Matrix([t, bt, n]).transposed().to_4x4() #rotation
                loc = M.translation = f.calc_center_median()

                context.scene.cursor.location = (0,0,0) 
                context.scene.cursor.matrix = M # or on an object obj.matrix_world = M

                bm.free()
            else:
                context.scene.cursor.location = loc

        else:  # edit              

            if event.shift:
                bm = bmesh.from_edit_mesh(me)
                bm.faces.ensure_lookup_table()
                f = bm.faces[index]
                n = f.normal@mw.inverted()
                t = f.calc_tangent_edge_pair().normalized()@mw.inverted()
                bt = n.cross(t).normalized()

                R = Matrix([t, bt, n]).transposed().to_4x4()                    

                context.scene.cursor.matrix = R
                context.scene.cursor.location = loc
                bmesh.update_edit_mesh(me) 

            else:
                context.scene.cursor.location = loc

def modal(self, context, event):

# to face center
    if event.type == 'F' and event.value == 'PRESS':
        self.face_center(context, event)
        return {'RUNNING_MODAL'}

    elif event.type in {'RIGHTMOUSE', 'ESC'}:
        return {'CANCELLED'}

    elif event.type in {'SPACE', 'RET'}:
        return {'FINISHED'}

    return {'RUNNING_MODAL'}

def invoke(self, context, event):
    context.window_manager.modal_handler_add(self)
    return {'RUNNING_MODAL'}



def register():
    bpy.utils.register_class(ModalOperator)
def unregister():
    bpy.utils.unregister_class(ModalOperator)
if name == "main":
    register()
# test call
bpy.ops.object.modal_operator('INVOKE_DEFAULT')

on an object instead of cursor in edit mode I did

mw = context.object.matrix_world 
n = f.normal @ mw.inverted()  
t = f.calc_tangent_edge_pair().normalized() @ mw.inverted()

and here is an example in object mode on a active object Align empty to normal with object matrix world rotation?