Praktisk veiledning: Konvertering mellom 3D-formater i Python

Introduksjon

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 er en naturlig løsning for dette arbeidet: skallskript er for skjøre, og fullstendige DCC (digital content creation)-verktøyintegrasjoner er for tunge for batch‑behandling. Det du trenger er et bibliotek som kan laste inn noen av disse formatene, gi deg en konsistent scenegraf, og skrive tilbake til ethvert målformat uten å kreve et GUI eller en grafikkdriver.

Aspose.3D FOSS for Python (aspose-3d-foss, MIT-lisens) dekker dette gapet. Denne guiden viser de mest vanlige konverteringsveiene med komplette, kjørbare kodeeksempler.

Hvilke formater støtter Aspose.3D FOSS?

Formatgjenkjenning er automatisk fra filendelsen. Formatspesifikke alternativklasser (ObjLoadOptions, StlSaveOptions, GltfSaveOptions) er tilgjengelige når du trenger finjustert kontroll.

Merk om FBX: Biblioteket inkluderer en delvis FBX-tokenizer for import. FBX anbefales ikke for produksjonskonverteringsarbeidsflyter i denne utgivelsen; bruk OBJ eller glTF som mellomformater i stedet.

OBJ til STL: Forberede en modell for 3D‑utskrift

OBJ er det mest vanlige utdataformatet fra modellerings- og skulpturverktøy. STL er lingua franca for 3D‑utskriftskuttere. Å konvertere mellom dem er ett enkelt kall.

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 koder kun trekantflater. Hvis OBJ-filen din inneholder kvadratiske eller n-gon-flater, triangulerer eksportøren dem automatisk før skriving. Hvis du vil kontrollere trianguleringen eksplisitt før lagring, kall mesh.triangulate() på hver mesh i scenen:

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 til glTF: Eksport for nett og spillmotorer

glTF 2.0 er det foretrukne utvekslingsformatet for sanntidsrenderere, WebGL‑visere og spillmotorer som Babylon.js, Three.js og Unity. GLB (den binære varianten) pakker geometri, teksturer og materialer i én selvstendig fil, noe som er enklere å levere over 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())

Formatet blir avledet fra filendelsen: .gltf produserer JSON+binærbuffer-paret; .glb produserer den enkeltfil-binaryen. OBJ-materialdata (LambertMaterial, PhongMaterial) blir overført til glTF PBR-materialrepresentasjonen der en tilsvarende finnes.

STL til glTF: Fra skanner‑ eller CAD‑utdata til nett

STL-filer fra 3D-skannere og CAD-systemer er vanlige innganger som må gjøres web‑visbare. STL inneholder kun trekantgeometri og ingen materialdata, så konverteringen er enkel.

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

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

Hvis STL‑filen ble laget av et CAD‑verktøy med et uvanlig koordinatsystem (Z‑opp vs Y‑opp), kan du inspisere og korrigere rot‑node‑transformasjonen før lagring:

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 til 3MF: Forberedelse for additiv produksjon

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

3MF-formatet blir oppdaget automatisk fra .3mf filendelsen. For eksplisitt kontroll, send inn en SaveOptions instans konfigurert for 3MF.

Massekonvertering

I praksis opererer konverteringsoppgaver på kataloger med filer i stedet for enkeltfiler. Følgende mønster håndterer en mappe med OBJ‑filer og konverterer hver enkelt til GLB, med feilbehandling per fil slik at én dårlig fil ikke avbryter hele kjøringen.

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

Dette mønsteret utvides naturlig til andre kilde/mål-formatpar: endre utvidelsesfilteret og den SaveOptions klasse for enhver kombinasjon i støttetabellen ovenfor.

Konklusjon

Aspose.3D FOSS for Python gjør formatkonvertering enkel: last inn med Scene.from_file, eventuelt inspisere eller endre scene‑grafen, og deretter lagre med den passende SaveOptions. Biblioteket håndterer triangulering, koordinatnormalisering og formatspesifikke særegenheter internt.

For en fullstendig liste over klasser og metoder, se API‑referanse. For å gå dypere inn i scene‑grafmodellen (noder, mesh‑er, transformasjoner), se:

• Klasse Scene: lasting, lagring og metadata på scenenivå
• Klasse Node: hierarki, transformasjoner, tilknytning av enheter
• Klasse Mesh: vertex‑data, polygoner, vertex‑elementer
• Slik gjør du: Laste inn filer: Hvordan laste inn 3D‑modeller i Python
• PyPI: aspose-3d-foss på PyPI