Hướng dẫn quaternion to rotation matrix python - quaternion để xoay ma trận python

classscipy.spatial.transform.Rotation#scipy.spatial.transform.Rotation#

Xoay trong 3 chiều.

Lớp này cung cấp một giao diện để khởi tạo và biểu diễn các vòng quay với:

  • Đệ tứ

  • Ma trận xoay

  • Vectơ xoay

  • Các thông số của Coleues Rodrigues

  • Góc Euler

Các hoạt động sau khi quay được hỗ trợ:

  • Ứng dụng trên vectơ

  • Thành phần xoay

  • Đảo ngược vòng quay

  • Lập chỉ mục xoay

Việc lập chỉ mục trong một vòng quay được hỗ trợ vì nhiều biến đổi xoay có thể được lưu trữ trong một trường hợp

>>> r = R.from_quat([0, 0, np.sin(np.pi/4), np.cos(np.pi/4)])
6 duy nhất.

Để tạo các đối tượng

>>> r = R.from_quat([0, 0, np.sin(np.pi/4), np.cos(np.pi/4)])
6, sử dụng các phương thức
>>> r = R.from_quat([0, 0, np.sin(np.pi/4), np.cos(np.pi/4)])
8 (xem các ví dụ bên dưới).
>>> r = R.from_quat([0, 0, np.sin(np.pi/4), np.cos(np.pi/4)])
9 không được cho là được khởi tạo trực tiếp.

Ghi chú

Ví dụ

>>> from scipy.spatial.transform import Rotation as R

Một ví dụ

>>> r = R.from_quat([0, 0, np.sin(np.pi/4), np.cos(np.pi/4)])
6 có thể được khởi tạo ở bất kỳ định dạng nào ở trên và được chuyển đổi sang bất kỳ định dạng nào khác. Đối tượng cơ bản độc lập với biểu diễn được sử dụng để khởi tạo.

Hãy xem xét một vòng quay ngược chiều kim đồng hồ 90 độ về trục z. Điều này tương ứng với Đệ tứ sau (ở định dạng qua vô hướng):

>>> r = R.from_quat([0, 0, np.sin(np.pi/4), np.cos(np.pi/4)])

Xoay có thể được thể hiện ở bất kỳ định dạng nào khác:

>>> r.as_matrix()
array([[ 2.22044605e-16, -1.00000000e+00,  0.00000000e+00],
[ 1.00000000e+00,  2.22044605e-16,  0.00000000e+00],
[ 0.00000000e+00,  0.00000000e+00,  1.00000000e+00]])
>>> r.as_rotvec()
array([0.        , 0.        , 1.57079633])
>>> r.as_euler('zyx', degrees=True)
array([90.,  0.,  0.])

Cùng một vòng quay có thể được khởi tạo bằng ma trận xoay:

>>> r = R.from_matrix([[0, -1, 0],
...                    [1, 0, 0],
...                    [0, 0, 1]])

Đại diện ở các định dạng khác:

>>> r.as_quat()
array([0.        , 0.        , 0.70710678, 0.70710678])
>>> r.as_rotvec()
array([0.        , 0.        , 1.57079633])
>>> r.as_euler('zyx', degrees=True)
array([90.,  0.,  0.])

Vectơ xoay tương ứng với vòng quay này được đưa ra bởi:

>>> r = R.from_rotvec(np.pi/2 * np.array([0, 0, 1]))

Đại diện ở các định dạng khác:

>>> r.as_quat()
array([0.        , 0.        , 0.70710678, 0.70710678])
>>> r.as_matrix()
array([[ 2.22044605e-16, -1.00000000e+00,  0.00000000e+00],
       [ 1.00000000e+00,  2.22044605e-16,  0.00000000e+00],
       [ 0.00000000e+00,  0.00000000e+00,  1.00000000e+00]])
>>> r.as_euler('zyx', degrees=True)
array([90.,  0.,  0.])

Vectơ xoay tương ứng với vòng quay này được đưa ra bởi:

>>> r = R.from_euler('z', 90, degrees=True)

Phương pháp

>>> r.as_matrix()
array([[ 2.22044605e-16, -1.00000000e+00,  0.00000000e+00],
[ 1.00000000e+00,  2.22044605e-16,  0.00000000e+00],
[ 0.00000000e+00,  0.00000000e+00,  1.00000000e+00]])
>>> r.as_rotvec()
array([0.        , 0.        , 1.57079633])
>>> r.as_euler('zyx', degrees=True)
array([90.,  0.,  0.])
1 khá linh hoạt trong phạm vi các định dạng đầu vào mà nó hỗ trợ. Ở đây chúng tôi khởi tạo một vòng quay duy nhất về một trục duy nhất:

