विशेषताएँ और कार्यात्मकताएँ

Aspose.3D FOSS for Python कई उद्योग-मानक फ़ॉर्मैट्स में 3D सामग्री को पढ़ने, बनाने और लिखने के लिए एक पूर्ण सीन-ग्राफ API प्रदान करता है। यह पृष्ठ प्रत्येक प्रमुख फीचर क्षेत्र को वास्तविक लाइब्रेरी API का उपयोग करने वाले कार्यशील Python कोड उदाहरणों के साथ दस्तावेज़ करता है।.

स्थापना और सेटअप

एक ही कमांड से PyPI से लाइब्रेरी स्थापित करें:

pip install aspose-3d-foss

कोई अतिरिक्त सिस्टम पैकेज, नेटिव एक्सटेंशन, या कंपाइलर टूलचेन आवश्यक नहीं है। लाइब्रेरी शुद्ध Python है और Windows, macOS, और Linux पर Python 3.7 से 3.12 तक का समर्थन करती है।.

स्थापना की पुष्टि करने के लिए:

from aspose.threed import Scene

scene = Scene()
print("Aspose.3D FOSS installed successfully")
print(f"Root node name: {scene.root_node.name}")

विशेषताएँ और कार्यात्मकताएँ

फ़ॉर्मैट समर्थन

Aspose.3D FOSS for Python निम्नलिखित फ़ॉर्मैट्स को पढ़ता और लिखता है:

विकल्पों के साथ OBJ लोड करना

ObjLoadOptions OBJ फ़ाइलों को कैसे पार्स किया जाता है, इसे नियंत्रित करता है:

from aspose.threed import Scene
from aspose.threed.formats import ObjLoadOptions

options = ObjLoadOptions()
options.enable_materials = True        # Load accompanying .mtl file
options.flip_coordinate_system = False # Preserve original handedness
options.normalize_normal = True        # Normalize vertex normals to unit length
options.scale = 1.0                    # Apply a uniform scale factor at load time

scene = Scene()
scene.open("model.obj", options)

print(f"Loaded {len(scene.root_node.child_nodes)} top-level nodes")

STL में सहेजना

StlSaveOptions बाइनरी बनाम ASCII आउटपुट और अन्य STL-विशिष्ट सेटिंग्स को नियंत्रित करता है:

from aspose.threed import Scene
from aspose.threed.formats import StlSaveOptions

scene = Scene.from_file("model.obj")
options = StlSaveOptions()
scene.save("output.stl", options)

सीन ग्राफ

सभी 3D सामग्री को एक ट्री के रूप में व्यवस्थित किया गया है Node ऑब्जेक्ट्स। ट्री की जड़ है scene.root_node. प्रत्येक नोड में चाइल्ड नोड्स हो सकते हैं और वह एक Entity (mesh, camera, or light) प्लस एक Transform.

सीन पदानुक्रम का पारगमन

from aspose.threed import Scene

scene = Scene.from_file("model.glb")

def traverse(node, depth=0):
    indent = "  " * depth
    entity_type = type(node.entity).__name__ if node.entity else "none"
    print(f"{indent}{node.name} [{entity_type}]")
    for child in node.child_nodes:
        traverse(child, depth + 1)

traverse(scene.root_node)

प्रोग्रामेटिक रूप से सीन बनाना

from aspose.threed import Scene, Node, Entity
from aspose.threed.entities import Mesh
from aspose.threed.utilities import Vector3

scene = Scene()
root = scene.root_node

##Create a child node and position it
child = root.create_child_node("my_object")
child.transform.translation = Vector3(1.0, 0.0, 0.0)
child.transform.scaling = Vector3(2.0, 2.0, 2.0)

scene.save("constructed.glb")

GlobalTransform की जाँच

GlobalTransform सभी पूर्वज ट्रांसफ़ॉर्म्स को इकट्ठा करने के बाद नोड का world-space ट्रांसफ़ॉर्म देता है:

from aspose.threed import Scene

scene = Scene.from_file("model.dae")

for node in scene.root_node.child_nodes:
    gt = node.global_transform
    print(f"Node: {node.name}")
    print(f"  World translation: {gt.translation}")
    print(f"  World scale: {gt.scale}")

Mesh API

यह Mesh entity जियोमेट्री डेटा तक पहुँच प्रदान करती है जिसमें control points (vertices), polygons, और vertex elements for normals, UVs, और colors शामिल हैं।.

Mesh ज्यामिति पढ़ना

from aspose.threed import Scene
from aspose.threed.formats import ObjLoadOptions

options = ObjLoadOptions()
options.enable_materials = True
options.flip_coordinate_system = False

