Praktische gids: converteren tussen 3D-formaten in Python

Introductie

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 is een natuurlijke keuze voor dit werk: shell‑scripts zijn te fragiel, en volledige DCC (digital content creation)‑toolintegraties zijn te zwaar voor batchverwerking. Wat je nodig hebt is een bibliotheek die elk van deze formaten kan laden, je een consistente scene‑graph biedt, en terug kan schrijven naar elk doelformaat zonder een GUI of grafische driver te vereisen.

Aspose.3D FOSS voor Python (aspose-3d-foss, MIT-licentie) vult dat gat. Deze gids toont de meest voorkomende conversiepaden met volledige, uitvoerbare codevoorbeelden.

Welke formaten ondersteunt Aspose.3D FOSS?

Formaatdetectie is automatisch op basis van de bestandsextensie. Formaat‑specifieke optieklassen (ObjLoadOptions, StlSaveOptions, GltfSaveOptions) zijn beschikbaar wanneer je fijnmazige controle nodig hebt.

Opmerking over FBX: De bibliotheek bevat een gedeeltelijke FBX-tokenizer voor import. FBX wordt niet aanbevolen voor productie‑conversieworkflows in deze release; gebruik in plaats daarvan OBJ of glTF als tussenformaten.

OBJ naar STL: een model voorbereiden voor 3D‑printen

OBJ is het meest voorkomende uitvoerformaat van modellerings‑ en beeldhouwtools. STL is de lingua franca van 3D‑print‑slicers. Converteren tussen beide is één enkele aanroep.

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 codeert alleen driehoekige vlakken. Als je OBJ‑bestand quad‑ of n‑gon‑vlakken bevat, trianguleert de exporteur deze automatisch vóór het schrijven. Als je de triangulatie expliciet wilt beheersen vóór het opslaan, roep dan mesh.triangulate() op elke mesh in de scène:

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 naar glTF: exporteren voor web‑ en game‑engines

glTF 2.0 is het voorkeurs‑interchange‑formaat voor realtime renderers, WebGL‑viewers en game‑engines zoals Babylon.js, Three.js en Unity. GLB (de binaire variant) verpakt geometrie, textures en materialen in één enkel zelf‑voorzienend bestand, wat makkelijker te serveren is 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())

Het formaat wordt afgeleid van de bestandsextensie: .gltf produceert het JSON+binary-buffer-paar; .glb produceert de één‑bestand‑binary. OBJ‑materiaaldata (LambertMaterial, PhongMaterial) wordt doorgegeven aan de glTF PBR‑materiaalrepresentatie waar een equivalent bestaat.

STL naar glTF: van scanner‑ of CAD‑output naar het web

STL‑bestanden van 3D‑scanners en CAD‑systemen zijn veelvoorkomende invoer die web‑bekijkbaar moeten worden gemaakt. STL bevat alleen driehoekgeometrie en geen materiaald gegevens, dus de conversie is eenvoudig.

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

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

Als de STL is geproduceerd door een CAD‑tool met een ongewoon coördinatensysteem (Z‑up versus Y‑up), kun je de transformatie van de root‑node inspecteren en corrigeren voordat je opslaat:

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 naar 3MF: Voorbereiden op Additive Manufacturing

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

Het 3MF‑formaat wordt automatisch gedetecteerd vanuit de .3mf extensie. Voor expliciete controle, geef een SaveOptions instance geconfigureerd voor 3MF.

Batchconversie

In de praktijk werken conversietaken op mappen met bestanden in plaats van op individuele bestanden. Het onderstaande patroon verwerkt een map met OBJ‑bestanden en converteert elk bestand naar GLB, met foutafhandeling per bestand zodat één slecht bestand de volledige uitvoering niet onderbreekt.

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

Dit patroon breidt zich natuurlijk uit naar andere bron/doel‑formaatparen: wijzig de extensiefilter en de SaveOptions klasse voor elke combinatie in de bovenstaande ondersteuningstabel.

Conclusie

Aspose.3D FOSS voor Python maakt formaatconversie eenvoudig: laad met Scene.from_file, inspecteer of wijzig optioneel de scenegraph, en sla vervolgens op met de juiste SaveOptions. De bibliotheek behandelt triangulatie, coördinatennormalisatie en formaat‑specifieke eigenaardigheden intern.

Voor een volledige lijst van klassen en methoden, zie de API-referentie. Voor een dieper inzicht in het scenegraph‑model (nodes, meshes, transformaties), zie:

• Klasse Scene: laden, opslaan en metadata op scenenniveau
• Klasse Node: hiërarchie, transformaties, entiteit‑koppeling
• Klasse Mesh: vertexgegevens, polygonen, vertex‑elementen
• Handleiding: Bestanden laden: Hoe 3D‑modellen te laden in Python
• PyPI: aspose-3d-foss op PyPI