Praktisk guide: Konvertering mellem 3D-formater 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 er en naturlig løsning til dette arbejde: shell‑scripts er for skrøbelige, og fulde DCC‑(digital content creation) værktøjsintegrationer er for tunge til batch‑behandling. Det du har brug for, er et bibliotek, der kan indlæse ethvert af disse formater, give dig en konsistent scene‑graf, og skrive tilbage til ethvert målformat uden at kræve en GUI eller en grafikkortdriver.

Aspose.3D FOSS til Python (aspose-3d-foss, MIT-licens) dækker dette hul. Denne vejledning viser de mest almindelige konverteringsveje med komplette, kørbare kodeeksempler.

Hvilke formater understøtter Aspose.3D FOSS?

Formatdetektion er automatisk ud fra filendelsen. Format‑specifikke optionsklasser (ObjLoadOptions, StlSaveOptions, GltfSaveOptions) er tilgængelige, når du har brug for finjusteret kontrol.

Bemærk om FBX: Biblioteket indeholder en delvis FBX‑tokenizer til import. FBX anbefales ikke til produktionskonverteringsarbejdsgange i denne udgave; brug i stedet OBJ eller glTF som mellemliggende formater.

OBJ til STL: Forberedelse af en model til 3D‑print

OBJ er det mest almindelige outputformat fra modellerings‑ og skulpturværktøjer. STL er lingua franca for 3D‑print‑slicere. Konvertering mellem dem er et enkelt kald.

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 kun koder trekantsflader. Hvis din OBJ‑fil indeholder quad‑ eller n‑gon‑flader, triangulerer eksportøren dem automatisk inden skrivning. Hvis du vil styre trianguleringen eksplicit før gemning, skal du kalde 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 til web‑ og spilmotorer

glTF 2.0 er det foretrukne udvekslingsformat for realtids‑renderere, WebGL‑visere og spilmotorer som Babylon.js, Three.js og Unity. GLB (den binære variant) pakker geometri, teksturer og materialer i én selvstændig fil, hvilket er lettere at 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 udledes fra filendelsen: .gltf producerer JSON+binær‑buffer‑parret; .glb producerer den enkelt‑fil binær. OBJ‑materialedata (LambertMaterial, PhongMaterial) overføres til glTF PBR‑materialerepræsentationen, hvor en ækvivalent findes.

STL til glTF: Fra scanner‑ eller CAD‑output til web

STL‑filer fra 3D‑scannere og CAD‑systemer er almindelige input, der skal gøres web‑visbare. STL indeholder kun trekantgeometri og ingen materialedata, så konverteringen er ligetil.

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

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

Hvis STL’en er produceret af et CAD‑værktøj med et usædvanligt koordinatsystem (Z‑op vs Y‑op), kan du inspicere og korrigere rotnodens transformation inden gemning:

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 til additiv fremstilling

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 detekteres automatisk fra .3mf filendelsen. For eksplicit kontrol, send en SaveOptions instans konfigureret til 3MF.

Massekonverteringsmønster

I praksis kører konverteringsopgaver på mapper med filer frem for enkelte filer. Det følgende mønster håndterer en mappe med OBJ‑filer og konverterer hver enkelt til GLB, med fejlhåndtering pr. fil, så en enkelt dårlig fil ikke afbryder hele kørslen.

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ønster udvides naturligt til andre kilde-/målformatpar: ændr udvidelsesfilteret og den SaveOptions klasse for enhver kombination i supporttabellen ovenfor.

Konklusion

Aspose.3D FOSS for Python gør formatkonvertering ligetil: indlæs med Scene.from_file, kan du eventuelt inspicere eller ændre scene‑grafen, og derefter gemme med den passende SaveOptions. Biblioteket håndterer triangulering, koordinatnormalisering og format‑specifikke særheder internt.

For en komplet liste over klasser og metoder, se API‑reference. For at gå dybere ind i scene‑grafmodellen (noder, mesh‑objekter, transformationer), se:

• Klasse Scene: indlæsning, gemning og metadata på sceneniveau
• Klasse Node: hierarki, transformationer, tilknytning af enheder
• Klasse Mesh: vertexdata, polygoner, vertex‑elementer
• Sådan gør du: Indlæsning af filer: Sådan indlæses 3D-modeller i Python
• PyPI: aspose-3d-foss på PyPI