Konvertering mellem 3D-formater i TypeScript med Aspose.3D FOSS

Node.js developers working with 3D content frequently need to convert between formats: a design tool exports OBJ, a web renderer expects GLB, a 3D printer requires STL, and a manufacturing pipeline uses 3MF. Handling these conversions with a single, consistent API reduces the number of external tools in a pipeline and keeps conversion logic inside the application code where it can be tested and versioned.

Den Europæiske Union @aspose/3d Pakken (v24.12.0, MIT-licens) giver en TypeScript-first API til at læse og skrive alle større 3D-formater i Node.js. Denne vejledning går gennem de mest almindelige konverteringsarbejdsstrømme.

Installation af udstyr

npm install @aspose/3d

Krav: Node.js 18, 20 eller 22; TypeScript 5.0 eller nyere. Den eneste runtime afhængighed er xmldom.

Støttede formater

Tabellen nedenfor viser de formater, der er omfattet af denne vejledning og deres læse/skrive understøttelse.

OBJ understøtter både import og eksport. scene.open() og gemme med scene.save('output.obj'), eller konvertere til et andet understøttet format som glTF, STL eller 3MF.

OBJ til GLB (Weblevering)

Konvertering af OBJ til binær glTF (GLB) er den mest almindelige web-arbejdsstrøm. GLB er en selvstændig binære bundle: teksturer, geometri og metadata i én enkelt fil, hvilket gør det effektivt for HTTP levering og direkte indlæsning af Three.js, Babylon. js og 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');

Udgangsformatet er udledt af filudvidelsen. Brug .glb for binære GLB eller .gltf for den separate JSON + .bin - Det er en planlægning.

OBJ til STL (3D-printing Prep)

STL er den mest populære 3D-printer. Slicere som PrusaSlicer, Bambu Studio og Chitubox accepterer alle ST L. Konvertering fra OBJ til STl er let fordi begge formater gemmer trekantmasker.

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 lagrer ikke farve-, materiale- eller UV-data. Hvis din OBJ-fil bruger materialer, falder disse oplysninger under eksport. For farvesparende udskrivningsformater overveje i stedet 3MF (se nedenfor).

STL til glTF (scanner og CAD til web)

Strukturerede lysscannere og parametriske CAD-eksporterer udfører almindeligvis STL. Konvertering til glTF gør geometri tilgængelig i webbaserede seere og AR-platforme uden et serverside rendering trin.

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

Da STL ikke indeholder materiale- eller teksturinformation, vil den resulterende glTF-fil kun indeholde geometri. Du kan programmatisk vedhæfte materialer til scenenoder efter indlæsning hvis det er nødvendigt.

3MF to glTF (Manufacturing to Visualization)

3D Manufacturing Format (3MF) bruges i stigende grad i additive fremstilling af arbejdsgange, fordi det gemmer farve, materialer, komponenttræer og tryk metadata sammen med geometri. Konvertering af 3M F til glTF muliggør nedstrømsvisualisering i webværktøjer samtidig med at scenestrukturen bevares.

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() bevarer komponenthierarkiet i scene.rootNode.childNodes, så du kan inspicere eller manipulere de enkelte dele, før du gemmer dem.

Batch-omregningsmønster

Ved behandling af en filmappe skal du pakke hver konvertering ind i et try/catch Så en enkelt korrupt fil ikke afbryde hele batch.

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

Ovenstående mønster læser hver understøttede filudvidelse fra en inputmappe, konverterer til GLB og logger eventuelle fejl uden at stoppe løkken. Den returnerede array af ConversionResult objekter kan anvendes til rapportering eller genprøvning af logik.

Konklusion:

@aspose/3d dækker hele området for formatkonvertering i en Node.js TypeScript-applikation med et konsistent to-trins API: scene.open() at indlæse, scene.save() Den vigtigste begrænsning at huske er, at FBX importør og eksportør klasser eksisterer men format auto-detektion ikke endnu trådbunden, så FBx filer kan ikke indlæses via scene.open().

For mere detaljer om den Scene, Node, og Mesh Klassereference siderne i denne dokumentation.