A 3D formátumok közötti átváltás a TypeScriptben Aspose.3D FOSS-szal

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.

A @aspose/3d a csomag (v24.12.0, MIT licenc) egy TypeScript-first API-t biztosít minden fő 3D formátum olvasására és írása számára a Node.js-ben. Ez az útmutató a leggyakoribb konverziós munkafolyamatokon megy keresztül.

Beépítés

Követelmények: Node.js 18, 20 vagy 22; TypeScript 5.0 vagy újabb. xmldom.

Támogatott formátumok

Az alábbi táblázat felsorolja az ebben a kézikönyvben szereplő formátumokat és azok olvasási/írási támogatását.

Az OBJ támogatja mind az importot, mind a kivitelt. scene.open() és menteni a scene.save('output.obj'), vagy bármely más támogatott formátumra, például glTF-re, STL-be vagy 3MF-ba alakítsák.

OBJ-tól GLB (Webszolgáltatás)

Az OBJ-t bináris glTF (GLB) formába átalakítás a leggyakoribb webes munkafolyamat. A GLB egy önálló binári csomag: textúrák, geometria és metaadatok egyetlen fájlban, ami hatékonyabbá teszi az HTTP szállítást és közvetlen betöltést Three.js, Babylon. js és modell néző által.

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

A kimeneti formátumot a fájl kiterjesztésből következtetjük. Use .glb a bináris GLB esetében, vagy .gltf a külön JSON + esetében .bin - A felépítés.

OBJ-STL (3D nyomtatás előkészítése)

Az STL a FDM és SLA 3D nyomtatás lingua franca. A PrusaSlicer, Bambu Studio és Chitubox típusú vágóeszközök mindegyike elfogadja az STl-t. Az OBJ-ből ST L-re való átalakítás egyszerű, mert mindkét formátum háromszögös hálókat tárol.

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

A STL nem tárolja a színeket, az anyagokat vagy az UV-s adatokat. Ha az OBJ fájlban anyagok csoportja van, akkor ez az információ kivonás közben eltűnik. A színmegőrző nyomtatási formátumok esetében inkább 3MF-t válasszuk (lásd alább).

STL-tól glTF (Scanner és CAD-től Web)

A strukturált fényes szkennerek és a paraméter-CAD exportőrök általában STL kimutatást adnak. Az glTF-re való konverzió lehetővé teszi, hogy a geometria hozzáférhető legyen web alapú nézőkben és AR platformokon szerveroldalú renderelés nélkül.

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

Mivel az STL nem tartalmaz anyag- vagy textúrainformációt, a kapott glTF fájl csak geometria formát tartalmaz. A szükséges feltöltés után programszerűen csatolhatsz anyagot a jelenet csomópontjához.

3MF to glTF (Manufacturing to Visualization)

A 3D gyártási formátumot (3MF) egyre inkább használják az additív gyártás munkafolyamatokban, mert a geometria mellett tárolja a színeket, anyagokat, alkatrészek fákat és nyomtató metadata-t. A 3-as MF átváltása glTF-re lehetővé teszi a webes eszközökben történő lefelé irányuló vizualizációt, miközben megőrzi a jelenet szerkezetét.

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() megőrzi a komponens hierarchiáját az alábbiakban: scene.rootNode.childNodes, így az egyes alkatrészeket meg lehet vizsgálni vagy manipulálni, mielőtt elment.

Sorozatkonverziós minták

A fájlok könyvtárának feldolgozásakor minden egyes átalakítást egy-egy try/catch hogy egyetlen korrupt fájl ne törölje az egész tételt.

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

A fenti minták minden támogatott fájlkiterjesztést olvasnak egy bemeneti könyvtárból, konvertálnak GLB-be és rögzítik a hibákat anélkül, hogy megállítanák az övezést. ConversionResult Az objektumok jelentést vagy újbóli logikát használhatnak.

A Bizottság következtetései

@aspose/3d a Node.js TypeScript alkalmazásban az összes formátumkonverziós igényeket lefedi egy következetes, kétlépcsős API-vel: scene.open() a rakodásra, scene.save() Az a legfontosabb, hogy emlékezzünk arra, az FBX importőr és exportőr osztályok léteznek, de formátum automatikus felderítése még nem vezetékes, így FBx fájlok nem lehet tölteni keresztül scene.open().

A részletesebbekért a következőkben: Scene, Node,és a következők: Mesh A fenti példákban használt osztályok, lásd a dokumentációhoz tartozó osztály-referencia oldalakat.