scene = Scene()
scene.open("model.obj", options)

for node in scene.root_node.child_nodes:
    if node.entity is None:
        continue
    mesh = node.entity
    print(f"Mesh: {node.name}")
    print(f"  Vertices: {len(mesh.control_points)}")
    print(f"  Polygons: {len(mesh.polygons)}")

वर्टेक्स एलिमेंट्स तक पहुँच

वर्टेक्स एलिमेंट्स प्रति-वर्टेक्स या प्रति-बहुभुज डेटा ले जाते हैं। सबसे सामान्य एलिमेंट्स नॉर्मल्स, UV निर्देशांक, वर्टेक्स रंग, और स्मूदिंग ग्रुप्स हैं:

from aspose.threed import Scene
from aspose.threed.entities import VertexElementNormal, VertexElementUV

scene = Scene.from_file("model.obj")

for node in scene.root_node.child_nodes:
    if node.entity is None:
        continue
    mesh = node.entity

    # Iterate vertex elements to find normals and UVs
    for element in mesh.vertex_elements:
        if isinstance(element, VertexElementNormal):
            print(f"  Normals count: {len(element.data)}")
        elif isinstance(element, VertexElementUV):
            print(f"  UV count: {len(element.data)}")

मैटेरियल सिस्टम

Aspose.3D FOSS दो सामग्री प्रकारों का समर्थन करता है: LambertMaterial (diffuse shading) और PhongMaterial (specular shading). दोनों को .mtl फ़ाइलों से स्वचालित रूप से लोड किया जाता है जब उपयोग किया जाता है ObjLoadOptions के साथ enable_materials = True.

OBJ से मैटेरियल्स पढ़ना

from aspose.threed import Scene
from aspose.threed.shading import LambertMaterial, PhongMaterial
from aspose.threed.formats import ObjLoadOptions

options = ObjLoadOptions()
options.enable_materials = True

scene = Scene()
scene.open("model.obj", options)

for node in scene.root_node.child_nodes:
    mat = node.material
    if mat is None:
        continue
    print(f"Node: {node.name}")
    if isinstance(mat, PhongMaterial):
        print(f"  Type: Phong")
        print(f"  Diffuse: {mat.diffuse_color}")
        print(f"  Specular: {mat.specular_color}")
    elif isinstance(mat, LambertMaterial):
        print(f"  Type: Lambert")
        print(f"  Diffuse: {mat.diffuse_color}")

प्रोग्रामेटिक रूप से मैटेरियल असाइन करना

from aspose.threed import Scene, Node
from aspose.threed.shading import PhongMaterial
from aspose.threed.utilities import Vector3

scene = Scene.from_file("model.glb")

material = PhongMaterial()
material.diffuse_color = Vector3(0.8, 0.2, 0.2)   # Red diffuse
material.specular_color = Vector3(1.0, 1.0, 1.0)  # White specular

##Apply to the first mesh node
for node in scene.root_node.child_nodes:
    if node.entity is not None:
        node.material = material
        break

scene.save("recolored.glb")

गणितीय उपयोगिताएँ

यह aspose.threed.utilities module दृश्य निर्माण और निरीक्षण के लिए आवश्यक सभी ज्यामितीय गणित प्रकार प्रदान करता है।.

ट्रांसफ़ॉर्म्स के साथ काम करना

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

##Build a rotation quaternion from axis-angle
axis = Vector3(0.0, 1.0, 0.0)          # Y-axis
angle_rad = math.radians(45.0)
q = Quaternion.from_angle_axis(angle_rad, axis)

print(f"Quaternion: x={q.x:.4f} y={q.y:.4f} z={q.z:.4f} w={q.w:.4f}")

##Convert to rotation matrix
mat = q.to_matrix()
print(f"Rotation matrix row 0: {mat[0, 0]:.4f} {mat[0, 1]:.4f} {mat[0, 2]:.4f}")

बाउंडिंग बॉक्स की गणना

from aspose.threed import Scene

scene = Scene.from_file("model.stl")

# NOTE: mesh.get_bounding_box() is a stub — it always returns an empty BoundingBox()
# regardless of geometry. Compute bounds manually from control_points:
for node in scene.root_node.child_nodes:
    if node.entity is None:
        continue
    mesh = node.entity
    pts = mesh.control_points  # returns a copy of the vertex list
    if not pts:
        continue
    xs = [p.x for p in pts]
    ys = [p.y for p in pts]
    zs = [p.z for p in pts]
    print(f"Mesh: {node.name}")
    print(f"  Min: ({min(xs):.3f}, {min(ys):.3f}, {min(zs):.3f})")
    print(f"  Max: ({max(xs):.3f}, {max(ys):.3f}, {max(zs):.3f})")

