Conversion entre les formats 3D en TypeScript avec Aspose.3D FOSS

Les développeurs Node.js qui travaillent avec du contenu 3D doivent souvent convertir entre formats : un outil de conception exporte OBJ, un moteur de rendu web attend GLB, une imprimante 3D nécessite STL, et une chaîne de fabrication utilise 3MF. Gérer ces conversions avec une API unique et cohérente réduit le nombre d’outils externes dans une pipeline et maintient la logique de conversion dans le code de l’application, où elle peut être testée et versionnée.

Le @aspose/3d Le package (v24.12.0, licence MIT) fournit une API TypeScript-first pour lire et écrire tous les principaux formats 3D dans Node.js. Ce guide décrit les flux de conversion les plus courants.

Installation

npm install @aspose/3d

Exigences : Node.js 18, 20 ou 22 ; TypeScript 5.0 ou supérieur. La seule dépendance d’exécution est xmldom.

Formats pris en charge

Le tableau ci‑dessous répertorie les formats couverts dans ce guide ainsi que leur prise en charge en lecture/écriture.

OBJ prend en charge à la fois l’importation et l’exportation. Chargez avec scene.open() et enregistrez avec scene.save('output.obj'), ou convertissez vers tout autre format pris en charge tel que glTF, STL ou 3MF.

OBJ vers GLB (Livraison Web)

Convertir OBJ en glTF binaire (GLB) est le flux de travail web le plus courant. GLB est un paquet binaire autonome : textures, géométrie et métadonnées dans un seul fichier, ce qui le rend efficace pour la diffusion HTTP et le chargement direct par Three.js, Babylon.js et model‑viewer.

import { Scene } from '@aspose/3d';

function convertObjToGlb(inputPath: string, outputPath: string): void {
  const scene = new Scene();
  scene.open(inputPath);
  scene.save(outputPath);  // extension '.glb' selects binary GLB format
  console.log(`Converted ${inputPath} -> ${outputPath}`);
}

convertObjToGlb('model.obj', 'model.glb');

Le format de sortie est déduit de l’extension du fichier. Utilisez .glb pour le GLB binaire ou .gltf pour le JSON séparé + .bin mise en page.

OBJ vers STL (Préparation Impression 3D)

STL est la lingua franca de l’impression 3D FDM et SLA. Les trancheurs comme PrusaSlicer, Bambu Studio et Chitubox acceptent tous le STL. Convertir d’OBJ en STL est simple car les deux formats stockent des maillages triangulaires.

import { Scene } from '@aspose/3d';

function convertObjToStl(inputPath: string, outputPath: string): void {
  const scene = new Scene();
  scene.open(inputPath);
  scene.save(outputPath);  // extension '.stl' selects STL format
  console.log(`STL written to ${outputPath}`);
}

convertObjToStl('part.obj', 'part.stl');

STL ne stocke pas les couleurs, les matériaux ou les données UV. Si votre fichier OBJ utilise des groupes de matériaux, ces informations sont perdues lors de l’exportation. Pour des formats d’impression conservant la couleur, envisagez plutôt le 3MF (voir ci‑dessous).

STL vers glTF (Scanner et CAO vers le Web)

Les scanners à lumière structurée et les exportateurs CAO paramétriques produisent couramment du STL. Convertir en glTF rend la géométrie accessible dans les visionneuses web et les plateformes AR sans étape de rendu côté serveur.

import { Scene } from '@aspose/3d';

function convertStlToGltf(inputPath: string, outputPath: string): void {
  const scene = new Scene();
  scene.open(inputPath);
  // extension '.gltf' saves as JSON + .bin sidecar
  scene.save(outputPath);
  console.log(`glTF written to ${outputPath}`);
}

convertStlToGltf('scan_output.stl', 'scan_output.gltf');

Comme le STL ne contient aucune information de matériau ou de texture, le fichier glTF résultant ne contiendra que la géométrie. Vous pouvez ajouter des matériaux de façon programmatique aux nœuds de la scène après le chargement si nécessaire.

3MF to glTF (Manufacturing to Visualization)

Le format de fabrication 3D (3MF) est de plus en plus utilisé dans les flux de travail de fabrication additive car il stocke la couleur, les matériaux, les arbres de composants et les métadonnées d’impression aux côtés de la géométrie. Convertir le 3MF en glTF permet la visualisation en aval dans les outils web tout en préservant la structure de la scène.

import { Scene } from '@aspose/3d';

function convert3mfToGlb(inputPath: string, outputPath: string): void {
  const scene = new Scene();
  scene.open(inputPath);
  scene.save(outputPath);  // extension '.glb' selects binary GLB format
  console.log(`3MF -> GLB: ${outputPath}`);
}

convert3mfToGlb('assembly.3mf', 'assembly.glb');

3MF files often contain multi-component assemblies. The scene graph produced by scene.open() préserve la hiérarchie des composants dans scene.rootNode.childNodes, de sorte que vous puissiez inspecter ou manipuler les pièces individuelles avant l’enregistrement.

Modèle de conversion par lots

Lors du traitement d’un répertoire de fichiers, encapsulez chaque conversion dans un try/catch afin qu’un seul fichier corrompu n’annule pas l’ensemble du lot.

import { Scene } from '@aspose/3d';
import { readdirSync } from 'fs';
import { join, basename, extname } from 'path';

interface ConversionResult {
  input: string;
  output: string;
  success: boolean;
  error?: string;
}

function batchConvertToGlb(
  inputDir: string,
  outputDir: string,
  extensions: string[] = ['.obj', '.stl', '.3mf', '.dae']  // .fbx excluded: format auto-detection not wired
): ConversionResult[] {
  const results: ConversionResult[] = [];

  const files = readdirSync(inputDir).filter((f) =>
    extensions.includes(extname(f).toLowerCase())
  );

  for (const file of files) {
    const inputPath = join(inputDir, file);
    const outputPath = join(outputDir, basename(file, extname(file)) + '.glb');

    try {
      const scene = new Scene();
      scene.open(inputPath);
      scene.save(outputPath);  // extension '.glb' infers GLB format
      results.push({ input: inputPath, output: outputPath, success: true });
    } catch (err) {
      const message = err instanceof Error ? err.message : String(err);
      results.push({ input: inputPath, output: outputPath, success: false, error: message });
      console.error(`Failed to convert ${file}: ${message}`);
    }
  }

  const succeeded = results.filter((r) => r.success).length;
  console.log(`Batch complete: ${succeeded}/${results.length} files converted.`);
  return results;
}

// Usage
batchConvertToGlb('./input', './output');

Le modèle ci‑dessus lit chaque extension de fichier prise en charge depuis un répertoire d’entrée, convertit en GLB et consigne les échecs sans interrompre la boucle. Le tableau retourné de ConversionResult les objets peut être utilisé pour le reporting ou la logique de réessai.

Conclusion

@aspose/3d couvre l’ensemble des besoins de conversion de formats dans une application Node.js TypeScript avec une API à deux étapes cohérente : scene.open() pour charger, scene.save() pour écrire. La contrainte principale à retenir est que les classes d’importateur et d’exportateur FBX existent mais la détection automatique du format n’est pas encore implémentée, de sorte que les fichiers FBX ne peuvent pas être chargés via scene.open().

Pour plus de détails sur le Scene, Node, et Mesh classes utilisées dans ces exemples, consultez les pages de référence des classes dans cette documentation.