Transform

Methods: aspose.threed (aspose-3d-foss)

Transform एक की स्थिति, अभिविन्यास और स्केल को नियंत्रित करता है Node 3D दृश्य में। प्रत्येक नोड के पास ठीक एक Transform, एक्सेस किया जाता है node.transform.

class Transform(A3DObject):

नोड के Transform को एक्सेस करना

from aspose.threed import Scene

scene = Scene()
node = scene.root_node.create_child_node("box")
t = node.transform     # Transform object

Methods

Methods	Methods	Methods
`translation`	`Vector3`	पैरेंट नोड की मूल बिंदु से स्थिति ऑफसेट। डिफ़ॉल्ट `Vector3(0, 0, 0)`.
`scaling`	`Vector3`	प्रत्येक अक्ष पर गैर-समरूप स्केल फैक्टर। डिफ़ॉल्ट `Vector3(1, 1, 1)`.
`rotation`	`Quaternion`	एक यूनिट क्वाटरनियन के रूप में रोटेशन। इसे सेट करने से यह भी अपडेट होता है `euler_angles`.
`euler_angles`	`Vector3`	डिग्री में रोटेशन (X, Y, Z) यूलेर कोणों के रूप में। इसे सेट करने से यह भी अपडेट होता है `rotation`.
`pre_rotation`	`Vector3`	मुख्य घूर्णन से पहले लागू किए गए Euler angles (FBX rigs में उपयोग किए जाते हैं)।.
`post_rotation`	`Vector3`	मुख्य घूर्णन के बाद लागू किए गए Euler angles।.
`geometric_translation`	`Vector3`	केवल स्थानीय translation: ज्यामिति को प्रभावित करता है लेकिन child nodes को नहीं।.
`geometric_scaling`	`Vector3`	केवल स्थानीय scale: ज्यामिति को प्रभावित करता है लेकिन child nodes को नहीं।.
`geometric_rotation`	`Vector3`	स्थानीय-केवल घूर्णन: ज्यामिति को प्रभावित करता है लेकिन child nodes को नहीं।.
`transform_matrix`	`Matrix4`	पूरा संयुक्त 4×4 ट्रांसफ़ॉर्मेशन मैट्रिक्स। कैश किया गया; जब भी कोई घटक बदलता है तो पुनः गणना किया जाता है। इसे सेट करने पर यह translation/scaling/rotation में वापस विभाजित हो जाता है।.

फ़्लुएंट सेट्टर मेथड्स

सभी सेटर्स रिटर्न करते हैं self, चेनिंग सक्षम करना:

Methods	Methods	Methods
`set_translation(tx, ty, tz)`	`float, float, float`	स्थिति सेट करें।.
`set_scale(sx, sy, sz)`	`float, float, float`	स्केल सेट करें।.
`set_euler_angles(rx, ry, rz)`	`float, float, float`	डिग्री में घूर्णन सेट करें।.
`set_rotation(rw, rx, ry, rz)`	`float, float, float, float`	घूर्णन को क्वाटरनियन (w, x, y, z) के रूप में सेट करें।.
`set_pre_rotation(rx, ry, rz)`	`float, float, float`	डिग्री में प्री-रोटेशन सेट करें।.
`set_post_rotation(rx, ry, rz)`	`float, float, float`	डिग्री में पोस्ट-रोटेशन सेट करें।.
`set_geometric_translation(x, y, z)`	`float, float, float`	ज्यामितीय ट्रांसलेशन सेट करें।.
`set_geometric_scaling(sx, sy, sz)`	`float, float, float`	ज्यामितीय स्केल सेट करें।.
`set_geometric_rotation(rx, ry, rz)`	`float, float, float`	डिग्री में ज्यामितीय घूर्णन सेट करें।.

उपयोग उदाहरण

नोड की स्थिति निर्धारित करें

from aspose.threed import Scene

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

# Using fluent setters
node.transform.set_translation(5.0, 0.0, -3.0)

# Or via property assignment
from aspose.threed.utilities import Vector3
node.transform.translation = Vector3(5.0, 0.0, -3.0)

यूलर एंगल्स के साथ घुमाएँ

from aspose.threed import Scene

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

# Rotate 45° around Y axis
node.transform.set_euler_angles(0.0, 45.0, 0.0)

# Chain multiple operations
node.transform.set_translation(2.0, 0.0, 0.0).set_scale(2.0, 2.0, 2.0)

क्वाटरनियन के साथ घुमाएँ

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

scene = Scene()
node = scene.root_node.create_child_node("q-rotated")

# 90° rotation around the Y axis
half_angle = math.radians(45)   # half the total rotation
q = Quaternion(math.cos(half_angle), 0.0, math.sin(half_angle), 0.0)
node.transform.rotation = q

print(f"Euler: {node.transform.euler_angles}")   # synced automatically

स्केल और स्थिति को साथ में लागू करें

from aspose.threed import Scene

scene = Scene()
node = scene.root_node.create_child_node("big-offset")

(node.transform
    .set_translation(10.0, 0.0, 0.0)
    .set_scale(3.0, 3.0, 3.0)
    .set_euler_angles(0.0, 90.0, 0.0))

ज्यामितीय ऑफ़सेट (पिवट ऑफ़सेट)

ज्यामितीय ट्रांसफ़ॉर्म्स जियोमेट्री को नोड के पिवट के सापेक्ष शिफ्ट करते हैं बिना चाइल्ड नोड्स को प्रभावित किए; यह मेष को उसके नोड के भीतर केंद्रित करने में उपयोगी है:

from aspose.threed import Scene

scene = Scene()
node = scene.root_node.create_child_node("centered-mesh")

# Shift the mesh half a unit down so its base sits at y=0
node.transform.set_geometric_translation(0.0, -0.5, 0.0)

संयुक्त Transform मैट्रिक्स पढ़ें

from aspose.threed import Scene

scene = Scene()
node = scene.root_node.create_child_node("m")
node.transform.set_translation(1.0, 2.0, 3.0).set_euler_angles(0.0, 45.0, 0.0)

m = node.transform.transform_matrix
print(type(m))  # <class 'aspose.threed.utilities.Matrix4'>