Treballant amb formats de fitxers 3D a Java amb Aspose.3D FOSS

Aspose.3D FOSS per a Java admet cinc formats de fitxer 3D: OBJ, STL, glTF, GLB, i FBX (només importació).

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

import com.aspose.threed.*;

Dependència Maven:

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

Panorama de formats

Abans d’endinsar-nos, aquí teniu una breu visió general dels quatre formats compatibles i els seus casos d’ús típics.

OBJ, STL, glTF i GLB admeten tant importació com exportació. FBX és compatible per a només importació. GLB (binary glTF) es produeix via GltfSaveOptions amb setContentType(FileContentType.BINARY).

OBJ: Objecte Wavefront

OBJ és un dels formats de malla 3D més àmpliament compatibles. Emmagatzema la geometria com a text pla, amb un opcional .mtl fitxer complementari per a materials.

Carregant fitxers OBJ

L’enfocament més senzill és passar la ruta del fitxer directament:

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

Per a més control, utilitzeu ObjLoadOptions:

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

Quan el fitxer OBJ fa referència a un fitxer MTL (mitjançant un mtllib directiva), la biblioteca intentarà carregar les definicions de material des d’aquest automàticament. El fitxer MTL ha d’estar al mateix directori que el fitxer OBJ o al camí especificat a la directiva.

Desant com a OBJ

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

Casos d’ús d’OBJ

• Intercanvi de dades de malla entre diferents eines 3D.
• Importació de models des de biblioteques d’actius que es distribueixen en format OBJ.
• Inspecció ràpida de la geometria sense jerarquies de escena complexes.

STL: Estereolitografia

STL és el format estàndard per a la impressió 3D. Representa geometria triangulada en brut sense materials, colors ni jerarquia de escena. Els fitxers STL vénen en dues variants: ASCII (legible per humans) i binari (compacte).

Carregant fitxers STL

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

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

Desar com STL

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

Per controlar la sortida, utilitzeu StlSaveOptions:

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

Consideracions sobre STL

• STL només emmagatzema geometria de triangles. Materials, textures i jerarquia de escena no són compatibles i es descarten en l’exportació.
• L’exportació STL fa no triangul·lar automàticament. El STL binari escriu només els tres primers vèrtexs de cada cara del polígon; les cares de quàdruple i n-gó són truncades silenciosament. L’STL ASCII escriu tots els índexs de vèrtex per cara, produint una sortida mal formada per a cares que no siguin triangles. Utilitzeu sempre malles pre-triangulades (totes les cares en triangle) quan exporteu a STL.
• El STL binari és significativament més petit que el STL ASCII per a models grans.
• STL és el format escollit quan l’objectiu és una impressora 3D o un programari de laminació.

glTF: GL Transmission Format

glTF és un format modern dissenyat per a una transmissió i càrrega eficients de contingut 3D, especialment al web i en aplicacions en temps real. Admet materials PBR, jerarquies de escena i animacions.

Carregant fitxers glTF

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

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

Desar com glTF

L’estalvi bàsic utilitza l’extensió del fitxer per determinar el format:

scene.save("output.gltf");

Per a un control detallat, utilitzeu GltfSaveOptions:

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

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

Detalls de GltfSaveOptions

Casos d’ús de glTF

• Visors 3D basats en web (three.js, Babylon.js).
• Aplicacions en temps real i motors de jocs.
• Conservació de les definicions de material PBR entre eines.

FBX: Filmbox (Només importació)

FBX és un format propietari d’Autodesk que s’utilitza àmpliament en el desenvolupament de jocs i la creació de contingut digital. Aspose.3D FOSS per a Java admet FBX per a només d’importació — l’exportació a FBX no està disponible.

Només FBX binari. L’importador FBX només llegeix fitxers FBX binaris. Passar un fitxer FBX ASCII llança ImportException("ASCII FBX format not yet supported - only binary FBX is supported"). La jerarquia de nodes i l’extracció de materials des de FBX no estan completament verificades; escenes FBX complexes poden no carregar-se completament. Les animacions i el rigging no estan implementats.

Carregant fitxers FBX

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

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

Convertint FBX a altres formats

Com que l’exportació FBX no està suportada, convertiu les escenes FBX importades a 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);

Casos d’ús de FBX

• Importació d’actius de malla estàtica des d’eines Autodesk (Maya, 3ds Max) i conversió a altres formats.
• Carregant geometria FBX binària i reexportant a glTF/GLB, OBJ o STL.

Conversió per lots

Un flux de treball comú consisteix a convertir tot un directori de fitxers d’un format a un altre. Aquí teniu un patró per a la conversió per lots:

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ò carrega cada .obj fitxer en un directori, converteix cada un a glTF amb sortida formatada i desa els resultats. Pots adaptar aquest patró per a qualsevol combinació de format d’origen i destí.

Referència de Conversió entre Formats

La taula següent mostra què esperar en convertir entre formats.

Directrius Generals de Conversió

• Geometria generalment es conserva entre parelles de formats, amb una excepció important: en exportar a STL, les malles han de constar exclusivament de cares triangulars. El STL binari truncar silenciosament les cares quadrangulars i n-gon a les seves primeres 3 vèrtexs; el STL ASCII genera una sortida malformada per a cares que no siguin triangles.
• Materials sobreviuen millor entre escenes importades de glTF i FBX que inclouen dades de material. Convertir a STL sempre elimina els materials. Convertir a OBJ simplifica els materials al model bàsic MTL.
• Jerarquia d’escena es conserva entre fitxers de format glTF. OBJ i STL produeixen estructures planes. La jerarquia FBX i l’extracció de materials no estan completament verificades en aquesta versió.

Posant-ho Tot Junt

Aquí teniu un exemple complet que carrega un fitxer OBJ, inspecciona els seus nodes i exporta tant a glTF com a 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 us ofereix una API consistent a través de múltiples formats. Els punts clau:

• OBJ – intercanvi simple de malles amb materials bàsics.
• STL – format només de geometria per a canals de impressió 3D.
• glTF / GLB – format modern compatible amb PBR per a ús web i en temps real. Utilitzeu GltfSaveOptions amb setContentType(FileContentType.BINARY) per a sortida GLB.
• FBX – només d’importació; format ric per a carregar actius des de motors de joc i eines DCC.

Utilitzeu classes d’opcions de càrrega i desament específiques del format (ObjLoadOptions, StlLoadOptions, StlSaveOptions, GltfLoadOptions, GltfSaveOptions, FbxLoadOptions) quan necessiteu un control detallat sobre el procés d’importació o exportació.

Per a més detalls, visiteu el Aspose.3D documentació o navegueu el codi font a GitHub.