Ghid practic: Conversia între formatele 3D în Python

Introducere

3D content rarely stays in a single format for its entire lifetime. A model may originate as an OBJ file exported from a modelling application, travel through a 3D printing pipeline as STL, appear in a web application as glTF, and end up in an additive manufacturing tool as 3MF. Each format serves a different audience and a different downstream tool, and conversion between them is something most 3D pipelines need to handle reliably.

Python este o alegere naturală pentru această sarcină: scripturile shell sunt prea fragile, iar integrările complete ale instrumentelor DCC (digital content creation) sunt prea grele pentru procesarea în lot. Ceea ce ai nevoie este o bibliotecă care să poată încărca oricare dintre aceste formate, să-ți ofere un graf de scenă consistent și să scrie înapoi în orice format țintă fără a necesita o interfață grafică (GUI) sau un driver grafic.

Aspose.3D FOSS pentru Python (aspose-3d-foss, licență MIT) acoperă acel gol. Acest ghid arată cele mai comune căi de conversie cu exemple de cod complete și executabile.

Ce formate suportă Aspose.3D FOSS?

Detectarea formatului este automată din extensia fișierului. Clasele de opțiuni specifice formatului (ObjLoadOptions, StlSaveOptions, GltfSaveOptions) sunt disponibile când aveți nevoie de control detaliat.

Notă despre FBX: Biblioteca include un tokenizer FBX parțial pentru import. FBX nu este recomandat pentru fluxuri de lucru de conversie în producție în această versiune; utilizați OBJ sau glTF ca formate intermediare în schimb.

OBJ la STL: Pregătirea unui model pentru imprimarea 3D

OBJ este cel mai comun format de ieșire din instrumentele de modelare și sculptură. STL este lingua franca a slicer-elor pentru imprimarea 3D. Conversia între ele se realizează printr-un singur apel.

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

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

opts = StlSaveOptions()
scene.save("model.stl", opts)

STL codifică doar fețe triunghiulare. Dacă fișierul dvs. OBJ conține fețe quad sau n-gon, exportatorul le triangulează automat înainte de scriere. Dacă doriți să controlați explicit triangularea înainte de salvare, apelați mesh.triangulate() pe fiecare plasă (mesh) din scenă:

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

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

def triangulate_all(node):
    for entity in list(node.entities):
        if isinstance(entity, Mesh):
            tri_mesh = entity.triangulate()
            # Attach the triangulated mesh via add_entity
            node.add_entity(tri_mesh)
    for child in node.child_nodes:
        triangulate_all(child)

triangulate_all(scene.root_node)
scene.save("model_triangulated.stl", StlSaveOptions())

OBJ la glTF: Export pentru web și motoare de jocuri

glTF 2.0 este formatul de interschimb preferat pentru randatoare în timp real, vizualizatoare WebGL și motoare de jocuri precum Babylon.js, Three.js și Unity. GLB (varianta binară) împachetează geometria, texturile și materialele într-un singur fișier auto-conținut, ceea ce îl face mai ușor de servit prin HTTP.

from aspose.threed import Scene
from aspose.threed.formats import GltfSaveOptions

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

##Save as JSON-based glTF (external buffer)
opts_gltf = GltfSaveOptions()
scene.save("model.gltf", opts_gltf)

##Save as self-contained GLB binary: preferred for web delivery
scene.save("model.glb", GltfSaveOptions())

Formatul este dedus din extensia fișierului: .gltf produce perechea JSON+buffer binar; .glb produce binarul într-un singur fișier. Datele de material OBJ (LambertMaterial, PhongMaterial) este transmis în reprezentarea materialului glTF PBR acolo unde există un echivalent.

STL la glTF: De la scanner sau ieșire CAD la web

Fișierele STL de la scanere 3D și sisteme CAD sunt intrări comune care trebuie să devină vizibile pe web. STL conține doar geometrie triunghiulară și nu date de material, așa că conversia este simplă.

from aspose.threed import Scene
from aspose.threed.formats import GltfSaveOptions

scene = Scene.from_file("scan.stl")
scene.save("scan.glb", GltfSaveOptions())

Dacă STL-ul a fost generat de un instrument CAD cu un sistem de coordonate neobișnuit (Z-up vs Y-up), poți inspecta și corecta transformarea nodului rădăcină înainte de salvare:

from aspose.threed import Scene
from aspose.threed.formats import GltfSaveOptions

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

##Rotate 90 degrees around X to convert Z-up to Y-up
root = scene.root_node
root.transform.set_euler_angles(-90.0, 0.0, 0.0)

scene.save("cad_export_yup.glb", GltfSaveOptions())

glTF la 3MF: Pregătirea pentru fabricație aditivă

3MF is a modern 3D printing format backed by the 3MF Consortium. It supports richer metadata than STL (colour, material assignments, build instructions) and is accepted by slicer software such as PrusaSlicer and Bambu Studio. If you are delivering models from a web viewer into a printing workflow, converting GLB to 3MF is a useful step.

from aspose.threed import Scene
from aspose.threed import FileFormat
from aspose.threed.formats import SaveOptions

scene = Scene.from_file("model.glb")
scene.save("model.3mf")

Formatul 3MF este detectat automat din .3mf extensie. Pentru control explicit, transmiteți un SaveOptions instanță configurată pentru 3MF.

Model de conversie în lot

În practică, sarcinile de conversie lucrează pe directoare de fișiere, nu pe fișiere individuale. Modelul următor gestionează un folder de fișiere OBJ și convertește fiecare în GLB, cu tratare a erorilor pe fișier, astfel încât un singur fișier defect nu întrerupe execuția completă.

import os
from aspose.threed import Scene
from aspose.threed.formats import GltfSaveOptions

input_dir = "./obj_files"
output_dir = "./glb_files"

os.makedirs(output_dir, exist_ok=True)

opts = GltfSaveOptions()
results = {"ok": [], "failed": []}

for filename in os.listdir(input_dir):
    if not filename.lower().endswith(".obj"):
        continue
    src = os.path.join(input_dir, filename)
    stem = os.path.splitext(filename)[0]
    dst = os.path.join(output_dir, stem + ".glb")
    try:
        scene = Scene.from_file(src)
        scene.save(dst, opts)
        results["ok"].append(filename)
        print(f"OK  {filename} -> {stem}.glb")
    except Exception as exc:
        results["failed"].append((filename, str(exc)))
        print(f"ERR {filename}: {exc}")

print(f"\n{len(results['ok'])} converted, {len(results['failed'])} failed.")
if results["failed"]:
    for name, reason in results["failed"]:
        print(f"  {name}: {reason}")

Acest model se extinde în mod natural la alte perechi de formate sursă/țintă: schimbați filtrul de extensie și SaveOptions clasa pentru orice combinație din tabelul de suport de mai sus.

Concluzie

Aspose.3D FOSS pentru Python face conversia de format simplă: încărcați cu Scene.from_file, opțional inspectați sau modificați graficul scenei, apoi salvați cu SaveOptions. Biblioteca gestionează triangularea, normalizarea coordonatelor și particularitățile specifice formatului în mod intern.

Pentru o listă completă de clase și metode, consultați Referința API. Pentru a aprofunda modelul de graf de scenă (nodes, meshes, transforms), vezi:

• Class Scene: încărcare, salvare și metadate la nivel de scenă
• Class Node: ierarhie, transformări, atașarea entităților
• Class Mesh: date de vertex, poligoane, elemente de vertex
• Cum să: Încărcarea fișierelor: Cum să încarci modele 3D în Python
• PyPI: aspose-3d-foss pe PyPI