Trabajar con los formatos de archivo 3D en Java utilizando Aspose.3D FOSS

Aspose.3D FOSS para Java soporta cinco formatos de archivo 3D: OBJ, STL, GTTF, GLB,y, FBX Este post es un guía práctico, de formato a formato que muestra cómo cargar y guardar cada uno, qué opciones están disponibles y cómo convertir entre ellos.

Todos los ejemplos utilizan el com.aspose.threed.* El paquete:

import com.aspose.threed.*;

Dependencia de Maven:

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

Formato del paisaje

Antes de subirse, aquí está un rápido resumen de los cuatro formatos apoyados y sus casos típicos de uso.

OBJ, STL, glTF y GLB soportan tanto las importaciones como las exportaciones. FBX se apoya para Sólo importación.GLB (GlTF binario) se produce a través de la GltfSaveOptions con setContentType(FileContentType.BINARY).

Objeto de Wavefront

OBJ es uno de los formatos de mesh 3D más ampliamente apoyados. almacenará geometría como texto plano, con un formato opcional .mtl Archivo de compañero para materiales.

Cargar archivos OBJ

La forma más sencilla es pasar el camino de archivo directamente:

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

Para más control, uso ObjLoadOptions:

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

Cuando el archivo OBJ se refiere a un archivio MTL (a través de una mtllib La biblioteca intentará cargar de ella automáticamente las definiciones del material.El archivo MTL debe estar en el mismo directorio que el archivado OBJ o en la ruta especificada en esta directiva.

El ahorro como OBJ

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

OBJ utiliza los casos

• Intercambio de datos de mesh entre diferentes herramientas 3D.
• Importación de modelos de bibliotecas de activos que distribuyen en formato OBJ.
• Inspección rápida de la geometría sin hierarquías complejas de escenario.

Título: Stereolithography

STL es el formato estándar para la impresión 3D. Representa geometría triangular cruda sin materiales, colores o hierarquía de escena. Los archivos STl se presentan en dos variantes: ASCII (human-readable) y binario (compact).

Cargar archivos STL

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

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

Ahorro como STL

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

Para controlar la producción, utilizar StlSaveOptions:

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

Las consideraciones STL

• STL almacenan sólo geometría triángulo. materiales, texturas y hierarquía de escenarios no se apoyan y se caen en la exportación.
• El STL exporta No Triangular automáticamente. STL binario escribe sólo las primeras 3 verticales de cada cara poligonal; los rostros cuad y n-gon son silenciosamente truncados. ASCII ST L escriben todos los índices vertex por cara, producen una salida malformada para los ojos no triángulos. Siempre use mesas pretrianguladas (fotos triangulares) cuando se exporta a STl.
• STL binario es significativamente menor que ASCII STl para los modelos grandes.
• STL es el formato de elección cuando el objetivo es un impresor 3D o software de escape.

GLTF: El formato de transmisión GL

GlTF es un formato moderno diseñado para la transmisión y carga eficiente de contenido 3D, especialmente en la web y en aplicaciones en tiempo real.

Cargar archivos glTF

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

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

Comprar como gltf

El almacenamiento básico utiliza la extensión de archivo para determinar el formato:

scene.save("output.gltf");

Para el control detallado, uso GltfSaveOptions:

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

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

GltfSaveOptions Detalles

GSTF Casos de uso

• 3D de la web (three.js, Babylon.js).
• Aplicaciones en tiempo real y motores de juego.
• Conservar las definiciones de material PBR a través de herramientas.

FBX: Filmbox (Solo importado)

FBX es un formato propiedad de Autodesk que se utiliza ampliamente en el desarrollo de juegos y la creación de contenido digital. Aspose.3D FOSS para Java soporta FBx para Sólo importación - No está disponible la exportación a FBX.

Binar solo FBX. El importador FBX sólo lee los archivos binarios de FB X. Pasando un archivo ASCII FBx se lanza ImportException("ASCII FBX format not yet supported - only binary FBX is supported").La hierarquía de nodos y la extracción de materiales de FBX no se verifican completamente; las escenas complejas de FBX pueden no cargarse por completo.

Cargar archivos FBX

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

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

Convertir FBX en otros formatos

Como la exportación de FBX no se apoya, convertir las escenas de FBX importadas 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 utiliza los casos

• Importación de activos de mesh estáticos de las herramientas Autodesk (Maya, 3ds Max) y conversión a otros formatos.
• Cargar geometría binaria FBX y reexportar a glTF/GLB, OBJ o STL.

Conversión Batch

Un flujo de trabajo común es convertir un directorio entero de archivos de un formato a otro. Aquí hay un patrón para la conversión de batch:

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

Esto carga a todos los .obj archivo en un directorio, converte cada uno a glTF con una salida bien impreso, y salva los resultados. Puede adaptar este patrón para cualquier combinación de formato fuente y objetivo.

Conversión de referencia cross-format

La tabla siguiente muestra lo que esperar al convertir entre formatos.

Guía de Conversión General

• Geometría Se conserva generalmente entre pares de formato, con una excepción importante: cuando se exporta a STL, las mesas deben consistir en su totalidad de caras triángulos. ST L binario silenciosamente truncata los cuadros y n-gon cares a sus tres primeras verticales; ASCII STl produce salida malformada para caros no triangulares.
• Materiales sobrevivir mejor entre glTF y FBX-importaciones que incluyen datos de material. Convertir a STL siempre cae materiales.Convertiendo a OBJ simplifica los materiales al modelo MTL básico.
• La hierarquía de escenarios se conserva entre los archivos de formato glTF. OBJ y STL producen estructuras plana. la hierarquía FBX y la extracción del material no están completamente verificadas en esta versión.

Poner todo lo juntas

Aquí hay un ejemplo completo que carga un archivo OBJ, inspecta sus nódulos y exporta tanto a glTF como 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.");
    }
}

Resumen

Aspose.3D FOSS para Java le da una API consistente a través de varios formatos.:

• OBJ - Intercambio de mezcla simple con materiales básicos.
• STL - Geometría-sólo formato para los tubos de impresión 3D.
• GN / GLB - formato PBR-capable para uso en web y en tiempo real. GltfSaveOptions con setContentType(FileContentType.BINARY) de la producción GLB.
• FBX - solo importa; rico formato para cargar activos de motores de juego y herramientas DCC.

En el caso de las clases de carga y la opción (ObjLoadOptions, StlLoadOptions, StlSaveOptions, GltfLoadOptions, GltfSaveOptions, FbxLoadOptionsCuando necesitas un control fin-grin sobre el proceso de importación o exportación.

Para más detalles, visite el Aspose.3D de la documentación o navegar por la fuente en GitHub.