Aspose.3D FOSS
TypeScript
Come ottimizzare i modelli 3D in TypeScript

Come ottimizzare i modelli 3D in TypeScript

Aspose.3D FOSS per TypeScript offre diverse strategie per ridurre le dimensioni dei file di output e migliorare il throughput di elaborazione. Questa guida copre la selezione del formato, l’incorporamento binario, le pipeline in memoria e le ottimizzazioni a livello di Node.js.

Guida passo-passo

Passo 1: Scegliere il formato di output corretto

GLB (binary glTF) produce l’output più compatto con un buon supporto degli strumenti. OBJ è basato su testo e più grande. STL è compatto per flussi di lavoro solo geometria.

FormatoDimensioneInclude MaterialiInclude AnimazioneUso migliore
GLBPiccoloSì (incorporato)SìWeb, giochi, scambio generale
glTFMedioSì (separato)SìSviluppo, ispezione
STLPiccoloNoNo3D printing, geometry-only
OBJGrandeSeparare .mtlNoStrumenti legacy, ampia compatibilità
FBXMedioNo*No*L’importatore/esportatore esiste ma non è collegato al rilevamento automatico
3MFPiccoloSìNoStampa 3D moderna

Passo 2: Esportare in GLB binario

Quando si salva in GLB, impostare GltfSaveOptions.binaryMode = true per produrre un unico file binario autonomo. Questo evita il .bin file laterale e è richiesto per molti visualizzatori 3D:

import { Scene } from '@aspose/3d';
import { ObjLoadOptions } from '@aspose/3d/formats/obj';
import { GltfSaveOptions } from '@aspose/3d/formats/gltf';

const scene = new Scene();
scene.open('complex-model.obj', new ObjLoadOptions());

const opts = new GltfSaveOptions();
opts.binaryMode = true;

scene.save('optimized.glb', opts);
console.log('Saved compact binary GLB');

Passo 3: Utilizzare I/O buffer per pipeline in memoria

Durante l’elaborazione dei file in un servizio web, utilizzare openFromBuffer e saveToBuffer per evitare di scrivere sul file system:

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

function convertInMemory(inputBuffer: Buffer): Buffer {
    const scene = new Scene();
    scene.openFromBuffer(inputBuffer, new ObjLoadOptions());
    return scene.saveToBuffer('glb');
}

Passo 4: Elaborare i file in batch con thread worker

Per lavori di conversione di grandi dimensioni, distribuire il lavoro tra i thread worker di Node.js per utilizzare più core CPU:

// worker.ts
import { workerData, parentPort } from 'worker_threads';
import { Scene } from '@aspose/3d';
import { ObjLoadOptions } from '@aspose/3d/formats/obj';

const { inputPath, outputPath } = workerData;

const scene = new Scene();
scene.open(inputPath, new ObjLoadOptions());
scene.save(outputPath);

parentPort?.postMessage({ done: true, output: outputPath });
// main.ts: dispatch files to workers
import { Worker } from 'worker_threads';
import * as fs from 'fs';
import * as path from 'path';

const files = fs.readdirSync('./input').filter(f => f.endsWith('.obj'));

for (const file of files) {
    const inputPath = path.join('./input', file);
    const outputPath = path.join('./output', file.replace('.obj', '.glb'));

    const worker = new Worker('./dist/worker.js', {
        workerData: { inputPath, outputPath }
    });

    worker.on('message', msg => console.log(`Converted: ${msg.output}`));
    worker.on('error', err => console.error(`Error: ${err}`));
}

Passo 5: Monitorare la memoria per modelli di grandi dimensioni

Per file superiori a 50 MB, monitorare l’uso dell’heap e processare i file in modo sequenziale se la memoria è limitata:

function logMemory(label: string) {
    const used = process.memoryUsage();
    console.log(`[${label}] heapUsed: ${Math.round(used.heapUsed / 1024 / 1024)} MB`);
}

logMemory('before load');
const scene = new Scene();
scene.open('large-model.obj');
logMemory('after load');
scene.save('output.glb');
logMemory('after save');

Aumentare l’heap di Node.js per modelli molto grandi:

node --max-old-space-size=8192 convert.js

Domande frequenti

Qual è il formato di output più compatto?

GLB (binary glTF) con risorse incorporate produce l’output a file singolo più compatto per scene con materiali e texture. STL è più compatto per contenuti solo geometria.

Il pacchetto @aspose/3d applica la semplificazione della mesh o LOD?

No. La libreria legge e scrive la geometria di origine senza modificare la topologia della mesh. La semplificazione della mesh (riduzione dei vertici, generazione di LOD) non è supportata.

Posso rimuovere i materiali per ridurre la dimensione del file?

Imposta ObjSaveOptions.enableMaterials = false quando si salva in OBJ. Per glTF, tutti i dati dei materiali sono sempre inclusi; usa STL per l’output solo geometria.

Vedi anche

 Italiano