如何对齐两个 来自不同模型的 点的法线？

nirenyang

这个问题困扰我很久了，单个模型里的对齐是没问题的，但是不知道为何两个模型的元素对齐卡这么久。

运行代码，帮我看看，谢谢～

1. import bpy
   
2. 
   
3. import random
   
4. from math import degrees, radians
   
5. from mathutils import Vector
   
6. 
   
7. 
   
8. def MergeMeshSoWeCanCheckTheNormals(context, ob1, ob2):
   
9.     context.scene.objects.active = ob2
   
10.     ob1.select = ob2.select = True
    
11.     bpy.ops.object.join()
    
12.     ob = context.active_object
    
13.     bpy.ops.object.editmode_toggle()
    
14.     return
    
15. 
    
16. def MatchPoint0(context, ob1, ob2):
    
17.     """
    
18.     static = ob1
    
19.     dynamic = ob2
    
20.     """
    
21.     vt1 = ob1.data.vertices[0]
    
22.     vt2 = ob2.data.vertices[0]
    
23.    
    
24.     #location match
    
25.     m1 = ob1.matrix_world.copy()
    
26.     m2 = ob2.matrix_world.copy()
    
27.     loc1 = m1 * vt1.co.copy()
    
28.     loc2 = m2 * vt2.co.copy()
    
29.     bpy.ops.object.select_all(action='DESELECT')
    
30.     context.scene.objects.active = ob2
    
31.     ob2.select = True
    
32.     bpy.ops.transform.translate(value=loc1 - loc2)
    
33.     context.scene.cursor_location = loc1
    
34.     bpy.ops.object.origin_set(type='ORIGIN_CURSOR', center='MEDIAN')
    
35.    
    
36.     #So, We can keep on caculate rotation match
    
37.     #Caculate again cuz of ob2 is moved
    
38.     m2 = ob2.matrix_world.copy()
    
39.     n1 = (m1 * vt1.normal.copy()).normalized()
    
40.     print('v1  ::  lNor:%s gNor:%s' % (vt1.normal.copy(), n1))
    
41.     n2 = (m2 * vt2.normal.copy()).normalized()
    
42.     print('v2  ::  lNor:%s gNor:%s' % (vt2.normal.copy(), n2))
    
43.    
    
44.     angle = n1.angle(n2)
    
45.     cross = n1.cross(n2)
    
46.     dot = n1.dot(n2)
    
47.    
    
48.     print('before::\naxis: %s \nangle: %s \ndot: %s\n' % (cross, angle, dot))
    
49.     if dot>0:
    
50.         angle *= -1
    
51.     #euler = m2.Rotation(angle, 4, cross).to_euler()
    
52.     #ob2.rotation_euler = euler
    
53.     bpy.ops.transform.rotate(value=angle, axis=cross)
    
54.    
    
55.     ##############################################################
    
56.     m2 = ob2.matrix_world.copy()
    
57.     n1 = (m1 * vt1.normal.copy()).normalized()
    
58.     n2 = (m2 * vt2.normal.copy()).normalized()
    
59.     angle = n1.angle(n2)
    
60.     cross = n1.cross(n2)
    
61.     dot = n1.dot(n2)
    
62.     print('before::\naxis: %s \nangle: %s \ndot: %s' % (cross, angle, dot))
    
63.     return
    
64. 
    
65. def PrepareMesh(ob):
    
66.     """init"""
    
67.     bpy.ops.object.editmode_toggle()
    
68.     bpy.ops.mesh.select_all(action = 'DESELECT')
    
69.     bpy.ops.object.editmode_toggle()
    
70.     vt0 = ob.data.vertices[0]
    
71.     vt0.select = True
    
72.     for i in range(len(vt0.co.copy())):
    
73.         vt0.co[i] += random.uniform(0.1, 1)
    
74.     ob.data.update()
    
75.     ob.data.show_normal_vertex = True
    
76.     print('ob Name: %s -vt0- ::\nlocation: %s  \nnormal: %s\n' % (ob.name, vt0.co, vt0.normal))
    
77.     return
    
78.    
    
79. def main(context):
    
80.     print('\n\n--->>>')
    
81.     # Creating and Preparing
    
82.     bpy.ops.mesh.primitive_cube_add(view_align=True, location=(0, 0, 0), rotation=(10, 20, 30))
    
83.     ob1 = context.active_object
    
84.     PrepareMesh(ob1)
    
