Matrix4
Methods
Matrix4 एक 4×4 डबल-प्रिसीजन मैट्रिक्स है जो रो-मैजोर क्रम में संग्रहीत है और इसमें 16 तत्व होते हैं (m00–m33). यह विश्व/स्थानीय ट्रांसफ़ॉर्म गणनाओं, कस्टम प्रोजेक्शन्स, और नोड ट्रांसफ़ॉर्म को ट्रांसलेशन, रोटेशन और स्केल में विभाजित करने के लिए उपयोग किया जाता है।.
Methods: aspose.threed.utilities
from aspose.threed.utilities import Matrix4Methods
| Methods | Methods |
|---|---|
Matrix4() | आइडेंटिटी मैट्रिक्स |
Matrix4(m00, m01, ..., m33) | स्पष्ट 16-तत्व कंस्ट्रक्टर (रो-मैजोर क्रम) |
Matrix4(values) | 16 की सूची से निर्मित float मान |
एलिमेंट प्रॉपर्टीज़
तत्वों के नाम हैं mRC जहाँ R पंक्ति (0–3) है और C स्तंभ (0–3) है। उदाहरण के लिए, m03 पंक्ति 0, स्तंभ 3 है (मैट्रिक्स जब एक ट्रांसफ़ॉर्म एन्कोड करता है तो X अनुवाद)। सभी 16 गुण (m00 के माध्यम से m33) पढ़ने योग्य और लिखने योग्य हैं।.
मैट्रिक्स को फ्लैट इंडेक्स द्वारा भी एक्सेस किया जा सकता है: mat[0]–mat[15].
गणना की गई प्रॉपर्टीज़
| Methods | Methods | Methods |
|---|---|---|
determinant | float | मैट्रिक्स का स्केलर डिटरमिनेंट |
Static Factory Methods
| Methods | रिटर्न टाइप | Methods |
|---|---|---|
Matrix4.get_identity() | Matrix4 | एक पहचान मैट्रिक्स लौटाता है |
Matrix4.translate(tx, ty, tz) | Matrix4 | ट्रांसलेशन मैट्रिक्स; साथ ही एक को स्वीकार करता है Vector3 या समान ट्रांसलेशन के लिए एकल scalar |
Matrix4.scale(sx, sy, sz) | Matrix4 | Scale matrix; साथ ही एक को स्वीकार करता है Vector3 या समान स्केल के लिए एकल स्केलर |
Matrix4.rotate(angle, axis) | Matrix4 | कोण (रेडियन) और से रोटेशन मैट्रिक्स Vector3 अक्ष; साथ ही एक को भी स्वीकार करता है Quaternion एकमात्र तर्क के रूप में |
Matrix4.rotate_from_euler(rx, ry, rz) | Matrix4 | Euler कोणों (रेडियन) से प्राप्त घूर्णन मैट्रिक्स; यह भी स्वीकार करता है एक Vector3 |
Instance Methods
| Methods | रिटर्न टाइप | Methods |
|---|---|---|
concatenate(m2) | Matrix4 | मैट्रिक्स गुणनफल लौटाता है self × m2 |
normalize() | Matrix4 | घूर्णन अक्षों को पुनः-ऑर्थोनॉर्मलाइज़ करके (घूर्णन कॉलमों से स्केल हटाकर) एक कॉपी लौटाता है |
transpose() | Matrix4 | ट्रांसपोज़्ड मैट्रिक्स लौटाता है |
inverse() | Matrix4 | इनवर्स लौटाता है; उठाता है ValueError यदि मैट्रिक्स सिंगुलर है |
decompose(translation, scaling, rotation) | None | TRS घटकों में विभाजित करता है। परिणाम एक-तत्वीय सूचियों में लिखे जाते हैं: translation[0] → Vector3, scaling[0] → Vector3, rotation[0] → Quaternion |
set_trs(translation, rotation, scale) | None | अनुवाद से मैट्रिक्स को इन‑प्लेस सेट करता है Vector3, घूर्णन Quaternion या Vector3 (Euler), और स्केल Vector3 |
to_array() | list[float] | 16 तत्वों को एक सपाट सूची के रूप में लौटाता है |
Methods
from aspose.threed.utilities import Matrix4, Vector3, Quaternion
import math
# Build a transform: translate (5, 0, 0), rotate 90 deg around Y, scale 2x
t = Matrix4.translate(5.0, 0.0, 0.0)
r = Matrix4.rotate(math.radians(90), Vector3(0, 1, 0))
s = Matrix4.scale(2.0, 2.0, 2.0)
# Combine: scale first, then rotate, then translate
combined = t.concatenate(r.concatenate(s))
# Decompose the result back into TRS
translation = [None]
scaling = [None]
rotation = [None]
combined.decompose(translation, scaling, rotation)
print(translation[0]) # Vector3(5.0, 0.0, 0.0)
print(scaling[0]) # Vector3(2.0, 2.0, 2.0)
# Retrieve from a node's global transform
from aspose.threed import Scene
scene = Scene()
node = scene.root_node.create_child_node("box")
node.transform.translation = Vector3(10.0, 0.0, 0.0)
world_mat = node.global_transform.transform_matrix
print(world_mat.m03) # 10.0 — translation X