>>> r.as_quat()
array([0.        , 0.        , 0.70710678, 0.70710678])
>>> r.as_matrix()
array([[ 2.22044605e-16, -1.00000000e+00,  0.00000000e+00],
       [ 1.00000000e+00,  2.22044605e-16,  0.00000000e+00],
       [ 0.00000000e+00,  0.00000000e+00,  1.00000000e+00]])
>>> r.as_rotvec()
array([0.        , 0.        , 1.57079633])

Một lần nữa, đối tượng là biểu diễn độc lập và có thể được chuyển đổi sang bất kỳ định dạng nào khác:

>>> r = R.from_euler('zyx', [
... [90, 0, 0],
... [0, 45, 0],
... [45, 60, 30]], degrees=True)

Cũng có thể khởi tạo nhiều vòng quay trong một trường hợp bằng cách sử dụng bất kỳ chức năng

>>> r = R.from_quat([0, 0, np.sin(np.pi/4), np.cos(np.pi/4)])
8 nào. Ở đây chúng tôi khởi tạo một chồng 3 vòng quay bằng phương pháp
>>> r.as_matrix()
array([[ 2.22044605e-16, -1.00000000e+00,  0.00000000e+00],
[ 1.00000000e+00,  2.22044605e-16,  0.00000000e+00],
[ 0.00000000e+00,  0.00000000e+00,  1.00000000e+00]])
>>> r.as_rotvec()
array([0.        , 0.        , 1.57079633])
>>> r.as_euler('zyx', degrees=True)
array([90.,  0.,  0.])
1:

>>> r = R.from_quat([0, 0, np.sin(np.pi/4), np.cos(np.pi/4)])
0

Các đại diện khác hiện cũng trả về một chồng 3 vòng quay. Ví dụ:

>>> r = R.from_quat([0, 0, np.sin(np.pi/4), np.cos(np.pi/4)])
1

Áp dụng các vòng quay trên lên một vectơ:

>>> r = R.from_quat([0, 0, np.sin(np.pi/4), np.cos(np.pi/4)])
2

Một thể hiện

>>> r = R.from_quat([0, 0, np.sin(np.pi/4), np.cos(np.pi/4)])
6 có thể được lập chỉ mục và cắt lát như thể nó là một mảng hoặc danh sách 1D duy nhất:

>>> r = R.from_quat([0, 0, np.sin(np.pi/4), np.cos(np.pi/4)])
3

Trong thực tế, nó có thể được chuyển đổi thành Numpy.Array:

>>> r = R.from_quat([0, 0, np.sin(np.pi/4), np.cos(np.pi/4)])
4

Nhiều vòng quay có thể được sáng tác bằng toán tử

>>> r.as_matrix()
array([[ 2.22044605e-16, -1.00000000e+00,  0.00000000e+00],
[ 1.00000000e+00,  2.22044605e-16,  0.00000000e+00],
[ 0.00000000e+00,  0.00000000e+00,  1.00000000e+00]])
>>> r.as_rotvec()
array([0.        , 0.        , 1.57079633])
>>> r.as_euler('zyx', degrees=True)
array([90.,  0.,  0.])
5:

>>> r = R.from_quat([0, 0, np.sin(np.pi/4), np.cos(np.pi/4)])
5

Cuối cùng, cũng có thể đảo ngược các vòng quay:

Attributes
>>> r.as_matrix()
array([[ 2.22044605e-16, -1.00000000e+00,  0.00000000e+00],
[ 1.00000000e+00,  2.22044605e-16,  0.00000000e+00],
[ 0.00000000e+00,  0.00000000e+00,  1.00000000e+00]])
>>> r.as_rotvec()
array([0.        , 0.        , 1.57079633])
>>> r.as_euler('zyx', degrees=True)
array([90.,  0.,  0.])
7

Những ví dụ này phục vụ như một cái nhìn tổng quan về lớp

>>> r = R.from_quat([0, 0, np.sin(np.pi/4), np.cos(np.pi/4)])
6 và nêu bật các chức năng chính. Để biết các ví dụ kỹ lưỡng hơn về phạm vi của các định dạng đầu vào và đầu ra được hỗ trợ, hãy tham khảo các ví dụ về phương pháp riêng lẻ.

