Aspose.3D FOSS
Python
Quaternion

Quaternion

Methods

Quaternion एक यूनिट क्वाटरनियन को दर्शाता है जिसका उपयोग 3D घूर्णन को एन्कोड करने के लिए किया जाता है। यूलेर एंगल्स के विपरीत, क्वाटरनियन गिम्बल लॉक से बचते हैं और सुगमता से इंटरपोलेट करते हैं। The Transform.rotation सीन नोड पर property एक … संग्रहीत करती है Quaternion.

घटक इस प्रकार संग्रहीत होते हैं (w, x, y, z) जहाँ w स्केलर भाग है और (x, y, z) वेक्टर भाग बनाते हैं।.

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()आइडेंटिटी क्वाटरनियन (w=1, x=0, y=0, z=0)
Quaternion(w, x, y, z)स्पष्ट घटक कंस्ट्रक्टर

Methods

MethodsMethodsMethods
wfloatस्केलर (वास्तविक) भाग
xfloatवेक्टर x-घटक
yfloatVector y-घटक
zfloatVector z-घटक
lengthfloatquaternion का परिमाण

Static Factory Methods

Methodsरिटर्न टाइपMethods
Quaternion.from_euler_angle(pitch, yaw, roll)QuaternionEuler कोणों (रेडियन में) (pitch=X, yaw=Y, roll=Z) से बनाता है। साथ ही एक Vector3 पहले तर्क के रूप में
Quaternion.from_angle_axis(angle, axis)Quaternionएक कोण (रेडियन) और एक Vector3 अक्ष
Quaternion.from_rotation(orig, dest)Quaternionदिशा से सबसे छोटा-आर्क घूर्णन orig दिशा तक dest
Quaternion.interpolate(t, from_q, to_q)QuaternionSLERP इंटरपोलेशन; t में [0, 1]
Quaternion.slerp(t, v1, v2)Quaternionके लिए उपनाम interpolate

Instance Methods

Methodsरिटर्न टाइपMethods
normalize()Quaternionएक यूनिट-लंबाई की कॉपी लौटाता है
conjugate()Quaternionसंयुग्मित लौटाता है (w, -x, -y, -z)
inverse()Quaternionगुणात्मक प्रतिलोम लौटाता है; उठाता है ValueError यदि लंबाई शून्य है
dot(q)floatएक अन्य क्वाटरनियन के साथ डॉट प्रोडक्ट
concat(rhs)Quaternionहैमिल्टन प्रोडक्ट (दो रोटेशनों का संयोजन)
euler_angles()Vector3Euler कोण (रेडियन) को निकालता है के रूप में Vector3(roll, pitch, yaw)
to_matrix(translation=None)Matrix44×4 घूर्णन मैट्रिक्स में परिवर्तित करता है; वैकल्पिक रूप से एक अनुवाद सम्मिलित करता है Vector3
to_angle_axis(angle, axis)Noneकोण (रेडियन) और अक्ष में विभाजित करता है; परिणाम एक-तत्वीय सूचियों में लिखे जाते हैं angle[0] और 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

संबंधित देखें

 हिन्दी