कैसे बनाएं 3D मेष Aspose.3D का उपयोग करके Python में

Aspose.3D FOSS for Python आपको पूरी तरह कोड में 3D ज्यामिति बनाने देता है: कोई बाहरी मॉडलिंग टूल आवश्यक नहीं। आप बनाते हैं एक Mesh, इसे वर्टेक्स पोजीशन से भरें (control_points) और फेस परिभाषाएँ (polygons), वैकल्पिक वर्टेक्स एट्रिब्यूट्स जैसे नॉर्मल्स संलग्न करें, फिर सीन को किसी भी समर्थित फॉर्मेट में सहेजें।.

स्टेप बाय स्टेप गाइड

स्टेप 1: पैकेज स्थापित करें

PyPI से Aspose.3D FOSS स्थापित करें। कोई नेटिव एक्सटेंशन या कंपाइलर टूलचेन आवश्यक नहीं है।.

pip install aspose-3d-foss

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

from aspose.threed import Scene
print("Aspose.3D FOSS ready")

समर्थित Python संस्करण: 3.7, 3.8, 3.9, 3.10, 3.11, 3.12.

चरण 2: एक सीन और एक नोड बनाएं

हर मेष को एक सीन ग्राफ के भीतर रहना चाहिए। एक बनाएं Scene और एक नामित जोड़ें Node मेश को रखने के लिए:

from aspose.threed import Scene

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

नोड का नाम निर्यातित फ़ाइल में संरक्षित रहता है और डिबगिंग तथा बाद में पुनः प्राप्ति के लिए उपयोगी है, के माध्यम से node.get_child("triangle").

चरण 3: एक Mesh ऑब्जेक्ट बनाएं

एक को इंस्टैंशिएट करें Mesh वैकल्पिक वर्णनात्मक नाम के साथ:

from aspose.threed.entities import Mesh

mesh = Mesh("triangle")

Mesh प्रारंभ में खाली है: कोई वर्टेक्स नहीं, कोई पॉलीगॉन नहीं। आप इसे अगले चरणों में भरते हैं।.

चरण 4: कंट्रोल पॉइंट्स (वर्टेक्स) जोड़ें

कंट्रोल पॉइंट्स वर्टेक्स पोजीशन होते हैं। प्रत्येक वर्टेक्स को एक के रूप में संग्रहीत किया जाता है Vector4(x, y, z, w) जहाँ w=1 3D स्थान में एक बिंदु दर्शाता है:

from aspose.threed.utilities import Vector4

##Vertex 0: origin
# Note: control_points returns a copy of the internal vertex list.
# Appending to the returned copy discards the vertex silently.
# Use _control_points to mutate the backing list directly.
# This is a known library limitation — a public add_control_point() API is not yet available.
mesh._control_points.append(Vector4(0.0, 0.0, 0.0, 1.0))

##Vertex 1: 1 unit along X
mesh._control_points.append(Vector4(1.0, 0.0, 0.0, 1.0))

##Vertex 2: apex
mesh._control_points.append(Vector4(0.5, 1.0, 0.0, 1.0))

print(f"Vertices added: {len(mesh.control_points)}")

महत्वपूर्ण: mesh.control_points एक लौटाता है कॉपी आंतरिक वर्टेक्स सूची का (getter निष्पादित करता है list(self._control_points)). कॉल कर रहा है mesh.control_points.append(v) कॉपी में जोड़ता है, मेष में नहीं, इसलिए वर्टेक्स चुपचाप हटाया जाता है। हमेशा उपयोग करें mesh._control_points.append(v) वर्टिसेज़ जोड़ने के लिए। private state तक पहुँचने के लिए _control_points एक ज्ञात वर्कअराउंड है; इंटरफ़ेस लाइब्रेरी के भविष्य के संस्करण में बदल सकता है।.

चरण 5: पॉलीगॉन फेस बनाएं

वर्टिस इंडेक्स का उपयोग करके फेस टोपोलॉजी परिभाषित करें। वर्टिस इंडेक्स को पास करें to create_polygon().तीन इंडेक्स एक त्रिभुज बनाते हैं; चार एक क्वाड बनाते हैं:

##Triangle: connect vertices 0 → 1 → 2
mesh.create_polygon(0, 1, 2)

print(f"Polygon count: {mesh.polygon_count}")

एक क्वाड मेष के लिए आप चार इंडेक्स पास करेंगे: mesh.create_polygon(0, 1, 2, 3).