एनिमेशन

Aspose.3D FOSS एक एनीमेशन मॉडल प्रदान करता है जो पर आधारित AnimationClip, AnimationNode, KeyFrame, और KeyframeSequence. लोड की गई फ़ाइलों (glTF, COLLADA) में संग्रहीत एनीमेशन डेटा इन वस्तुओं के माध्यम से सुलभ है।.

एनिमेशन क्लिप्स पढ़ना

from aspose.threed import Scene

scene = Scene.from_file("animated.glb")

for clip in scene.animation_clips:
    print(f"Clip: {clip.name}  ({clip.start:.2f}s – {clip.stop:.2f}s)")
    for anim_node in clip.animations:
        print(f"  Animation node: {anim_node.name}")
        for sub in anim_node.sub_animations:
            print(f"    Sub-animation: {sub.name}")
        for bp in anim_node.bind_points:
            print(f"    Bind point: {bp.name}")

लोड और सेव विकल्प

प्रत्येक समर्थित फ़ॉर्मेट का एक संबंधित विकल्प क्लास होता है जो पार्सिंग और सीरियलाइज़ेशन व्यवहार को नियंत्रित करता है।.

उपयोग के उदाहरण

उदाहरण 1: OBJ से STL फ़ॉर्मेट रूपांतरण

एक OBJ फ़ाइल (सामग्री के साथ) को बाइनरी STL में परिवर्तित करें, साथ ही मेष आँकड़े प्रिंट करते हुए:

from aspose.threed import Scene
from aspose.threed.formats import ObjLoadOptions
from aspose.threed.formats import StlSaveOptions

##Load OBJ with material support
load_opts = ObjLoadOptions()
load_opts.enable_materials = True
load_opts.flip_coordinate_system = False
load_opts.normalize_normal = True

scene = Scene()
scene.open("input.obj", load_opts)

##Report what was loaded
total_vertices = 0
total_polygons = 0
for node in scene.root_node.child_nodes:
    if node.entity is not None:
        mesh = node.entity
        total_vertices += len(mesh.control_points)
        total_polygons += len(mesh.polygons)
        print(f"  {node.name}: {len(mesh.control_points)} vertices, {len(mesh.polygons)} polygons")

print(f"Total: {total_vertices} vertices, {total_polygons} polygons")

##Save as STL
save_opts = StlSaveOptions()
scene.save("output.stl", save_opts)
print("Saved output.stl")

उदाहरण 2: बैच glTF से GLB पैकिंग

अलग-अलग glTF + टेक्सचर फ़ाइलों की एक डायरेक्टरी को स्वयं-समाहित GLB बाइनरी के रूप में पुनः सहेजें:

import os
from aspose.threed import Scene

input_dir = "gltf_files"
output_dir = "glb_files"
os.makedirs(output_dir, exist_ok=True)

for filename in os.listdir(input_dir):
    if not filename.endswith(".gltf"):
        continue
    src = os.path.join(input_dir, filename)
    dst = os.path.join(output_dir, filename.replace(".gltf", ".glb"))
    scene = Scene.from_file(src)
    scene.save(dst)
    print(f"Packed {filename} -> {os.path.basename(dst)}")

उदाहरण 3: सीन ग्राफ निरीक्षण और निर्यात रिपोर्ट

एक COLLADA फ़ाइल के सीन ग्राफ को ट्रैवर्स करें, प्रति-मे़ष आँकड़े एकत्र करें, और एक संरचित रिपोर्ट प्रिंट करें:

from aspose.threed import Scene

scene = Scene.from_file("assembly.dae")

report = []

def collect(node, path=""):
    full_path = f"{path}/{node.name}" if node.name else path
    if node.entity is not None:
        mesh = node.entity
        gt = node.global_transform
        report.append({
            "path": full_path,
            "vertices": len(mesh.control_points),
            "polygons": len(mesh.polygons),
            "world_x": gt.translation.x,
            "world_y": gt.translation.y,
            "world_z": gt.translation.z,
        })
    for child in node.child_nodes:
        collect(child, full_path)

collect(scene.root_node)

print(f"{'Path':<40} {'Verts':>6} {'Polys':>6} {'X':>8} {'Y':>8} {'Z':>8}")
print("-" * 78)
for entry in report:
    print(
        f"{entry['path']:<40} "
        f"{entry['vertices']:>6} "
        f"{entry['polygons']:>6} "
        f"{entry['world_x']:>8.3f} "
        f"{entry['world_y']:>8.3f} "
        f"{entry['world_z']:>8.3f}"
    )