85.     ob2 = bpy.ops.mesh.primitive_cube_add(view_align=True, location=(3, 0.5, 0), rotation=(40, 50, 60))
    
86.     ob2 = context.active_object
    
87.     PrepareMesh(ob2)
    
88.    
    
89.     # Main working
    
90.     # static = ob1
    
91.     # dynamic = ob2
    
92.     context.tool_settings.mesh_select_mode = (True, False, False)
    
93.     MatchPoint0(context, ob1, ob2)
    
94.     MergeMeshSoWeCanCheckTheNormals(context, ob1, ob2)
    
95.     # Goto 3dView check two normals
    
96.    
    
97. 
    
98. 
    
99. 
    
100. class SimpleOperator(bpy.types.Operator):
     
101.     """Tooltip"""
     
102.     bl_idname = "object.simple_operator"
     
103.     bl_label = "Simple Object Operator"
     
104. 
     
105.     def execute(self, context):
     
106.         main(context)
     
107.         return {'FINISHED'}
     
108. 
     
109. 
     
110. def register():
     
111.     bpy.utils.register_class(SimpleOperator)
     
112. 
     
113. 
     
114. def unregister():
     
115.     bpy.utils.unregister_class(SimpleOperator)
     
116. 
     
117. 
     
118. if __name__ == "__main__":
     
119.     register()
     
120. 
     
121.     # test call
     
122.     bpy.ops.object.simple_operator()
     
123. 
     

复制代码

在BA也问了，不过英文实在很菜，沟通起来还是有点别扭。
http://blenderartists.org/forum/showthread.php?272472-How-to-match-two-Normals-direction&p=2243567#post2243567

nirenyang

直接跑到irc的blendercoders频道求人去了，果然有大神帮我了，不过还是不太理解反转矩阵那些部分。

感谢：brecht
The problem is in how you transform the normals. The python API does not make an automatic distinction between position and normal vectors, but they need to be transformed differently by matrices.

For normals the translation component should be ignored (as normals are invariant under translations). That's the cause of the mismatch here. Another issue happens when an object has non-uniform scale, in that case you need to use the inverse transpose.

Here's the modified code that should work, note NormalTransformMatrix:

1. 
   
2. import bpy
   
3. 
   
4. 
   
5. import random
   
6. from math import degrees, radians
   
7. from mathutils import Vector
   
8. 
   
9. 
   
10. 
    
11. 
    
12. def MergeMeshSoWeCanCheckTheNormals(context, ob1, ob2):
    
13.     context.scene.objects.active = ob2
    
14.     ob1.select = ob2.select = True
    
15.     bpy.ops.object.join()
    
16.     ob = context.active_object
    
17.     bpy.ops.object.editmode_toggle()
    
18.     return
    
19. 
    
20. 
    
21. def NormalTransformMatrix(m):
    
22.     m_normal = m.inverted().transposed()
    
23.     m_normal[0][3] = 0.0
    
24.     m_normal[1][3] = 0.0
    
25.     m_normal[2][3] = 0.0
    
26.    
    
27.     return m_normal
    
28. 
    
29. 
    
30. def MatchPoint0(context, ob1, ob2):
    
31.     """
    
32.     static = ob1
    
33.     dynamic = ob2
    
34.     """
    
35.     vt1 = ob1.data.vertices[0]
    
36.     vt2 = ob2.data.vertices[0]
    
37.    
    
38.     #location match
    
39.     m1 = ob1.matrix_world.copy()
    
40.     m2 = ob2.matrix_world.copy()
    
41.     loc1 = m1 * vt1.co.copy()
    
42.     loc2 = m2 * vt2.co.copy()
    
43.     bpy.ops.object.select_all(action='DESELECT')
    
44.     context.scene.objects.active = ob2
    
45.     ob2.select = True
    
46.     bpy.ops.transform.translate(value=loc1 - loc2)
    
47.     context.scene.cursor_location = loc1
    
48.     bpy.ops.object.origin_set(type='ORIGIN_CURSOR', center='MEDIAN')
    
49.    
    
50.     #So, We can keep on caculate rotation match
    
51.     #Caculate again cuz of ob2 is moved
    
52.     m1 = NormalTransformMatrix(ob1.matrix_world.copy())
    
53.     m2 = NormalTransformMatrix(ob2.matrix_world.copy())
    
54.     n1 = (m1 * vt1.normal.copy()).normalized()
    
