Lavorare con i formati di file 3D in Java utilizzando Aspose.3D FOSS

Aspose.3D FOSS per Java supporta cinque formati di file 3D: OBJ, STL, Il GTTF, GLB,e FBX Questo post è un manuale pratico, formato-per-format che mostra come caricare e salvare ciascuno, quali opzioni sono disponibili e come convertire tra di loro.

Tutti gli esempi utilizzano il com.aspose.threed.* Il pacchetto:

import com.aspose.threed.*;

La dipendenza di Maven:

<dependency>
  <groupId>org.aspose</groupId>
  <artifactId>aspose-3d-foss</artifactId>
  <version>26.5.0</version>
</dependency>

Il Paesaggio di formato

Prima di nuotare, ecco un rapido panoramico dei quattro formati supportati e i loro tipici casi di utilizzo.

OBJ, STL, glTF e GLB supportano entrambi l’importazione ed esportazioni. importare solo.GLB (GlTF binario) è prodotto attraverso il GltfSaveOptions con setContentType(FileContentType.BINARY).

OBJ: oggetto di fronte a onde

OBJ è uno dei formati di mesh 3D più ampiamente supportati. memorizza la geometria come testo piatto, con un formato opzionale .mtl file di compagnia per i materiali.

Caricamento dei file OBJ

Il metodo più semplice è quello di passare direttamente il percorso del file:

Scene scene = Scene.fromFile("model.obj");

Per un maggiore controllo, utilizzo ObjLoadOptions:

ObjLoadOptions opts = new ObjLoadOptions();
Scene scene = Scene.fromFile("model.obj", opts);