Cho dù trường hợp này đại diện cho một vòng quay duy nhất.

>>> r.as_matrix()
array([[ 2.22044605e-16, -1.00000000e+00,  0.00000000e+00],
[ 1.00000000e+00,  2.22044605e-16,  0.00000000e+00],
[ 0.00000000e+00,  0.00000000e+00,  1.00000000e+00]])
>>> r.as_rotvec()
array([0.        , 0.        , 1.57079633])
>>> r.as_euler('zyx', degrees=True)
array([90.,  0.,  0.])
8

Phương pháp

>>> r.as_matrix()
array([[ 2.22044605e-16, -1.00000000e+00,  0.00000000e+00],
[ 1.00000000e+00,  2.22044605e-16,  0.00000000e+00],
[ 0.00000000e+00,  0.00000000e+00,  1.00000000e+00]])
>>> r.as_rotvec()
array([0.        , 0.        , 1.57079633])
>>> r.as_euler('zyx', degrees=True)
array([90.,  0.,  0.])
9

Số lượng vòng quay có trong đối tượng này.

>>> r = R.from_matrix([[0, -1, 0],
...                    [1, 0, 0],
...                    [0, 0, 1]])
0

Khởi tạo từ Đệ tứ.

>>> r = R.from_matrix([[0, -1, 0],
...                    [1, 0, 0],
...                    [0, 0, 1]])
1

Khởi tạo từ ma trận xoay.

>>> r = R.from_matrix([[0, -1, 0],
...                    [1, 0, 0],
...                    [0, 0, 1]])
2

Khởi tạo từ các vectơ xoay.

>>> r.as_matrix()
array([[ 2.22044605e-16, -1.00000000e+00,  0.00000000e+00],
[ 1.00000000e+00,  2.22044605e-16,  0.00000000e+00],
[ 0.00000000e+00,  0.00000000e+00,  1.00000000e+00]])
>>> r.as_rotvec()
array([0.        , 0.        , 1.57079633])
>>> r.as_euler('zyx', degrees=True)
array([90.,  0.,  0.])
1

Khởi tạo từ các tham số Rodrigues được sửa đổi (MRP).

>>> r = R.from_matrix([[0, -1, 0],
...                    [1, 0, 0],
...                    [0, 0, 1]])
4

Khởi tạo từ các góc Euler.

>>> r = R.from_matrix([[0, -1, 0],
...                    [1, 0, 0],
...                    [0, 0, 1]])
5

Đại diện như Đệ tứ.

>>> r = R.from_matrix([[0, -1, 0],
...                    [1, 0, 0],
...                    [0, 0, 1]])
6

Biểu thị như ma trận xoay.

>>> r = R.from_matrix([[0, -1, 0],
...                    [1, 0, 0],
...                    [0, 0, 1]])
7

Đại diện như các vectơ xoay.

>>> r = R.from_matrix([[0, -1, 0],
...                    [1, 0, 0],
...                    [0, 0, 1]])
8

Biểu thị dưới dạng các tham số Rodrigues đã sửa đổi (MRP).

>>> r = R.from_matrix([[0, -1, 0],
...                    [1, 0, 0],
...                    [0, 0, 1]])
9

Đại diện như các góc Euler.

>>> r.as_quat()
array([0.        , 0.        , 0.70710678, 0.70710678])
>>> r.as_rotvec()
array([0.        , 0.        , 1.57079633])
>>> r.as_euler('zyx', degrees=True)
array([90.,  0.,  0.])
1

Concatenate một chuỗi các đối tượng

>>> r = R.from_quat([0, 0, np.sin(np.pi/4), np.cos(np.pi/4)])
6.

>>> r.as_quat()
array([0.        , 0.        , 0.70710678, 0.70710678])
>>> r.as_rotvec()
array([0.        , 0.        , 1.57079633])
>>> r.as_euler('zyx', degrees=True)
array([90.,  0.,  0.])
2

Áp dụng vòng quay này cho một tập hợp các vectơ.

>>> r.as_quat()
array([0.        , 0.        , 0.70710678, 0.70710678])
>>> r.as_rotvec()
array([0.        , 0.        , 1.57079633])
>>> r.as_euler('zyx', degrees=True)
array([90.,  0.,  0.])
3