टिप्स और सर्वोत्तम प्रथाएँ

फ़ॉर्मेट चयन

• glTF 2.0 / GLB सामग्री, एनीमेशन और जटिल पदानुक्रमों वाले दृश्यों के लिए अनुशंसित इंटरचेंज फ़ॉर्मेट है। पोर्टेबिलिटी के लिए glTF (टेक्स्ट + बाहरी फ़ाइलें) की तुलना में GLB (बाइनरी) को प्राथमिकता दें।.
• STL जब डाउनस्ट्रीम कंज्यूमर एक स्लाइसर, CAD टूल, या कोई भी टूल हो जो केवल ज्योमेट्री की आवश्यकता रखता है, तो यह सही विकल्प है। STL में कोई सामग्री या एनीमेशन डेटा नहीं होता।.
• OBJ यह व्यापक रूप से समर्थित है और जब सामग्री डेटा को पुराने टूल्स के साथ आदान‑प्रदान करना हो तो एक अच्छा विकल्प है। हमेशा .mtl फ़ाइल को .obj फ़ाइल के साथ रखें।.

निर्देशांक प्रणाली

• विभिन्न अनुप्रयोग अलग‑अलग हैंडेडनेस सम्मेलनों का उपयोग करते हैं। सेट ObjLoadOptions.flip_coordinate_system = True जब आप ऐसे टूल्स से OBJ फ़ाइलें इम्पोर्ट करते हैं जो right-handed coordinate system का उपयोग करते हैं, यदि आपका पाइपलाइन left-handed coordinates की अपेक्षा करता है, और इसके विपरीत।.
• स्रोत एसेट की अक्ष परम्परा की जाँच करें इससे पहले कि आप कोई फ़्लिप लागू करें। दो बार फ़्लिप करने से गलत ज्यामिति बनती है।.

सामान्यीकरण

• हमेशा सेट करें ObjLoadOptions.normalize_normal = True जब डाउनस्ट्रीम पाइपलाइन unit normals की अपेक्षा करती है (उदाहरण के लिए, जब normals को एक shader को पास किया जाता है या dot-product लाइटिंग गणनाएँ की जाती हैं)। खराब-फ़ॉर्मेटेड OBJ फ़ाइलों से अननॉर्मलाइज़्ड normals लाइटिंग आर्टिफैक्ट्स का कारण बनते हैं।.

प्रदर्शन

• फ़ाइलों को एक बार लोड करें और इन‑मेमोरी सीन ग्राफ को बदलें बजाय प्रत्येक आउटपुट फ़ॉर्मेट के लिए डिस्क से पुनः लोड करने के। एकल Scene.from_file() call के बाद कई scene.save() calls दोहराए गए लोड्स की तुलना में अधिक कुशल है।.
• बड़े बैचों को प्रोसेस करते समय, एकल बनाएं ObjLoadOptions या StlSaveOptions instance को सभी फ़ाइलों में पुन: उपयोग करें बजाय प्रत्येक फ़ाइल के लिए नया options ऑब्जेक्ट बनाने के।.

त्रुटि संभालना

• Wrap scene.open() और scene.save() calls को try/except blocks जब अनविश्वसनीय या उपयोगकर्ता‑प्रदान फ़ाइलों को प्रोसेस किया जा रहा हो। अपवाद संदेशों में फ़ाइलनाम रिपोर्ट करें ताकि बैच पाइपलाइन में डिबगिंग सरल हो सके।.

सामान्य समस्याएँ

अक्सर पूछे जाने वाले प्रश्न

कौन से Python संस्करण समर्थित हैं? Python 3.7, 3.8, 3.9, 3.10, 3.11, और 3.12 सभी समर्थित हैं। लाइब्रेरी शुद्ध Python है और इसमें कोई नेटिव एक्सटेंशन नहीं है, इसलिए यह किसी भी प्लेटफ़ॉर्म पर काम करती है जहाँ CPython चलता है।.

क्या लाइब्रेरी में कोई बाहरी निर्भरताएँ हैं? नहीं। Aspose.3D FOSS for Python केवल Python मानक लाइब्रेरी का उपयोग करता है। यह एक ही pip install aspose-3d-foss कमांड के रूप में स्थापित होता है और कोई अतिरिक्त चरण नहीं होते।.

