Guida pratica: conversione tra formati 3D in Python

Introduzione

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 è una scelta naturale per questo lavoro: gli script shell sono troppo fragili, e le integrazioni complete di strumenti DCC (digital content creation) sono troppo pesanti per l’elaborazione batch. Ciò di cui hai bisogno è una libreria che possa caricare qualsiasi di questi formati, fornire un grafo di scena coerente e scrivere nuovamente in qualsiasi formato di destinazione senza richiedere una GUI o un driver grafico.

Aspose.3D FOSS per Python (aspose-3d-foss, licenza MIT) colma questa lacuna. Questa guida mostra i percorsi di conversione più comuni con esempi di codice completi e eseguibili.

Quali formati supporta Aspose.3D FOSS?

Il rilevamento del formato è automatico dall’estensione del file. Le classi di opzioni specifiche per il formato (ObjLoadOptions, StlSaveOptions, GltfSaveOptions) sono disponibili quando è necessario un controllo granulare.

Nota su FBX: La libreria include un tokenizzatore FBX parziale per l’importazione. FBX non è consigliato per i flussi di lavoro di conversione in produzione in questa versione; usa OBJ o glTF come formati intermedi invece.

OBJ a STL: preparare un modello per la stampa 3D

OBJ è il formato di output più comune proveniente da strumenti di modellazione e scultura. STL è la lingua franca dei slicer per la stampa 3D. Convertirli tra loro richiede una singola chiamata.

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 codifica solo facce triangolari. Se il tuo file OBJ contiene facce quad o n-gon, l’esportatore le triangola automaticamente prima di scrivere. Se desideri controllare esplicitamente la triangolazione prima di salvare, chiama mesh.triangulate() su ogni mesh nella scena:

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: esportazione per il web e i motori di gioco

glTF 2.0 è il formato di interscambio preferito per renderer in tempo reale, visualizzatori WebGL e motori di gioco come Babylon.js, Three.js e Unity. GLB (la variante binaria) raggruppa geometria, texture e materiali in un unico file autonomo, più facile da servire via 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())

Il formato è dedotto dall’estensione del file: .gltf genera la coppia JSON+buffer binario; .glb genera il binario a file singolo. I dati del materiale OBJ (LambertMaterial, PhongMaterial) vengono trasferiti alla rappresentazione del materiale glTF PBR dove esiste un equivalente.

STL a glTF: da scanner o output CAD al web

I file STL provenienti da scanner 3D e sistemi CAD sono input comuni che devono essere resi visualizzabili sul web. STL contiene solo geometria a triangolo e nessun dato di materiale, quindi la conversione è semplice.

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

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

Se lo STL è stato prodotto da uno strumento CAD con un sistema di coordinate insolito (Z-up vs Y-up), è possibile ispezionare e correggere la trasformazione del nodo radice prima di 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 a 3MF: Preparazione per la Produzione 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")

Il formato 3MF viene rilevato automaticamente dal .3mf estensione. Per un controllo esplicito, passa un SaveOptions istanza configurata per 3MF.

Modello di Conversione Batch

In pratica, le attività di conversione operano su directory di file piuttosto che su file singoli. Il modello seguente gestisce una cartella di file OBJ e converte ciascuno in GLB, con gestione degli errori per file in modo che un singolo file difettoso non interrompa l’intera esecuzione.

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

Questo schema si estende naturalmente ad altre coppie di formati sorgente/obiettivo: modifica il filtro di estensione e il SaveOptions classe per qualsiasi combinazione nella tabella di supporto sopra.

Conclusione

Aspose.3D FOSS per Python rende la conversione dei formati semplice: carica con Scene.from_file, opzionalmente ispeziona o modifica il grafo della scena, quindi salva con il formato appropriato SaveOptions.La libreria gestisce internamente la triangolazione, la normalizzazione delle coordinate e le particolarità specifiche del formato.

Per un elenco completo di classi e metodi, consulta il Riferimento API. Per approfondire il modello del grafo della scena (nodi, mesh, trasformazioni), vedi:

• Classe Scene: caricamento, salvataggio e metadati a livello di scena
• Classe Node: gerarchia, trasformazioni, collegamento di entità
• Classe Mesh: dati dei vertici, poligoni, elementi dei vertici
• Guida: Caricamento file: Come caricare modelli 3D in Python
• PyPI: aspose-3d-foss su PyPI