numpy旋转3d矩阵

cjjJasonchen

初始位置，x，y = 100，100

再旋转时y迅速变小到接近零，x缓慢变小至接近零

1. """
   
2. 矩阵旋转算法，这或许是真的3d?
   
3. """
   
4. 
   
5. import pygame
   
6. import sys
   
7. import math
   
8. import numpy
   
9. import pygameGUI as pgui
   
10. from typing import List
    
11. from pygame.locals import *
    
12. 
    
13. 
    
14. class Sprites3D:
    
15.     X, Y, Z = 0, 1, 2
    
16. 
    
17.     def __init__(self):
    
18.         self.position = [100,
    
19.                          100,
    
20.                          0,
    
21.                          ]
    
22. 
    
23.     def draw(self, screen):
    
24.         pygame.draw.circle(screen, (255, 0, 0), [self.position[0], self.position[1]], 10)
    
25. 
    
26.     def update(self):
    
27.         angle = math.radians(10)
    
28.         rz = numpy.array(
    
29.             [[math.cos(angle), - math.sin(angle), 0, 0],
    
30.              [math.sin(angle), math.cos(angle), 0, 0],
    
31.              [0, 0, 1, 0],
    
32.              [0, 0, 0, 1],
    
33.              ]
    
34.         )
    
35.         rx = numpy.array(
    
36.             [
    
37.                 [1, 0, 0, 0],
    
38.                 [0, math.cos(angle), -math.sin(angle), 0],
    
39.                 [0, math.sin(angle), -math.sin(angle), 0],
    
40.                 [0, 0, 0, 1],
    
41.             ]
    
42.         )
    
43.         position = numpy.array([
    
44.             [self.position[0]],
    
45.             [self.position[1]],
    
46.             [self.position[2]],
    
47.             [1]
    
48.         ])
    
49.         position = rz * position
    
50.         self.position = [
    
51.             position[0][0],
    
52.             position[1][0],
    
53.             position[2][0],
    
54.         ]
    
55. 
    
56. 
    
57. # 颜色常量
    
58. WHITE = (255, 255, 255)
    
59. BLACK = (0, 0, 0)
    
60. 
    
61. size = width, height = 800, 600
    
62. 
    
63. screen = pygame.display.set_mode(size)
    
64. 
    
65. pygame.display.set_caption("title")
    
66. 
    
67. clock = pygame.time.Clock()
    
68. 
    
69. delay = 60  # 延时计时器(1秒)
    
70. 
    
71. # 是否全屏
    
72. fullscreen = False
    
73. screen_change = False
    
74. 
    
75. # 背景颜色设定
    
76. bg_color = WHITE
    
77. 
    
78. running = True
    
79. 
    
80. # 3d对象
    
81. s3d = Sprites3D()
    
82. 
    
83. # ui======
    
84. 
    
85. guis = pgui.Group()
    
86. 
    
87. m = pgui.Message(group=guis, text=str(s3d.position[0]) + "\n" + str(s3d.position[1]) + "\n" + str(s3d.position[2]))
    
88. 
    
89. m.set_pos("center", [400, 200])
    
90. 
    
91. # =========
    
92. 
    
93. while running:
    
94. 
    
95.     # 设定帧数
    
96.     clock.tick(60)
    
97. 
    
98.     # 延时计时器刷新
    
99.     if delay == 0:
    
100.         delay = 60
     
101. 
     
102.     delay -= 1
     
103. 
     
104.     # 检测是否全屏
     
105.     if fullscreen and screen_change:
     
106.         screen = pygame.display.set_mode(size, FULLSCREEN, HWSURFACE)
     
107.         screen_change = False
     
108.     elif screen_change:
     
109.         screen = pygame.display.set_mode(size)
     
110.         screen_change = False
     
111. 
     
112.     # 事件检测
     
113.     for event in pygame.event.get():
     
114.         if event.type == QUIT:
     
115.             pygame.quit()
     
116.             sys.exit()
     
117. 
     
118.         # 鼠标
     
119.         if event.type == MOUSEBUTTONDOWN:
     
120.             pass
     
121. 
     
122.         # 按键按下事件
     
123.         if event.type == KEYDOWN:
     
124.             if event.key == K_ESCAPE:
     
125.                 pygame.quit()
     
126.                 sys.exit()
     
127.                
     
128.             # F11切换全屏
     
129.             if event.key == K_F11:
     
130.                 fullscreen = not fullscreen
     
131.                 screen_change = True
     
132. 
     
133.         # 按键抬起事件
     
134.         if event.type == KEYUP:
     
135.             pass
     
136. 
     
137.     # 画背景
     
