Praktisk vejledning: Konvertering mellem 3D-formater i Python

Indledning

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 et naturligt fit for dette arbejde: shell-skripter er alt for skrøbelige, og fuld DCC (digital content creation) værktøj integrationer er for tunge til batch behandling. Hvad du har brug for er en bibliotek, der kan indlæse nogen af disse formater, give dig en konsekvent scene graf, Og skrive tilbage til ethvert målformat uden at kræve en GUI eller grafik driver.

3D FOSS til Python (aspose-3d-foss,Denne vejledning viser de mest almindelige konverteringsveje med komplette, klattelige kodesprøver.

Hvilke formater understøttes af Aspose.3D FOSS?

Formatdetektering sker automatisk fra filudvidelsen.ObjLoadOptions, StlSaveOptions, GltfSaveOptions) er tilgængelige, når du har brug for en fingrøn kontrol.

Bemærkning om FBX: Biblioteket indeholder en del af FBX-tokeniser til import. FBx anbefales ikke til produktionskonvertering i denne udgave; brug OBJ eller glTF som mellemformater i stedet.

OBJ til STL: Forberedelse af en model til 3D-udskrivning

OBJ er det mest almindelige udgangsformat fra modellerings- og skulpturværktøjer. STL er lingua franca for 3D-printing slicers. Konvertering mellem dem er et enkelt opkald.

from aspose.threed import Scene
from aspose.threed.formats import StlSaveOptions

scene = Scene.from_file("model.obj")

opts = StlSaveOptions()
scene.save("model.stl", opts)

Hvis OBJ-filen indeholder quad eller n-gon ansigter, triangulerer eksportøren dem automatisk før skrivning. Hvis du vil kontrollere trianguleringen udtrykkeligt inden lagring, skal du ringe til: mesh.triangulate() på hvert maskestykke 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):
    if isinstance(node.entity, Mesh):
        # entity setter clears existing entities and sets the new one
        node.entity = node.entity.triangulate()
    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 web- og spilmotorer

glTF 2.0 er det foretrukne udvekslingsformat til realtids-renderere, WebGL-visere og spilmotorer som Babylon.js, Three. js og Unity. GLB (den binære variant) pakker geometri, teksturer og materialer i en enkelt selvstændig fil, hvilket er lettere at tjene 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 er afledt fra filudvidelsen: .gltf producerer JSON+binær-bufferparet; .glb genererer binær data i en enkeltfil.LambertMaterial, PhongMaterial) overføres til glTF-PBR-materiale, hvis der findes et tilsvarende.

STL til glTF: Fra scanner- eller CAD-udgang til web

STL-filer fra 3D-scannere og CAD-systemer er almindelige indgange, der skal gøres synlige på nettet. ST L bærer kun trekantgeometri og ingen materialeoplysninger, 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’en er produceret af et CAD-værktøj med et usædvanligt koordinatsystem (Z-op vs. Y-up), kan du inspicere og korrigere rodknottransformationen, før du gemmer:

import math
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
# set_euler_angles takes radians, not degrees
root = scene.root_node
root.transform.set_euler_angles(-math.pi / 2, 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 registreres automatisk fra den .3mf For eksplicit kontrol skal der gives en SaveOptions Instans konfigureret til 3MF.

Batch-omregningsmønster

I praksis opererer konverteringsopgaver på mapper af filer snarere end individuelle filer. Det følgende mønster håndterer en mappen med OBJ-filer og konverterer hver enkelt til GLB, med fejlbehandling pr. fil, så en enkelt dårlig fil ikke afbryder hele udførelsen.

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 udvider sig naturligt til andre kildemåls/målformatspar: skift forlængelsesfilteret og den indbyggede tekst. SaveOptions klasse for enhver kombination i ovenstående støttetabell.

Konklusion:

Aspose.3D FOSS for Python gør formatkonvertering enkel: indlæse med Scene.from_file, kan man vælge at inspicere eller ændre scenegrafen, og derefter gemme med den relevante SaveOptions.Biblioteket håndterer triangulation, koordinatnormalisering og format-specifikke særtræk internt.

For en fuldstændig liste over klasser og metoder, se “Klasse-metode” i denne artikel. API-reference.For at gå dybere ind i scenegrafmodellen (knob, mesh og transformationer), se:

• Klassescenen: indlæse, gemme og scene-niveau metadata
• Klasse-node: hierarki, transformationer, enhedsanlæg
• Klasse Mesh: data om vinkelpunkterne, polygoner og elementer i vekselpunktet
• Hvordan man indlæser 3D-modeller i Python
• PyPI: aspose-3d-foss