55.     print('v1  ::  lNor:%s gNor:%s' % (vt1.normal.copy(), n1))
    
56.     n2 = (m2 * vt2.normal.copy()).normalized()
    
57.     print('v2  ::  lNor:%s gNor:%s' % (vt2.normal.copy(), n2))
    
58.    
    
59.     angle = n1.angle(n2)
    
60.     cross = n1.cross(n2)
    
61.     dot = n1.dot(n2)
    
62.    
    
63.     print('before::\naxis: %s \nangle: %s \ndot: %s\n' % (cross, angle, dot))
    
64.     if dot>0:
    
65.         angle *= -1
    
66.     #euler = m2.Rotation(angle, 4, cross).to_euler()
    
67.     #ob2.rotation_euler = euler
    
68.     bpy.ops.transform.rotate(value=angle, axis=cross)
    
69.    
    
70.     ##############################################################
    
71.     m1 = NormalTransformMatrix(ob1.matrix_world.copy())
    
72.     m2 = NormalTransformMatrix(ob2.matrix_world.copy())
    
73.     n1 = (m1 * vt1.normal.copy()).normalized()
    
74.     n2 = (m2 * vt2.normal.copy()).normalized()
    
75.     angle = n1.angle(n2)
    
76.     cross = n1.cross(n2)
    
77.     dot = n1.dot(n2)
    
78.     print('before::\naxis: %s \nangle: %s \ndot: %s' % (cross, angle, dot))
    
79.     return
    
80. 
    
81. 
    
82. def PrepareMesh(ob):
    
83.     """init"""
    
84.     bpy.ops.object.editmode_toggle()
    
85.     bpy.ops.mesh.select_all(action = 'DESELECT')
    
86.     bpy.ops.object.editmode_toggle()
    
87.     vt0 = ob.data.vertices[0]
    
88.     vt0.select = True
    
89.     for i in range(len(vt0.co.copy())):
    
90.         vt0.co[i] += random.uniform(0.1, 1)
    
91.     ob.data.update()
    
92.     ob.data.show_normal_vertex = True
    
93.     print('ob Name: %s -vt0- ::\nlocation: %s  \nnormal: %s\n' % (ob.name, vt0.co, vt0.normal))
    
94.     return
    
95.    
    
96. def main(context):
    
97.     print('\n\n--->>>')
    
98.     # Creating and Preparing
    
99.     bpy.ops.mesh.primitive_cube_add(view_align=True, location=(0, 0, 0), rotation=(10, 20, 30))
    
100.     ob1 = context.active_object
     
101.     PrepareMesh(ob1)
     
102.     ob2 = bpy.ops.mesh.primitive_cube_add(view_align=True, location=(3, 0.5, 0), rotation=(40, 50, 60))
     
103.     ob2 = context.active_object
     
104.     PrepareMesh(ob2)
     
105.    
     
106.     # Main working
     
107.     # static = ob1
     
108.     # dynamic = ob2
     
109.     context.tool_settings.mesh_select_mode = (True, False, False)
     
110.     MatchPoint0(context, ob1, ob2)
     
111.     MergeMeshSoWeCanCheckTheNormals(context, ob1, ob2)
     
112.     # Goto 3dView check two normals
     
113.    
     
114. 
     
115. 
     
116. 
     
117. 
     
118. 
     
119. 
     
120. class SimpleOperator(bpy.types.Operator):
     
121.     """Tooltip"""
     
122.     bl_idname = "object.simple_operator"
     
123.     bl_label = "Simple Object Operator"
     
124. 
     
125. 
     
126.     def execute(self, context):
     
127.         main(context)
     
128.         return {'FINISHED'}
     
129. 
     
130. 
     
131. 
     
132. 
     
133. def register():
     
134.     bpy.utils.register_class(SimpleOperator)
     
135. 
     
136. 
     
137. 
     
138. 
     
139. def unregister():
     
140.     bpy.utils.unregister_class(SimpleOperator)
     
141. 
     
142. 
     
143. 
     
144. 
     
145. if __name__ == "__main__":
     
146.     register()
     
147. 
     
148. 
     
149.     # test call
     
150.     bpy.ops.object.simple_operator()
     

复制代码

By the way, most of the .copy() calls in the code are not needed, though they don't hurt.

么么神人

只看懂前面开头定义了三个变量 context, ob1, ob2 后面云里雾绕