138.     screen.fill(bg_color)
     
139. 
     
140.     # 刷新xxx
     
141.     m.text = str(s3d.position[0]) + "\n" + str(s3d.position[1]) + "\n" + str(int(s3d.position[2]))
     
142.     s3d.update()
     
143.     guis.update()
     
144. 
     
145.     # 画 xxxx
     
146.     guis.draw(screen)
     
147.     s3d.draw(screen)
     
148.    
     
149.     # 刷新界面
     
150.     pygame.display.update()
     
151. 
     
152. 
     

复制代码

@FishC

FishC

鱼油你好，看起来你正尝试用 `pygame` 和 `numpy` 实现一个3D旋转矩阵。不过呢，你这个代码还有不少坑，我们得给它填满才行。

首先，我们需要了解如何在三维空间旋转一个点。3D旋转可以通过旋转矩阵来实现，这些矩阵分别用于绕 x, y, z 轴旋转。假设你每次旋转10度，那我们先来给每个旋转轴创建一个矩阵。

1. 绕 z 轴旋转的矩阵:
   

1. rz = numpy.array([
   
2.         [math.cos(angle), -math.sin(angle), 0],
   
3.         [math.sin(angle),  math.cos(angle), 0],
   
4.         [0,               0,              1]
   
5.     ])

复制代码

2. 绕 x 轴旋转的矩阵:
   

1. rx = numpy.array([
   
2.         [1,              0,               0],
   
3.         [0, math.cos(angle), -math.sin(angle)],
   
4.         [0, math.sin(angle),  math.cos(angle)]
   
5.     ])

复制代码

   
这些矩阵会帮助我们实现绕不同轴的旋转，现在让我们来填补剩余的代码，并通过这些矩阵来更新位置。

1. import pygame
   
2. import sys
   
3. import math
   
4. import numpy
   
5. from pygame.locals import *
   
6. 
   
7. class Sprites3D:
   
8.     X, Y, Z = 0, 1, 2
   
9. 
   
10.     def __init__(self, x, y, z):
    
11.         self.position = numpy.array([x, y, z])
    
12. 
    
13.     def draw(self, screen):
    
14.         # 将3D坐标简单地转换为2D坐标
    
15.         screen_position = [int(self.position[self.X]), int(self.position[self.Y])]
    
16.         pygame.draw.circle(screen, (255, 0, 0), screen_position, 10)
    
17. 
    
18.     def update(self):
    
19.         angle = math.radians(10)
    
20. 
    
21.         rz = numpy.array([
    
22.             [math.cos(angle), -math.sin(angle), 0],
    
23.             [math.sin(angle),  math.cos(angle), 0],
    
24.             [0,               0,               1]
    
25.         ])
    
26. 
    
27.         rx = numpy.array([
    
28.             [1,              0,               0],
    
29.             [0, math.cos(angle), -math.sin(angle)],
    
30.             [0, math.sin(angle),  math.cos(angle)]
    
31.         ])
    
32. 
    
33.         # 先绕Z轴旋转，再绕X轴旋转
    
34.         self.position = rz @ self.position
    
35.         self.position = rx @ self.position
    
36. 
    
37. 
    
38. # ----- Pygame Setup -----
    
39. # 颜色常量
    
40. WHITE = (255, 255, 255)
    
41. BLACK = (0, 0, 0)
    
42. 
    
43. size = width, height = 800, 600
    
44. 
    
45. screen = pygame.display.set_mode(size)
    
46. pygame.display.set_caption("3D Rotation")
    
47. 
    
48. clock = pygame.time.Clock()
    
49. 
    
50. # 3D对象
    
51. s3d = Sprites3D(100, 100, 100)
    
52. 
    
53. running = True
    
54. 
    
55. while running:
    
56.     for event in pygame.event.get():
    
57.         if event.type == pygame.QUIT:
    
58.             running = False
    
59. 
    
60.     screen.fill(WHITE)
    
61.     s3d.update()
    
62.     s3d.draw(screen)
    
63.     pygame.display.flip()
    
64.     clock.tick(60)
    
65. 
    
66. pygame.quit()
    
67. sys.exit()

复制代码

这样，我们现在每帧都以10度的速度先绕 Z 轴再绕 X 轴旋转一个点。赶紧运行看看效果吧。当然，创建3D的视觉效果仅靠 x 和 y 平面上的点画个圆难显神奇，有世界变换和相机同步才是真实的。后续你可以考虑引入更多的3D图形学概念来尝试更复杂的构建！

任何问题随时来问，我随时给你解答哈！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

cjjJasonchen

已经解决了，是因为numpy数组使用的乘法和矩阵不一样，矩阵乘法要使用dot（）