इंडेक्स को … में वैध स्थितियों होना चाहिए control_points (0-आधारित, सीमा के भीतर)। विंडिंग क्रम बाहर की ओर मुख वाले नॉर्मल्स के लिए प्रतिक्लॉकवाइज़ है।.

चरण 6: वर्टेक्स नॉर्मल्स जोड़ें

वर्टिस नॉर्मल्स को एक … के रूप में संग्रहीत किया जाता है VertexElement मेश से जुड़ा हुआ। उपयोग करें mesh.create_element() के साथ VertexElementType.NORMAL, MappingMode.CONTROL_POINT, और ReferenceMode.DIRECT:

from aspose.threed.entities import VertexElementType, MappingMode, ReferenceMode, VertexElementNormal
from aspose.threed.utilities import Vector4, FVector4

##Create the normal element (returns VertexElementNormal, a VertexElementFVector subclass)
normals: VertexElementNormal = mesh.create_element(
    VertexElementType.NORMAL,
    MappingMode.CONTROL_POINT,
    ReferenceMode.DIRECT
)

##One normal per vertex: all pointing out of the XY plane (0, 0, 1)
normals.set_data([
    FVector4(0, 0, 1, 0),   # vertex 0
    FVector4(0, 0, 1, 0),   # vertex 1
    FVector4(0, 0, 1, 0),   # vertex 2
])

print("Normal layer attached.")

MappingMode.CONTROL_POINT का अर्थ है प्रत्येक वर्टिस के लिए एक नॉर्मल।. ReferenceMode.DIRECT का अर्थ है कि नॉर्मल डेटा को कंट्रोल पॉइंट्स के समान क्रम में पढ़ा जाता है (कोई अतिरिक्त इंडेक्स बफ़र नहीं)।.

नॉर्मल वेक्टर उपयोग करते हैं FVector4(x, y, z, w) के साथ w=0 एक स्थिति के बजाय दिशा दर्शाने के लिए।. FVector4 एक single-precision float vector है; vertex attribute data में VertexElementFVector उपवर्ग इस type का उपयोग करते हैं।.

चरण 7: मेष को नोड से जोड़ें और सहेजें

मेष को नोड में जोड़ें, फिर सीन को सहेजें:

node.add_entity(mesh)

scene.save("triangle.gltf")
print("Saved triangle.gltf")

पूरा कार्यशील स्क्रिप्ट (सभी चरणों को मिलाकर):

from aspose.threed import Scene
from aspose.threed.entities import Mesh, VertexElementType, MappingMode, ReferenceMode, VertexElementNormal
from aspose.threed.utilities import Vector3, Vector4, FVector4

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

mesh = Mesh("triangle")

##Add 3 vertices (x, y, z, w)
# Use _control_points to mutate the backing list directly (control_points returns a copy)
mesh._control_points.append(Vector4(0.0, 0.0, 0.0, 1.0))
mesh._control_points.append(Vector4(1.0, 0.0, 0.0, 1.0))
mesh._control_points.append(Vector4(0.5, 1.0, 0.0, 1.0))

##Create a triangle polygon
mesh.create_polygon(0, 1, 2)

##Add normals (create_element returns VertexElementNormal, a VertexElementFVector subclass)
normals: VertexElementNormal = mesh.create_element(VertexElementType.NORMAL, MappingMode.CONTROL_POINT, ReferenceMode.DIRECT)
normals.set_data([
    FVector4(0, 0, 1, 0),
    FVector4(0, 0, 1, 0),
    FVector4(0, 0, 1, 0),
])

node.add_entity(mesh)
scene.save("triangle.gltf")

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