Quando il file OBJ si riferisce a un file MTL (a mtllib La biblioteca cercherà di caricare automaticamente le definizioni del materiale.Il file MTL dovrebbe essere nello stesso directory che il file OBJ o sul percorso specificato nella direttiva.

Il risparmio come OBJ

Scene scene = Scene.fromFile("input.fbx");
scene.save("output.obj");

Il caso utilizza i casi

• Scambiare i dati mesh tra diversi strumenti 3D.
• Importare modelli da biblioteche di attività che distribuiscono in formato OBJ.
• La geometria è una ricerca rapida senza ieriche complesse.

STL: Stereolithografia

STL è il formato standard per la stampa 3D. rappresenta geometria triangolare cruda senza materiali, colori o gerarchie scene. i file STl vengono in due varianti: ASCII (umano-legibile) e binario (compatto).

Caricamento di file STL

// Simple load
Scene scene = Scene.fromFile("part.stl");

// With explicit options
StlLoadOptions opts = new StlLoadOptions();
Scene scene = Scene.fromFile("part.stl", opts);

Risparmio come STL

Scene scene = Scene.fromFile("model.obj");
scene.save("output.stl");

Per controllare la produzione, utilizzare StlSaveOptions:

StlSaveOptions opts = new StlSaveOptions();
scene.save("output.stl", opts);

Le considerazioni STL

• STL immagazzinano solo geometria triangolare. materiali, tessuti e gerarchie scene non sono supportati e vengono gettate su esportazione.
• L’esportazione di STL Non è Triangolare automaticamente. STL binario scrive solo le prime 3 verticali di ciascun poligono faccia; quad e n-gon facce sono silenziosamente truncate. ASCII ST L scriva tutti gli indizi vertici per faccio, produrre una produzione malformata per non triangoli facci. Sempre utilizzare messi pre-triangolati (tutte le faccende triungle) quando esportato a STl.
• Il binario STL è significativamente più piccolo di ASCII STl per i modelli grandi.
• STL è il formato di scelta quando l’obiettivo è un software stampante 3D o slicer.

GLTF: formato di trasmissione GL

GlTF è un formato moderno progettato per la trasmissione efficiente e il caricamento di contenuti 3D, in particolare su web e nelle applicazioni in tempo reale. supporta materiali PBR, gerarchie scene e animazioni.

Caricamento di file glTF

Scene scene = Scene.fromFile("scene.gltf");

// With options
GltfLoadOptions opts = new GltfLoadOptions();
Scene scene = Scene.fromFile("scene.gltf", opts);

Risparmio come gltf

Il salvataggio di base utilizza l’estensione del file per determinare il formato:

scene.save("output.gltf");

Per un controllo dettagliato, l’uso GltfSaveOptions:

GltfSaveOptions opts = new GltfSaveOptions();
opts.setFlipCoordinateSystem(true);
opts.setPrettyPrint(true);

scene.save("output.gltf", opts);

GSTFSaveOptions Dettagli

GST utilizza i casi

• Visualizzatori 3D basati sul web (three.js, Babylon.js).
• Applicazioni in tempo reale e motori di gioco.
• Conservare le definizioni del materiale PBR attraverso strumenti.

FBX: Filmbox (Solo importato)

FBX è un formato proprietario di Autodesk che viene ampiamente utilizzato nello sviluppo dei giochi e nella creazione di contenuti digitali. Aspose.3D FOSS per Java supporta FBx per il importare solo - l’esportazione a FBX non è disponibile.

Il binario FBX è solo. L’importatore FBX legge solo i file binari FBx. Passando un file ASCII FB X lancia ImportException("ASCII FBX format not yet supported - only binary FBX is supported").La gerarchia dei nodi e l’estrazione del materiale da FBX non sono completamente verificati; le scene di FB X complesse potrebbero non essere completamente caricate.

Caricamento di file FBX

Scene scene = Scene.fromFile("character.fbx");

// With options
FbxLoadOptions opts = new FbxLoadOptions();
Scene scene = Scene.fromFile("character.fbx", opts);

Convertire FBX in altri formati

Poiché l’esportazione di FBX non è supportata, convertire le scene di FbX importate in glTF, GLB, OBJ o STL:

Scene scene = Scene.fromFile("character.fbx");

// Save as GLB
GltfSaveOptions opts = new GltfSaveOptions();
opts.setContentType(FileContentType.BINARY);
scene.save("character.glb", opts);

FBX utilizza il caso

• Importare i mezzi statici da strumenti Autodesk (Maya, 3ds Max) e convertire in altri formati.
• Caricamento di geometria binaria FBX e riesportazione a glTF/GLB, OBJ o STL.

Conversione Batch

Un flusso di lavoro comune è la conversione di un intero directory di file da uno formato all’altro. ecco un modello per la convergenza del pacch:

import com.aspose.threed.*;
import java.io.File;

public class BatchConvert {
    public static void main(String[] args) throws Exception {
        File inputDir = new File("models/obj");
        File outputDir = new File("models/gltf");
        outputDir.mkdirs();

        GltfSaveOptions saveOpts = new GltfSaveOptions();
        saveOpts.setPrettyPrint(true);

        File[] objFiles = inputDir.listFiles(
            (dir, name) -> name.toLowerCase().endsWith(".obj")
        );

        if (objFiles == null) return;

        for (File objFile : objFiles) {
            String baseName = objFile.getName()
                .replaceFirst("\\.obj$", "");

            Scene scene = Scene.fromFile(objFile.getAbsolutePath());
            String outPath = new File(outputDir, baseName + ".gltf")
                .getAbsolutePath();

            scene.save(outPath, saveOpts);
            System.out.println("Converted: " + objFile.getName()
                + " -> " + baseName + ".gltf");
        }
    }
}

Questo carica ogni .obj file in un directory, converte ciascuno a glTF con una produzione stampata e salva i risultati. Puoi adattare questo modello per qualsiasi combinazione di formato fonte e target.

Conversione di riferimento cross-format

La tabella seguente mostra cosa aspettarsi quando si converte tra i formati.

Le linee guida generali di conversione

• Geometria è generalmente conservato tra le coppie di formato, con una eccezione importante: quando esportati a STL, le messe devono consistere interamente di facce triangoli. STl binario silenziosamente truncates quad e n-gon facciate alle loro prime 3 verticali; ASCII ST L produce il risultato malformato per non triangi faccia.
• Materiali sopravvivere meglio tra le scene importate da glTF e FBX che includono i dati materiali. Convertire a STL sempre taglia i materiali, Convertendo a OBJ semplifica i contenuti al modello MTL di base.
• La gerarchia della scena è conservato tra i file di formato glTF. OBJ e STL producono strutture piatte. la gerarchia FBX e l’estrazione del materiale non sono completamente verificati in questa versione.

Puntiamo tutto insieme

Ecco un esempio completo che carica un file OBJ, ispeziona i suoi nodi e esporta sia glTF che GLB:

import com.aspose.threed.*;

public class FormatWorkflow {
    public static void main(String[] args) throws Exception {
        // Load
        Scene scene = Scene.fromFile("input.obj");

        // Inspect
        System.out.println("Nodes in scene:");
        for (Node child : scene.getRootNode().getChildNodes()) {
            System.out.println("  " + child.getName());
            Transform t = child.getTransform();
            System.out.println("    Translation: "
                + t.getTranslation());
        }

        // Export to glTF with options
        GltfSaveOptions gltfOpts = new GltfSaveOptions();
        gltfOpts.setPrettyPrint(true);
        scene.save("output.gltf", gltfOpts);

        // Export to GLB (binary glTF)
        GltfSaveOptions glbOpts = new GltfSaveOptions();
        glbOpts.setContentType(FileContentType.BINARY);
        scene.save("output.glb", glbOpts);

        System.out.println("Export complete.");
    }
}

Il sintesi

Aspose.3D FOSS per Java ti dà un’API costante in diversi formati.:

• OBJ - semplice scambio di mezz con materiali di base.
• STL - formato geometrico solo per i tubi di stampa 3D.
• GTTF / GLB - formato PBR-capabile per uso web e in tempo reale. utilizzo GltfSaveOptions con setContentType(FileContentType.BINARY) per la produzione di GLB.
• FBX - importare solo; formato ricco per il carico di beni da motori di gioco e strumenti DCC.

Utilizzare la carica specifica per formato e salvare le classi opzioni (ObjLoadOptions, StlLoadOptions, StlSaveOptions, GltfLoadOptions, GltfSaveOptions, FbxLoadOptionsQuando è necessario il controllo finito del processo di importazione o esportazione.

Per maggiori dettagli, visita il Documentazione 3D o si spiega la fonte su GitHub.