Praktisk guide: Konvertera mellan 3D-format i Python

Introduktion

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 är en naturlig matchning för detta arbete: skal‑skript är för sköra, och fullständiga DCC‑integreringar (digital content creation) är för tunga för batch‑behandling. Det du behöver är ett bibliotek som kan läsa in något av dessa format, ge dig ett konsekvent scen‑graf, och skriva tillbaka till vilket målformat som helst utan att kräva ett GUI eller en grafikdrivrutin.

Aspose.3D FOSS för Python (aspose-3d-foss, MIT-licens) täcker det gapet. Den här guiden visar de vanligaste konverteringsvägarna med kompletta, körbara kodexempel.

Vilka format stöder Aspose.3D FOSS?

Formatdetektering är automatisk utifrån filändelsen. Format‑specifika alternativklasser (ObjLoadOptions, StlSaveOptions, GltfSaveOptions) är tillgängliga när du behöver finmaskig kontroll.

Obs på FBX: Biblioteket innehåller en partiell FBX‑tokeniserare för import. FBX rekommenderas inte för produktionskonverteringsarbetsflöden i denna version; använd OBJ eller glTF som mellanformat istället.

OBJ till STL: Förbereda en modell för 3D-utskrift

OBJ är det vanligaste exportformatet från modellerings- och skulpteringsverktyg. STL är lingua franca för 3D-utskriftsslicers. Att konvertera mellan dem är ett enda anrop.

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 kodar endast trekantiga ytor. Om din OBJ‑fil innehåller fyrkantiga eller n‑gon‑ytor triangulerar exportören dem automatiskt innan skrivning. Om du vill styra trianguleringen explicit innan du sparar, anropa mesh.triangulate() på varje 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 till glTF: Export för webb och spelmotorer

glTF 2.0 är det föredragna utbytesformatet för realtidsrenderare, WebGL‑visare och spelmotorer som Babylon.js, Three.js och Unity. GLB (den binära varianten) paketerar geometri, texturer och material i en enda självständig fil, vilket är enklare att leverera 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())

Formatet härleds från filändelsen: .gltf producerar JSON+binär‑buffer‑paret; .glb producerar den enkelfils‑binära filen. OBJ‑materialdata (LambertMaterial, PhongMaterial) förs vidare till glTF PBR‑materialrepresentationen där en motsvarighet finns.

STL till glTF: Från skanner‑ eller CAD‑utdata till webben

STL-filer från 3D-skannrar och CAD-system är vanliga indata som måste göras webbläsbara. STL innehåller endast triangelgeometri och ingen materialdata, så konverteringen är enkel.

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

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

Om STL-filen skapades av ett CAD-verktyg med ett ovanligt koordinatsystem (Z-upp vs Y-upp), kan du inspektera och korrigera rotnodens transform innan du sparar:

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 till 3MF: Förberedelse för additiv tillverkning

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 upptäcks automatiskt från den .3mf filändelsen. För explicit kontroll, skicka en SaveOptions instans konfigurerad för 3MF.

Mönster för batchkonvertering

I praktiken körs konverteringsuppgifter på kataloger med filer snarare än enskilda filer. Följande mönster hanterar en mapp med OBJ-filer och konverterar var och en till GLB, med felhantering per fil så att en enda felaktig fil inte avbryter hela körningen.

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

Detta mönster utökas naturligt till andra källa/mål-formatpar: ändra filtret för filändelser och den SaveOptions klass för vilken kombination som helst i stödtabellen ovan.

Slutsats

Aspose.3D FOSS för Python gör formatkonvertering enkel: ladda med Scene.from_file, valfritt inspektera eller modifiera scengrafen, och sedan spara med lämplig SaveOptions. Biblioteket hanterar triangulering, koordinatnormalisering och format‑specifika egenheter internt.

För en fullständig lista över klasser och metoder, se API‑referens. För att gå djupare in på scengrafmodellen (noder, meshar, transformationer), se:

• Klass Scene: inläsning, sparande och metadata på scen‑nivå
• Klass Node: hierarki, transformationer, entitets‑koppling
• Klass Mesh: vertex data, polygons, vertex elements
• Instruktion: Laddar filer: Hur man laddar 3D-modeller i Python
• PyPI: aspose-3d-foss på PyPI