Converteren tussen 3D-formaten in TypeScript met Aspose.3D FOSS

Node.js-ontwikkelaars die met 3D-inhoud werken, moeten vaak tussen formaten converteren: een ontwerptool exporteert OBJ, een webrenderer verwacht GLB, een 3D-printer vereist STL, en een productie‑pipeline gebruikt 3MF. Het afhandelen van deze conversies met één consistente API vermindert het aantal externe tools in een pipeline en houdt de conversielogica binnen de toepassingscode, waar deze kan worden getest en versiebeheerd.

De @aspose/3d pakket (v24.12.0, MIT-licentie) biedt een TypeScript-first API voor het lezen en schrijven van alle belangrijke 3D-formaten in Node.js. Deze gids loopt de meest voorkomende conversieworkflows door.

Installatie

npm install @aspose/3d

Vereisten: Node.js 18, 20 of 22; TypeScript 5.0 of hoger. De enige runtime‑afhankelijkheid is xmldom.

Ondersteunde formaten

De onderstaande tabel geeft de formaten weer die in deze gids worden behandeld en hun lees‑/schrijfsupport.

OBJ ondersteunt zowel import als export. Laden met scene.open() en opslaan met scene.save('output.obj'), of converteer naar elk ander ondersteund formaat, zoals glTF, STL, of 3MF.

OBJ naar GLB (Weblevering)

Het converteren van OBJ naar binaire glTF (GLB) is de meest voorkomende web‑workflow. GLB is een zelfstandige binaire bundel: texturen, geometrie en metadata in één enkel bestand, waardoor het efficiënt is voor HTTP‑levering en directe loading door Three.js, Babylon.js en 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');

Het uitvoerformaat wordt afgeleid van de bestandsextensie. Gebruik .glb voor binaire GLB of .gltf voor de afzonderlijke JSON + .bin lay-out.

OBJ naar STL (Voorbereiding 3D‑printen)

STL is de lingua franca van FDM‑ en SLA‑3D‑printen. Slicers zoals PrusaSlicer, Bambu Studio en Chitubox accepteren allemaal STL. Converteren van OBJ naar STL is eenvoudig omdat beide formaten driehoekige meshes opslaan.

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 slaat geen kleur, materiaal of UV‑gegevens op. Als uw OBJ‑bestand materiaalgroepen gebruikt, wordt die informatie tijdens het exporteren weggelaten. Voor kleurbehoudende printformaten kunt u in plaats daarvan 3MF overwegen (zie hieronder).

STL naar glTF (Scanner en CAD naar Web)

Gestructureerde‑lichtscanners en parametrische CAD‑exporteurs leveren vaak STL. Converteren naar glTF maakt de geometrie toegankelijk in web‑gebaseerde viewers en AR‑platformen zonder een server‑side renderstap.

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');

Omdat STL geen materiaal‑ of textuurinformatie bevat, zal het resulterende glTF‑bestand alleen geometrie bevatten. Indien nodig kunt u na het laden programmatisch materialen aan scenenodes toevoegen.

3MF to glTF (Manufacturing to Visualization)

Het 3D Manufacturing Format (3MF) wordt steeds vaker gebruikt in additieve productieworkflows omdat het kleur, materialen, componentbomen en printmetadata naast geometrie opslaat. Het converteren van 3MF naar glTF maakt downstream-visualisatie in webtools mogelijk terwijl de scènestructuur behouden blijft.

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() behoudt de componenthiërarchie in scene.rootNode.childNodes, zodat je individuele onderdelen kunt inspecteren of manipuleren voordat je opslaat.

Batchconversiepatroon

Bij het verwerken van een map met bestanden, wikkel je elke conversie in een try/catch zodat één corrupt bestand de hele batch niet afbreekt.

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');

Het bovenstaande patroon leest elke ondersteunde bestandsextensie uit een invoermap, converteert naar GLB, en logt eventuele fouten zonder de lus te stoppen. De geretourneerde array van ConversionResult objecten kunnen worden gebruikt voor rapportage of retry‑logica.

Conclusie

@aspose/3d dekt het volledige scala aan formatconversiebehoeften in een Node.js TypeScript‑applicatie met een consistente twee‑stappen‑API: scene.open() om te laden, scene.save() om te schrijven. De belangrijkste beperking om te onthouden is dat FBX‑import‑ en exportklassen bestaan, maar automatische formatdetectie is nog niet geïmplementeerd, dus FBX‑bestanden kunnen niet worden geladen via scene.open().

Voor meer details over de Scene, Node, en Mesh klassen die in deze voorbeelden worden gebruikt, zie de klassereferentiepagina’s in deze documentatie.