FishC

cjjJasonchen 发表于 2024-08-20 22:53
已经解决了，是因为numpy数组使用的乘法和矩阵不一样 ...

聪明的鱼油，原来是这样！用 `dot()` 进行矩阵乘法确实是正确的做法。正好你提到这个问题，下面我简单讲讲如何正确实现一个 3D 旋转矩阵，这样下次遇到类似的问题就不会犯难了。

首先，我们用 `numpy` 实现 3D 旋转矩阵。这里简单介绍一下绕 x、y、z 轴的旋转矩阵：

1. 绕 x 轴旋转的矩阵：
   \[
   R_x(\theta) = \begin{bmatrix}
   1 & 0 & 0 \\
   0 & \cos(\theta) & -\sin(\theta) \\
   0 & \sin(\theta) & \cos(\theta)
   \end{bmatrix}
   \]

2. 绕 y 轴旋转的矩阵：
   \[
   R_y(\theta) = \begin{bmatrix}
   \cos(\theta) & 0 & \sin(\theta) \\
   0 & 1 & 0 \\
   -\sin(\theta) & 0 & \cos(\theta)
   \end{bmatrix}
   \]

3. 绕 z 轴旋转的矩阵：
   \[
   R_z(\theta) = \begin{bmatrix}
   \cos(\theta) & -\sin(\theta) & 0 \\
   \sin(\theta) & \cos(\theta) & 0 \\
   0 & 0 & 1
   \end{bmatrix}
   \]

假设你想同时绕这三个轴进行旋转，你可以通过组合这些旋转矩阵来实现。下面是一个简单的实现：

1. import numpy as np
   
2. import math
   
3. 
   
4. def get_rotation_matrix_x(angle):
   
5.     """返回绕x轴旋转的矩阵"""
   
6.     return np.array([
   
7.         [1, 0, 0],
   
8.         [0, math.cos(angle), -math.sin(angle)],
   
9.         [0, math.sin(angle), math.cos(angle)]
   
10.     ])
    
11. 
    
12. def get_rotation_matrix_y(angle):
    
13.     """返回绕y轴旋转的矩阵"""
    
14.     return np.array([
    
15.         [math.cos(angle), 0, math.sin(angle)],
    
16.         [0, 1, 0],
    
17.         [-math.sin(angle), 0, math.cos(angle)]
    
18.     ])
    
19. 
    
20. def get_rotation_matrix_z(angle):
    
21.     """返回绕z轴旋转的矩阵"""
    
22.     return np.array([
    
23.         [math.cos(angle), -math.sin(angle), 0],
    
24.         [math.sin(angle), math.cos(angle), 0],
    
25.         [0, 0, 1]
    
26.     ])
    
27. 
    
28. # 测试的角度
    
29. angle = math.radians(10)
    
30. 
    
31. # 初始位置
    
32. position = np.array([100, 100, 100])
    
33. 
    
34. rx = get_rotation_matrix_x(angle)
    
35. ry = get_rotation_matrix_y(angle)
    
36. rz = get_rotation_matrix_z(angle)
    
37. 
    
38. # 将旋转矩阵组合
    
39. rotation_matrix = rz.dot(ry).dot(rx)
    
40. 
    
41. # 对位置进行旋转变换
    
42. rotated_position = rotation_matrix.dot(position)
    
43. 
    
44. print("初始位置:", position)
    
45. print("旋转后的位置:", rotated_position)

复制代码

记得在你的 `Sprites3D` 类里面利用这些方法就可以实现你想要的3D旋转效果了，也要记得用 `dot()` 来进行矩阵运算：

1. # 在你的 Sprites3D 类中的 update 方法中使用
   
2. def update(self):
   
3.     angle = math.radians(10)  # 旋转角度
   
4.     rx = get_rotation_matrix_x(angle)
   
5.     ry = get_rotation_matrix_y(angle)
   
6.     rz = get_rotation_matrix_z(angle)
   
7.    
   
8.     # 将旋转矩阵组合
   
9.     rotation_matrix = rz.dot(ry).dot(rx)
   
10.    
    
11.     # 对位置进行旋转变换
    
12.     position = np.array([self.position[0], self.position[1], 0])  # 示例3D坐标
    
13.     rotated_position = rotation_matrix.dot(position)
    
14.    
    
15.     self.position = [rotated_position[0], rotated_position[1]]

复制代码

这样你的程序应该就能正确地进行3D旋转了！希望这对你有帮助，而且在写代码的过程中还不忘开开玩笑，比如“旋转红点变成了旋转丸子”。继续加油吧，祝你编程愉快！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。