Treballant amb els formats de fitxers 3D en Java utilitzant Aspose.3D FOSS

Aspose.3D FOSS per a Java suposa cinc formats de fitxers 3D: OBJ, STL, GSTF, GLB,i FBX Aquest post és un guia pràctic, format per format que mostra com carregar i salvar cadascun, quines opcions estan disponibles i com convertir entre ells.

Tots els exemples utilitzen el com.aspose.threed.* El paquet:

import com.aspose.threed.*;

La dependència de Maven:

<dependency>
    <groupId>com.aspose</groupId>
    <artifactId>aspose-3d-foss</artifactId>
    <version>26.1.0</version>
</dependency>

Format de paisatge

Abans de submergir-se, aquí és una ràpida revisió dels quatre formats que s’hi donen suport i els seus casos d’ús típic.

OBJ, STL, glTF i GLB suporten tant les importacions com les exportacions. Només importar.GLB (GlTF binari) es produeix a través de la GltfSaveOptions amb setContentType(FileContentType.BINARY).

Objecte de la vora Wavefront

OBJ és un dels formats de mesh 3D més àmpliament recolzats. emmagatzema la geometria com a text pla, amb una opció opcional .mtl Arxiu de companyia per a materials.

Carregar els arxius OBJ

L’enfocament més senzill és passar el camí de fitxer directament:

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

Per a més control, utilitzar ObjLoadOptions:

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

Quan el fitxer OBJ es refereix a un fitxer MTL (a través d’un mtllib La biblioteca intentarà carregar definiments de material automàticament.El fitxer MTL hauria d’estar en el mateix directory que el fitxer OBJ o al camí especificat a la directiva.

El que s’estalvia com a OBJ

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

OBJ utilitza els casos

• Intercanvi de dades mesh entre diferents eines 3D.
• Importació de models de les biblioteques d’actius que distribueixen en format OBJ.
• Inspecció ràpida de la geometria sense hierarquies complexes.

Títol: Stereolithografia

STL és el format estàndard per a la impressió 3D. representa geometria triangulada cru sense materials, colors o jerarquia de escena. els arxius STl es troben en dues variants: ASCII (human-readable) i binari (compact).

Carregar els arxius STL

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

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

Estalvi com a STL

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

Per controlar la producció, utilitzar StlSaveOptions:

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

Consideracions STL

• STL només emmagatzema geometria triangular. materials, textures i jerarquia de l’escena no es recolzen i es llancen a l’exportació.
• L’exportació de l’est No és Triangular automàticament. STL binari només escriu les primeres 3 vertices de cada cara poligon; els rostres quad i n-gon són silenciosament truncats. ASCII STl escric tots els indicis vertics per cara, produint una sortida malformada per a rostre no triangulari. Sempre utilitzeu mesxes pretriangulat (faços tot triángulars) quan s’exporta a ST L.
• STL binari és significativament menor que ASCII STl per a models grans.
• STL és el format de l’elecció quan l’objectiu és un programari d’impressió 3D o de tallador.

GLTF: format de transmissió GL

GlTF és un format modern dissenyat per a la transmissió i carregament eficients de continguts 3D, especialment en la web i en aplicacions en temps real.

Carregar els arxius glTF

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

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

Estalvi com a glTF

El savi bàsic utilitza l’extenssió de fitxer per determinar el format:

scene.save("output.gltf");

Per a control detallat, utilitzar GltfSaveOptions:

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

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

GltfSaveOptions Detalls

GST utilitza els casos

• Visitadors 3D basats en la web (three.js, Babylon.js).
• Aplicacions i motors de joc en temps real.
• Conservació de les definicions del material PBR a través d’eines.

FBX: Filmbox (Solament importat)

FBX és un format propietat per Autodesk que s’utilitza àmpliament en el desenvolupament de jocs i la creació de continguts digitals. Aspose.3D FOSS per a Java suposa FBx per Només importar - Exportació a FBX no està disponible.

Només el binari FBX. El importador FBX només llegeix els fitxers binaris FB X. Passant un fitxer ASCII FB x ImportException("ASCII FBX format not yet supported - only binary FBX is supported"). la jerarquia de nues i l’extracció del material de FBX no es verifica completament; les escenes complexes de FBX poden no carregar-se completment.

Carregar els arxius FBX

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

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

Convertir FBX a altres formats

Com que l’exportació de FBX no es dóna suport, converteix les escenes d’FBX importades en 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 utilitza els casos

• Importació d’actius de mesh estàtics a partir d’eines Autodesk (Maya, 3ds Max) i conversió en altres formats.
• Carregar la geometria binària FBX i reexportar a glTF/GLB, OBJ o STL.

Conversió Batx

Un flux de treball comú és convertir un directori complet de fitxers d’un format a l’altre.Aquí hi ha un patró per la conversió de batxons:

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");
        }
    }
}

Això fa càrrec a tots els .obj fitxers en un directory, converteix cadascun a glTF amb una sortida ben imprès, i salva els resultats. pot adaptar aquest patró per a qualsevol combinació de format font i objectiu.

Conversions de format transversal

La taula següent mostra el que esperar quan es converteix entre els formats.

Guia general de conversió

• Geometria S’ha conservat generalment entre els parells de format, amb una excepció important: quan s’exporta a STL, les meses han de consistir en tot el triangle. STl binari silenciosament troncava quad i n-gon cara a les seves primeres 3 vertices; ASCII ST L produeix la sortida malformada per a cares no triángles.
• Materials sobreviure millor entre glTF i FBX-importa escenes que inclouen dades de material. Convertir a STL sempre cau materials. convertir a OBJ simplifica els materials al model bàsic MTL.
• La jerarquia de l’escenari es conserva entre els fitxers de format glTF. OBJ i STL produeixen estructures planes. la jerarquia FBX i l’extracció del material no estan completament verificats en aquesta versió.

Posa’t tot junts

Aquí teniu un exemple complet que carrega un arxiu OBJ, inspecciona els seus nodes i exporta a tant glTF com 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.");
    }
}

Resum

Aspose.3D FOSS per a Java li dóna una API consistent en diversos formats.:

• OBJ - Intercanvi de mes simples amb materials bàsics.
• STL - Geometria-només format per a tubs d’impressió 3D.
• GST / GLB - format PBR-capable per a la web i ús en temps real. GltfSaveOptions amb setContentType(FileContentType.BINARY) de la producció GLB.
• FBX - només import; format ric per a la càrrega d’actius de motors de joc i eines DCC.

Utilitzar càrrega específica de format i salvar classes d’opció (ObjLoadOptions, StlLoadOptions, StlSaveOptions, GltfLoadOptions, GltfSaveOptions, FbxLoadOptionsQuan necessiteu un control de granja fina sobre el procés d’importació o exportacions.

Per a més detalls, visita el Aspose.3D documentació o navegar a la font de GitHub.