क्या FBX समर्थित है? FBX टोकनाइज़र लागू किया गया है और बाइनरी FBX टोकन स्ट्रीम को पार्स कर सकता है, लेकिन टोकनाइज़र के ऊपर का सीन-ग्राफ बिल्डर ज्ञात बग्स रखता है और उत्पादन के लिए तैयार नहीं है। विश्वसनीय उत्पादन उपयोग के लिए OBJ, STL, glTF, COLLADA, या 3MF का उपयोग करें।.

क्या मैं Aspose.3D FOSS को एक व्यावसायिक उत्पाद में उपयोग कर सकता हूँ? हाँ। लाइब्रेरी MIT लाइसेंस के तहत जारी की गई है, जो स्वामित्व और व्यावसायिक सॉफ़्टवेयर में उपयोग की अनुमति देती है बिना रॉयल्टी भुगतान के, बशर्ते लाइसेंस नोटिस शामिल किया जाए।.

मैं बग की रिपोर्ट कैसे करूँ या किसी फ़ॉर्मेट का अनुरोध कैसे करूँ? रिपॉज़िटरी में एक इश्यू खोलें। एक न्यूनतम पुनरुत्पादक फ़ाइल और Python संस्करण, ऑपरेटिंग सिस्टम, तथा लाइब्रेरी संस्करण शामिल करें। pip show aspose-3d-foss.

API रेफ़रेंस सारांश

मुख्य वर्ग

• Scene: 3D सीन के लिए टॉप-लेवल कंटेनर। एंट्री पॉइंट open(), from_file(), और save().
• Node: सीन ग्राफ में ट्री नोड। वह ले जाता है entity, transform, global_transform, material, child_nodes, और name.
• Entity: नोड्स से जुड़े ऑब्जेक्ट्स (Mesh, Camera, Light) के लिए बेस क्लास।.
• Transform: नोड के लिए स्थानीय-स्थान स्थिति, घूर्णन (क्वाटरनियन), और स्केल।.
• GlobalTransform: सभी पूर्वज ट्रांसफ़ॉर्म को संचित करके गणना किया गया केवल-पढ़ने योग्य विश्व-स्थान ट्रांसफ़ॉर्म।.

ज्यामिति

• Mesh: बहुभुज मेष के साथ control_points : (वर्टेक्स सूची) और polygons.
• VertexElementNormal: प्रति-वर्टेक्स या प्रति-बहुभुज सामान्य वेक्टर।.
• VertexElementUV: प्रति-वर्टेक्स यूवी टेक्सचर निर्देशांक।.
• VertexElementVertexColor: प्रति-वर्टेक्स रंग डेटा।.
• VertexElementSmoothingGroup: बहुभुज स्मूदिंग ग्रुप असाइनमेंट।.

मैटेरियल्स

• LambertMaterial: डिफ्यूज़ शेडिंग मॉडल के साथ diffuse_color : और emissive_color.
• PhongMaterial: स्पेक्यूलर शेडिंग मॉडल जो जोड़ता है specular_color : और shininess.

: गणित उपयोगिताएँ (aspose.threed.utilities)

• Vector2: 2D वेक्टर।.
• Vector3: 3D डबल-प्रिसीजन वेक्टर।.
• Vector4: 4D डबल-प्रिसीजन वेक्टर।.
• FVector3: 3D सिंगल-प्रिसीजन वेक्टर।.
• Quaternion: रोटेशन क्वाटरनियन के साथ from_angle_axis() और to_matrix().
• Matrix4: 4×4 ट्रांसफ़ॉर्मेशन मैट्रिक्स।.
• BoundingBox: एक्सिस-एलाइन्ड बाउंडिंग बॉक्स के साथ minimum और maximum : कोनों।.

एनिमेशन

• AnimationClip: एनिमेशन चैनलों के सेट और उनके कीफ़्रेम्स के लिए नामित कंटेनर।.
• AnimationNode: क्लिप के भीतर प्रति-नोड एनिमेशन डेटा।.
• KeyFrame: समय और मान के साथ एकल कीफ़्रेम।.
• KeyframeSequence: एकल एनिमेटेड प्रॉपर्टी के लिए कीफ़्रेम्स की क्रमबद्ध श्रृंखला।.

लोड / सेव विकल्प

• ObjLoadOptions: OBJ-विशिष्ट लोड सेटिंग्स: enable_materials, flip_coordinate_system, normalize_normal, scale.
• StlSaveOptions: STL-विशिष्ट सहेजने की सेटिंग्स (बाइनरी बनाम ASCII मोड)।.

कैमरे और लाइट्स

• Camera: प्रोजेक्शन सेटिंग्स वाला कैमरा एंटिटी, जिसे एक Node.
• Light: लाइट सोर्स एंटिटी, जिसे एक Node.