Guía práctica: conversión entre formatos 3D en Python

Introducción

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 es una opción natural para este trabajo: los scripts de shell son demasiado frágiles, y las integraciones completas de herramientas DCC (creación de contenido digital) son demasiado pesadas para el procesamiento por lotes. Lo que necesitas es una biblioteca que pueda cargar cualquiera de estos formatos, proporcionarte un grafo de escena coherente y volver a escribir en cualquier formato de destino sin requerir una GUI ni un controlador gráfico.

Aspose.3D FOSS para Python (aspose-3d-foss, licencia MIT) cubre esa brecha. Esta guía muestra las rutas de conversión más comunes con ejemplos de código completos y ejecutables.

¿Qué formatos admite Aspose.3D FOSS?

La detección del formato es automática a partir de la extensión del archivo. Las clases de opciones específicas del formato (ObjLoadOptions, StlSaveOptions, GltfSaveOptions) están disponibles cuando necesitas un control granular.

Nota sobre FBX: La biblioteca incluye un tokenizador parcial de FBX para importación. FBX no se recomienda para flujos de trabajo de conversión en producción en esta versión; usa OBJ o glTF como formatos intermedios en su lugar.

OBJ a STL: Preparando un modelo para impresión 3D

OBJ es el formato de salida más común de las herramientas de modelado y escultura. STL es la lingua franca de los slicers de impresión 3D. Convertir entre ellos es una única llamada.

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 solo codifica caras triangulares. Si tu archivo OBJ contiene caras cuádruples o n-gon, el exportador las triangula automáticamente antes de escribir. Si deseas controlar la triangulación explícitamente antes de guardar, llama a mesh.triangulate() en cada malla de la 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: Exportando para web y motores de juego

glTF 2.0 es el formato de intercambio preferido para renderizadores en tiempo real, visores WebGL y motores de juego como Babylon.js, Three.js y Unity. GLB (la variante binaria) empaqueta geometría, texturas y materiales en un único archivo autocontenido, lo que facilita su entrega por 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 formato se infiere a partir de la extensión del archivo: .gltf produce el par JSON+buffer binario; .glb produce el binario de un solo archivo. Datos de material OBJ (LambertMaterial, PhongMaterial) se lleva al modelo de material glTF PBR donde existe un equivalente.

STL a glTF: De escáner o salida CAD a la web

Los archivos STL de escáneres 3D y sistemas CAD son entradas comunes que deben hacerse visibles en la web. STL solo contiene geometría triangular y no datos de material, por lo que la conversión es directa.

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

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

Si el STL fue producido por una herramienta CAD con un sistema de coordenadas inusual (Z-up vs Y-up), puedes inspeccionar y corregir la transformación del nodo raíz antes de guardar:

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ón para la Fabricación Aditiva

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 formato 3MF se detecta automáticamente a partir del .3mf extensión. Para un control explícito, pase un SaveOptions instancia configurada para 3MF.

Patrón de Conversión por Lotes

En la práctica, las tareas de conversión operan sobre directorios de archivos en lugar de archivos individuales. El siguiente patrón maneja una carpeta de archivos OBJ y convierte cada uno a GLB, con manejo de errores por archivo para que un solo archivo defectuoso no aborta toda la ejecución.

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

Este patrón se extiende de forma natural a otras parejas de formatos origen/destino: cambie el filtro de extensión y el SaveOptions clase para cualquier combinación en la tabla de soporte anterior.

Conclusión

Aspose.3D FOSS para Python hace que la conversión de formatos sea sencilla: cargue con Scene.from_file, opcionalmente inspeccione o modifique el grafo de escena, luego guarde con el apropiado SaveOptions. La biblioteca maneja la triangulación, la normalización de coordenadas y las peculiaridades específicas de cada formato internamente.

Para obtener una lista completa de clases y métodos, consulte el Referencia de API. Para profundizar en el modelo de grafo de escena (nodos, mallas, transformaciones), vea:

• Clase Scene: carga, guardado y metadatos a nivel de escena
• Clase Node: jerarquía, transformaciones, adjunto de entidad
• Clase Mesh: datos de vértices, polígonos, elementos de vértice
• Cómo cargar modelos 3D en Python
• PyPI: aspose-3d-foss