Guide pratique : conversion entre les formats 3D dans Python

Introduction

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 est naturellement adapté à ce travail : les scripts shell sont trop fragiles, et les intégrations complètes d’outils DCC (digital content creation) sont trop lourdes pour le traitement par lots. Ce dont vous avez besoin, c’est d’une bibliothèque capable de charger n’importe lequel de ces formats, de vous fournir un graphe de scène cohérent, et d’écrire de nouveau dans n’importe quel format cible sans nécessiter d’interface graphique ni de pilote graphique.

Aspose.3D FOSS pour Python (aspose-3d-foss, licence MIT) comble cette lacune. Ce guide montre les chemins de conversion les plus courants avec des exemples de code complets et exécutables.

Quels formats Aspose.3D FOSS prend‑en charge ?

La détection du format est automatique à partir de l’extension du fichier. Les classes d’options spécifiques au format (ObjLoadOptions, StlSaveOptions, GltfSaveOptions) sont disponibles lorsque vous avez besoin d’un contrôle granulaire.

Note sur FBX : La bibliothèque inclut un tokenizer FBX partiel pour l’importation. FBX n’est pas recommandé pour les flux de travail de conversion en production dans cette version ; utilisez OBJ ou glTF comme formats intermédiaires à la place.

OBJ vers STL : préparer un modèle pour l’impression 3D

OBJ est le format de sortie le plus répandu des outils de modélisation et de sculpture. STL est la lingua franca des trancheurs d’impression 3D. La conversion entre les deux se fait en un seul appel.

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 ne encode que des faces triangulaires. Si votre fichier OBJ contient des faces quadrangulaires ou n-gon, l’exportateur les triangule automatiquement avant l’écriture. Si vous souhaitez contrôler explicitement la triangulation avant l’enregistrement, appelez mesh.triangulate() sur chaque maillage de la 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 vers glTF : exportation pour le web et les moteurs de jeu

glTF 2.0 est le format d’échange privilégié pour les rendus en temps réel, les visionneuses WebGL et les moteurs de jeu tels que Babylon.js, Three.js et Unity. GLB (la variante binaire) regroupe la géométrie, les textures et les matériaux dans un seul fichier autonome, ce qui facilite son diffusion 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())

Le format est déduit de l’extension du fichier : .gltf produit la paire JSON+tampon binaire ; .glb produit le binaire à fichier unique. Données de matériau OBJ (LambertMaterial, PhongMaterial) est transmis à la représentation de matériau glTF PBR lorsqu’un équivalent existe.

STL vers glTF : du scanner ou de la sortie CAD au web

Les fichiers STL provenant de scanners 3D et de systèmes CAO sont des entrées courantes qui doivent être rendues visualisables sur le web. STL ne contient que la géométrie en triangles et aucune donnée de matériau, donc la conversion est simple.

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

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

Si le STL a été produit par un outil CAO avec un système de coordonnées inhabituel (Z-up vs Y-up), vous pouvez inspecter et corriger la transformation du nœud racine avant d’enregistrer :

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 vers 3MF : Préparer la fabrication additive

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

Le format 3MF est détecté automatiquement à partir du .3mf extension. Pour un contrôle explicite, transmettez un SaveOptions instance configurée pour le 3MF.

Modèle de conversion par lots

En pratique, les tâches de conversion opèrent sur des répertoires de fichiers plutôt que sur des fichiers individuels. Le modèle suivant gère un dossier de fichiers OBJ et convertit chacun en GLB, avec une gestion des erreurs par fichier afin qu’un seul fichier défectueux n’interrompe pas l’ensemble du processus.

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

Ce modèle s’étend naturellement à d’autres paires de formats source/cible : modifiez le filtre d’extension et le SaveOptions classe pour toute combinaison dans le tableau de prise en charge ci‑dessus.

Conclusion

Aspose.3D FOSS pour Python rend la conversion de format simple : chargez avec Scene.from_file, inspectez ou modifiez éventuellement le graphe de scène, puis enregistrez avec le SaveOptions. La bibliothèque gère la triangulation, la normalisation des coordonnées et les particularités propres à chaque format en interne.

Pour une liste complète des classes et méthodes, consultez le Référence API. Pour approfondir le modèle de graphe de scène (nœuds, maillages, transformations), voir :

• Classe Scene: chargement, sauvegarde et métadonnées au niveau de la scène
• Classe Node: hiérarchie, transformations, attachement d’entité
• Classe Mesh: données de sommets, polygones, éléments de sommet
• Comment faire : Chargement de fichiers : Comment charger des modèles 3D dans Python
• PyPI : aspose-3d-foss sur PyPI