समस्या	समाधान
`IndexError` में `create_polygon`	सुनिश्चित करें कि सभी सूचकांक … के भीतर हैं `range(len(mesh.control_points))`. सूचकांक 0-आधारित हैं।.
Mesh निर्यात शून्य शीर्ष बिंदुओं के साथ	`mesh.control_points.append(...)` चुपचाप शीर्ष बिंदुओं को त्याग देता है क्योंकि यह गुण एक प्रति लौटाता है। उपयोग करें `mesh._control_points.append(...)` इसके बजाय।.
नॉर्मल्स की गिनती शीर्ष बिंदुओं की गिनती से मेल नहीं खाती	जब उपयोग किया जाता है `MappingMode.CONTROL_POINT` + `ReferenceMode.DIRECT`, `normals.data` को बिल्कुल होना चाहिए `len(control_points)` प्रविष्टियाँ।.
Mesh सहेजी गई फ़ाइल में गायब है	पुष्टि करें कि `node.add_entity(mesh)` को पहले बुलाया गया था `scene.save()`. कोई भी नोड से जुड़ा नहीं हुआ Mesh निर्यात नहीं किया जाता है।.
गलत वाइंडिंग क्रम (सतह अदृश्य दिखाई देती है)	विपरीत-घड़ी दिशा में शीर्ष बिंदु क्रम बाहरी दिशा वाला नॉर्मल बनाता है। इंडेक्स क्रम को उलटें `create_polygon` इसे उलटने के लिए।.
`polygon_count` 0 लौटाता है	`polygon_count` उसी सूची को पढ़ता है जैसा कि `polygons`. यदि `create_polygon` को कॉल नहीं किया गया, सूची खाली है।.
नॉर्मल्स व्यूअर में गलत दिख रहे हैं।	सुनिश्चित करें कि सभी नॉर्मल वेक्टर यूनिट-लेंथ के हों। के साथ गणना करें `n / abs(n)` या प्री-नॉर्मलाइज़्ड मान पास करें।.

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

के बीच अंतर क्या है Vector3 और Vector4 कंट्रोल पॉइंट्स के लिए?

control_points संग्रहित करता है Vector4 ऑब्जेक्ट्स। The w घटक होमोजेनियस कोऑर्डिनेट है: उपयोग करें w=1 वर्टेक्स स्थितियों और w=0 दिशा वेक्टरों के लिए जैसे नॉर्मल्स।. Vector3 ट्रांसफ़ॉर्म (translation, scale) के लिए उपयोग किया जाता है, लेकिन geometry storage के लिए नहीं।.

क्या मैं त्रिभुजों के बजाय क्वाड्स के साथ मेष बना सकता हूँ?

हाँ। कॉल mesh.create_polygon(0, 1, 2, 3) चार इंडेक्स के साथ एक क्वाड को परिभाषित करने के लिए। कुछ सहेजने के लक्ष्य (STL, 3MF) त्रिभुजों की आवश्यकता रखते हैं और क्वाड्स को स्वचालित रूप से त्रिभुजित करेंगे। glTF और COLLADA क्वाड्स को संरक्षित रखते हैं।.

मैं UV कोऑर्डिनेट्स कैसे जोड़ूँ?

उपयोग करें mesh.create_element_uv(TextureMapping.DIFFUSE, MappingMode.POLYGON_VERTEX) एक बनाने के लिए VertexElementUV डिफ्यूज़ चैनल के लिए, फिर उसके data सूची को Vector4 एंट्रीज़। UV coordinates का उपयोग करें x और y; z और w आमतौर पर 0 होते हैं। पहला तर्क एक TextureMapping स्थिर (उदाहरण के लिए,., TextureMapping.DIFFUSE) यह पहचानते हुए कि UV लेयर किस टेक्सचर स्लॉट से संबंधित है।.

क्या मेष को सही ढंग से निर्यात करने के लिए नॉर्मल्स की आवश्यकता है?

नहीं। नॉर्मल्स वैकल्पिक हैं। यदि इन्हें छोड़ दिया जाए, तो अधिकांश व्यूअर्स बहुभुज की विंडिंग क्रम से प्रति-फेस नॉर्मल्स की गणना करते हैं। स्पष्ट प्रति-वर्टेक्स नॉर्मल्स जोड़ने से शेडिंग अधिक स्मूद हो जाती है।.

क्या मैं एक नोड में कई मेष जोड़ सकता हूँ?

हाँ। कॉल node.add_entity(mesh) कई बार। प्रत्येक कॉल एक नई इकाई को जोड़ता है node.entities. कुछ फ़ॉर्मेट निर्यात पर कई इकाइयों को एक में समतल कर सकते हैं।.

मैं मिश्रित बहुभुज प्रकारों वाले मेष को कैसे त्रिकोणीकृत करूँ?

कॉल mesh.triangulate() सभी क्वाड और N-गॉन को स्थान पर त्रिभुजों में बदलने के लिए। यह केवल त्रिभुजों को समर्थन करने वाले फ़ॉर्मेट में सहेजने से पहले उपयोगी है।.