Praktischer Leitfaden: Konvertieren zwischen 3D-Formaten in Python

Einleitung

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 ist dafür prädestiniert: Shell‑Skripte sind zu fragil, und vollständige DCC‑(Digital Content Creation‑)Tool‑Integrationen sind für die Batch‑Verarbeitung zu schwer. Was Sie benötigen, ist eine Bibliothek, die jedes dieser Formate laden, Ihnen einen konsistenten Szenengraphen bereitstellen und wieder in jedes Zielformat schreiben kann, ohne dass eine GUI oder ein Grafiktreiber erforderlich ist.

Aspose.3D FOSS für Python (aspose-3d-foss, MIT-Lizenz) schließt diese Lücke. Dieser Leitfaden zeigt die gängigsten Konvertierungspfade mit vollständigen, ausführbaren Codebeispielen.

Welche Formate unterstützt Aspose.3D FOSS?

Die Format-Erkennung erfolgt automatisch anhand der Dateierweiterung. Format-spezifische Optionsklassen (ObjLoadOptions, StlSaveOptions, GltfSaveOptions) sind verfügbar, wenn Sie eine feinkörnige Kontrolle benötigen.

Hinweis zu FBX: Die Bibliothek enthält einen teilweisen FBX-Tokenizer für den Import. FBX wird in dieser Version nicht für Produktions‑Konvertierungs‑Workflows empfohlen; verwenden Sie stattdessen OBJ oder glTF als Zwischenformate.

OBJ zu STL: Vorbereitung eines Modells für den 3D‑Druck

OBJ ist das am häufigsten verwendete Ausgabeformat von Modellierungs‑ und Sculpting‑Tools. STL ist die Lingua Franca der 3D‑Druck‑Slicer. Die Konvertierung zwischen ihnen erfolgt mit einem einzigen Aufruf.

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 codiert nur Dreiecksflächen. Wenn Ihre OBJ-Datei Quad‑ oder n‑Gon‑Flächen enthält, trianguliert der Exporter diese automatisch vor dem Schreiben. Wenn Sie die Triangulation explizit vor dem Speichern steuern möchten, rufen Sie mesh.triangulate() für jedes Mesh in der Szene auf:

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 zu glTF: Export für Web‑ und Spiel‑Engines

glTF 2.0 ist das bevorzugte Austauschformat für Echtzeit‑Renderer, WebGL‑Viewer und Spiel‑Engines wie Babylon.js, Three.js und Unity. GLB (die binäre Variante) bündelt Geometrie, Texturen und Materialien in einer einzigen, eigenständigen Datei, die sich leichter über HTTP bereitstellen lässt.

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

Das Format wird aus der Dateierweiterung abgeleitet: .gltf erzeugt das JSON+Binary‑Buffer‑Paar; .glb erzeugt das einteilige Binärdatei. OBJ‑Materialdaten (LambertMaterial, PhongMaterial) wird in die glTF PBR-Materialdarstellung übernommen, wo ein Äquivalent existiert.

STL zu glTF: Von Scanner‑ oder CAD‑Ausgabe ins Web

STL‑Dateien von 3D‑Scannern und CAD‑Systemen sind gängige Eingaben, die web‑anschaulich gemacht werden müssen. STL enthält nur Dreiecksgeometrie und keine Materialdaten, sodass die Konvertierung unkompliziert ist.

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

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

Wenn das STL von einem CAD‑Tool mit einem ungewöhnlichen Koordinatensystem (Z‑up vs. Y‑up) erzeugt wurde, können Sie die Transformation des Wurzelknotens vor dem Speichern prüfen und korrigieren:

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 zu 3MF: Vorbereitung für die additive Fertigung

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

Das 3MF-Format wird automatisch anhand der .3mf Erweiterung erkannt. Für explizite Kontrolle übergeben Sie ein SaveOptions Instanz, die für 3MF konfiguriert ist.

Muster für Stapelkonvertierung

In der Praxis arbeiten Konvertierungsaufgaben mit Verzeichnissen von Dateien statt mit einzelnen Dateien. Das folgende Muster verarbeitet einen Ordner mit OBJ‑Dateien und konvertiert jede in GLB, wobei pro Datei eine Fehlerbehandlung erfolgt, sodass eine einzelne fehlerhafte Datei den gesamten Durchlauf nicht abbricht.

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

Dieses Muster lässt sich natürlich auf andere Quell-/Ziel-Formatpaare anwenden: Ändern Sie den Erweiterungsfilter und die SaveOptions Klasse für jede Kombination in der obigen Unterstützungstabelle.

Fazit

Aspose.3D FOSS für Python macht die Formatkonvertierung unkompliziert: Laden Sie mit Scene.from_file, prüfen oder modifizieren Sie optional den Szenengraphen und speichern Sie dann mit dem passenden SaveOptions. Die Bibliothek übernimmt intern Triangulierung, Koordinatennormalisierung und formatbezogene Eigenheiten.

Für eine vollständige Liste von Klassen und Methoden siehe die API-Referenz. Um tiefer in das Szenengraph‑Modell (Knoten, Meshes, Transformationen) einzutauchen, siehe:

• Klasse Scene: Laden, Speichern und szenenbezogene Metadaten
• Klasse Node: Hierarchie, Transformationen, Entitätsbindung
• Klasse Mesh: Vertexdaten, Polygone, Vertex‑Elemente
• Anleitung: Laden von Dateien: Wie man 3D-Modelle in Python lädt
• PyPI: aspose-3d-foss auf PyPI