Guia pràctica: Convertir entre formats 3D a Python

Introducció

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 és una solució natural per a aquesta tasca: els scripts de shell són massa fràgils, i les integracions completes d’eines DCC (digital content creation) són massa pesades per al processament per lots. El que necessites és una biblioteca que pugui carregar qualsevol d’aquests formats, proporcionar-te un gràfic d’escena coherent i escriure de nou a qualsevol format de destinació sense requerir una interfície gràfica (GUI) ni un controlador gràfic.

Aspose.3D FOSS per a Python (aspose-3d-foss, llicència MIT) cobreix aquest buit. Aquesta guia mostra els camins de conversió més comuns amb exemples de codi complets i executables.

Quins formats admet Aspose.3D FOSS?

La detecció del format és automàtica a partir de l’extensió del fitxer. Les classes d’opcions específiques del format (ObjLoadOptions, StlSaveOptions, GltfSaveOptions) estan disponibles quan necessiteu un control detallat.

Nota sobre FBX: La biblioteca inclou un tokenitzador parcial de FBX per a la importació. No es recomana FBX per a fluxos de treball de conversió de producció en aquesta versió; utilitzeu OBJ o glTF com a formats intermedis.

OBJ a STL: Preparació d’un model per a impressió 3D

OBJ és el format de sortida més comú de les eines de modelatge i esculpint. STL és la llengua franca dels talladors d’impressió 3D. Convertir entre ells es fa amb una única crida.

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 només codifica cares triangulars. Si el vostre fitxer OBJ conté cares de quàdruple o n-gó, l’exportador les triangula automàticament abans d’escriure. Si voleu controlar la triangulació explícitament abans de desar, crideu mesh.triangulate() a cada malla de l’escena:

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 a glTF: Exportació per a web i motors de jocs

glTF 2.0 és el format d’intercanvi preferit per a renderitzadors en temps real, visualitzadors WebGL i motors de jocs com Babylon.js, Three.js i Unity. GLB (la variant binària) empaqueta geometria, textures i materials en un únic fitxer autònom, el que facilita el seu servei per 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())

El format s’infereix a partir de l’extensió del fitxer: .gltf genera la parella JSON+buffer binari; .glb genera el binari d’un sol fitxer. Dades de material OBJ (LambertMaterial, PhongMaterial) es transmet a la representació del material glTF PBR on existeix un equivalent.

STL a glTF: Des de l’eixida d’un escàner o CAD cap al web

Els fitxers STL procedents d’escàners 3D i sistemes CAD són entrades comunes que cal fer visualitzables al web. STL només conté geometria triangular i cap dada de material, de manera que la conversió és senzilla.

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

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

Si l’STL va ser generat per una eina CAD amb un sistema de coordenades inusual (Z-up vs Y-up), pots inspeccionar i corregir la transformació del node arrel abans de desar:

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 a 3MF: Preparació per a la fabricació additiva

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")

El format 3MF es detecta automàticament des del .3mf extensió. Per a un control explícit, passa un SaveOptions instància configurada per a 3MF.

Patró de conversió per lots

En la pràctica, les tasques de conversió operen sobre directoris de fitxers en lloc de fitxers individuals. El patró següent gestiona una carpeta de fitxers OBJ i converteix cada un a GLB, amb gestió d’errors per fitxer perquè un únic fitxer defectuós no interrompi tota l’execució.

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}")

Aquest patró s’estén naturalment a altres parelles de formats d’origen/destinació: canvia el filtre d’extensió i el SaveOptions classe per a qualsevol combinació a la taula de suport anterior.

Conclusió

Aspose.3D FOSS per a Python fa que la conversió de formats sigui senzilla: carrega amb Scene.from_file, opcionalment inspecciona o modifica el gràfic de l’escena, després desa amb el apropiat SaveOptions. La biblioteca gestiona la triangulació, la normalització de coordenades i les peculiaritats específiques del format internament.

Per a una llista completa de classes i mètodes, consulta el Referència de l’API. Per aprofundir en el model de gràfic d’escena (nodes, meshes, transformacions), vegeu:

• Class Scene: càrrega, desament i metadades a nivell d’escena
• Class Node: jerarquia, transformacions, adjunció d’entitat
• Class Mesh: dades de vèrtex, polígons, elements de vèrtex
• Com fer: Carregar fitxers: Com carregar models 3D a Python
• PyPI: aspose-3d-foss a PyPI