Kết hợp vòng quay này với cái khác.

>>> r.as_quat()
array([0.        , 0.        , 0.70710678, 0.70710678])
>>> r.as_rotvec()
array([0.        , 0.        , 1.57079633])
>>> r.as_euler('zyx', degrees=True)
array([90.,  0.,  0.])
4

Đảo ngược vòng quay này.

>>> r.as_quat()
array([0.        , 0.        , 0.70710678, 0.70710678])
>>> r.as_rotvec()
array([0.        , 0.        , 1.57079633])
>>> r.as_euler('zyx', degrees=True)
array([90.,  0.,  0.])
5

Lấy độ lớn của vòng quay.

>>> r.as_quat()
array([0.        , 0.        , 0.70710678, 0.70710678])
>>> r.as_rotvec()
array([0.        , 0.        , 1.57079633])
>>> r.as_euler('zyx', degrees=True)
array([90.,  0.,  0.])
6

Nhận giá trị trung bình của các vòng quay.

>>> r.as_quat()
array([0.        , 0.        , 0.70710678, 0.70710678])
>>> r.as_rotvec()
array([0.        , 0.        , 1.57079633])
>>> r.as_euler('zyx', degrees=True)
array([90.,  0.,  0.])
7

Giảm vòng quay này với các nhóm xoay được cung cấp.

>>> r.as_quat()
array([0.        , 0.        , 0.70710678, 0.70710678])
>>> r.as_rotvec()
array([0.        , 0.        , 1.57079633])
>>> r.as_euler('zyx', degrees=True)
array([90.,  0.,  0.])
8

Tạo một nhóm xoay 3D.

>>> r.as_quat()
array([0.        , 0.        , 0.70710678, 0.70710678])
>>> r.as_rotvec()
array([0.        , 0.        , 1.57079633])
>>> r.as_euler('zyx', degrees=True)
array([90.,  0.,  0.])
9

Trích xuất (các) vòng quay tại chỉ số đã cho (ES) từ đối tượng.

>>> r = R.from_rotvec(np.pi/2 * np.array([0, 0, 1]))
0

Nhận (các) vòng quay nhận dạng.

>>> r = R.from_rotvec(np.pi/2 * np.array([0, 0, 1]))
1

Tạo các vòng quay phân phối đồng đều.

Làm thế nào để bạn biến một bậc bốn thành một ma trận xoay?

Kết hợp các vòng quay bậc bốn vào một biểu diễn duy nhất, sau đó áp dụng phép quay bậc bốn vào các điểm Cartesian được khởi tạo tùy ý. Kết hợp các ma trận xoay thành một biểu diễn duy nhất, sau đó áp dụng ma trận xoay cho cùng các điểm Cartesian ban đầu.. Combine the rotation matrices into a single representation, then apply the rotation matrix to the same initial Cartesian points.

Làm thế nào để bạn xoay một ma trận trong Python?

Ý tưởng là sử dụng các vòng tương tự như chương trình để in ma trận ở dạng xoắn ốc ...
Di chuyển các yếu tố của hàng trên cùng ..
Di chuyển các yếu tố của cột cuối cùng ..
Di chuyển các yếu tố của hàng dưới cùng ..
Di chuyển các yếu tố của cột đầu tiên ..

Làm thế nào để bạn xoay theo bậc bốn?

Đối với các bậc bốn xoay, nghịch đảo bằng với liên hợp.Vì vậy, đối với các bậc bốn xoay, q 1 = q* = (q0, Q1, Q2, Q3).Đảo ngược hoặc kết hợp một bậc bốn xoay có tác dụng đảo ngược trục quay, điều chỉnh nó để xoay theo hướng ngược lại từ bản gốc.q1 = q* = ( q0, −q1, −q2, −q3 ). Inverting or conjugating a rotation quaternion has the effect of reversing the axis of rotation, which modifies it to rotate in the opposite direction from the original.

Đệ tứ có nhanh hơn ma trận xoay không?

Đối với bậc bốn so với ma trận xoay 3x3, bậc bốn có lợi thế về kích thước (4 vô hướng so với 9) và tốc độ (phép nhân bậc bốn nhanh hơn nhiều so với phép nhân ma trận 3x3).Lưu ý rằng tất cả các biểu diễn của vòng quay được sử dụng trong thực tế.quaternion multiplication is much faster than 3x3 matrix multiplication). Note that all of these representations of rotations are used in practice.