Aspose.3D FOSS
Python
Quaternion

Quaternion

Methods

Quaternion représente un quaternion unité utilisé pour encoder les rotations 3D. Contrairement aux angles d’Euler, les quaternions évitent le blocage de cardan et interpolent en douceur. Le Transform.rotation propriété sur un nœud de scène stocke un Quaternion.

Les composants sont stockés sous forme de (w, x, y, z) où w est la partie scalaire et (x, y, z) forment la partie vectorielle.

from aspose.threed.utilities import Quaternion
import math

# Identity quaternion (no rotation)
q = Quaternion()   # w=1, x=0, y=0, z=0

# Rotation of 90 degrees around the Y axis
q = Quaternion.from_euler_angle(0.0, math.radians(90), 0.0)

Methods: aspose.threed.utilities

from aspose.threed.utilities import Quaternion

Methods

MethodsMethods
Quaternion()Quaternion d’identité (w=1, x=0, y=0, z=0)
Quaternion(w, x, y, z)Constructeur explicite de composantes

Methods

MethodsMethodsMethods
wfloatPartie scalaire (réelle)
xfloatComposante x du vecteur
yfloatComposante y du vecteur
zfloatComposante z du vecteur
lengthfloatMagnitude du quaternion

Méthodes de fabrique statiques

MethodsType de retourMethods
Quaternion.from_euler_angle(pitch, yaw, roll)QuaternionConstruit à partir d’angles d’Euler en radians (pitch=X, yaw=Y, roll=Z). Accepte également un Vector3 comme premier argument
Quaternion.from_angle_axis(angle, axis)QuaternionConstruit à partir d’un angle (radians) et d’un Vector3 axe
Quaternion.from_rotation(orig, dest)QuaternionRotation d’arc le plus court depuis la direction orig vers la direction dest
Quaternion.interpolate(t, from_q, to_q)QuaternionInterpolation SLERP ; t dans [0, 1]
Quaternion.slerp(t, v1, v2)QuaternionAlias de interpolate

Méthodes d’instance

MethodsType de retourMethods
normalize()QuaternionRenvoie une copie de longueur unitaire
conjugate()QuaternionRenvoie le conjugué (w, -x, -y, -z)
inverse()QuaternionRenvoie l’inverse multiplicatif ; lève ValueError si la longueur est nulle
dot(q)floatProduit scalaire avec un autre quaternion
concat(rhs)QuaternionProduit de Hamilton (composition de deux rotations)
euler_angles()Vector3Extrait les angles d’Euler (radians) sous forme de Vector3(roll, pitch, yaw)
to_matrix(translation=None)Matrix4Convertit en une matrice de rotation 4×4 ; intègre éventuellement une translation Vector3
to_angle_axis(angle, axis)NoneDécompose en angle (radians) et axe ; les résultats sont écrits dans des listes à un seul élément angle[0] et axis[0]

Methods 

from aspose.threed import Scene
from aspose.threed.utilities import Quaternion, Vector3
import math

scene = Scene()
node = scene.root_node.create_child_node("rotated_box")

# Rotate 45 degrees around the Y axis
angle = math.radians(45)
q = Quaternion.from_euler_angle(0.0, angle, 0.0)
node.transform.rotation = q

# SLERP between two rotations
q_start = Quaternion.from_euler_angle(0, 0, 0)
q_end   = Quaternion.from_euler_angle(0, math.pi, 0)
q_mid   = Quaternion.slerp(0.5, q_start, q_end)

# Convert to matrix (useful for manual transforms)
mat = q.to_matrix()

# Extract Euler angles back
angles = q.euler_angles()   # Vector3(roll, pitch, yaw)
print(math.degrees(angles.y))   # ~45.0

Voir aussi

 Français