Cargar y guardar fuentes CFF en Java

Procese archivos Compact Font Format (`.cff`) basados en PostScript mediante programación con Aspose.Font for Java. Abra archivos binarios de fuentes CFF desde rutas de archivos locales o matrices de bytes en memoria, inspeccione las estructuras de las fuentes mediante la clase `CffFont` y guarde los datos de fuentes modificados en el disco o en flujos sin dependencias externas.

Compact Font Format (CFF) es una representación compacta de los contornos de fuentes PostScript Type 1, ampliamente utilizada en documentos PDF, fuentes OpenType CFF (.otf) y flujos de trabajo de publicación digital. Con Aspose.Font for Java, los desarrolladores pueden:

Procesamiento de fuentes en memoria: Cargar bytes de fuentes CFF directamente desde BLOB de bases de datos, flujos PDF o almacenamiento en la nube sin escribir archivos temporales en el disco.
Gestión de almacenamiento compacto: Manipular estructuras de fuentes de contornos PostScript de baja ocupación para optimizar la incrustación en documentos.
Operaciones de archivos flexibles: Leer archivos de fuentes CFF mediante FileSystemStreamSource o ByteContentStreamSource y exportarlos mediante CffFont.save().

Flujo de trabajo de procesamiento de fuentes CFF

Cargar CFF desde el disco - utiliza (ruta del archivo (.cff)) y FontDefinition + FileSystemStreamSource

Cargar CFF desde la memoria - utiliza una matriz de bytes binarios (byte[]) y FontDefinition + ByteContentStreamSource

Inspeccionar/editar datos CFF - utiliza el objeto CffFont y CffFont.getFontName(), CffFont.getNumGlyphs(), etc.

Guardar CFF en el disco - utiliza el objeto CffFont y CffFont.getFontName(), CffFont.getNumGlyphs(), etc.

¿Cómo cargar una fuente CFF desde un archivo de fuentes en disco en Java?

Cargue un archivo de fuente .cff definiendo un FontDefinition con FontType.CFF y un FileSystemStreamSource.

import com.aspose.font.*;

public class LoadCffFontFromDisk {
    public static void main(String[] args) {
        // Step 1: Specify path to the .cff font file
        String fileName = "path/to/OpenSans-Regular.cff";

        // Step 2: Initialize FontDefinition with CFF format and FileSystemStreamSource
        FontDefinition fd = new FontDefinition(
            FontType.CFF, 
            new FontFileDefinition("cff", new FileSystemStreamSource(fileName))
        );

        // Step 3: Open the CFF font
        CffFont font = (CffFont) Font.open(fd);

        // Step 4: Verify font properties
        System.out.println("Font Name: " + font.getFontName());
        System.out.println("Glyph Count: " + font.getNumGlyphs());
        System.out.println("CFF Font successfully loaded from disk.");
    }
}

¿Cómo cargar una fuente CFF desde una matriz de bytes (`byte[]`)?

Después de cargar una fuente en la memoria y realizar la extracción o modificación de datos, puede guardar la fuente nuevamente en el almacenamiento local o escribirla en un flujo de bytes de salida.

import com.aspose.font.*;
import java.nio.file.Files;
import java.nio.file.Paths;

public class LoadCffFontFromByteArray {
    public static void main(String[] args) throws Exception {
        String fileName = "path/to/OpenSans-Regular.cff";

        // Step 1: Read font file bytes into memory
        byte[] fontMemoryData = Files.readAllBytes(Paths.get(fileName));

        // Step 2: Create FontDefinition using ByteContentStreamSource
        FontDefinition fd = new FontDefinition(
            FontType.CFF, 
            new FontFileDefinition("cff", new ByteContentStreamSource(fontMemoryData))
        );

        // Step 3: Open font instance from byte array
        CffFont font = (CffFont) Font.open(fd);

        System.out.println("Loaded CFF Font Name from memory: " + font.getFontName());
    }
}

¿Cómo modificar y guardar fuentes CFF en el disco?

Después de cargar e interactuar con una instancia de CffFont, escriba el archivo de fuente en una nueva ubicación mediante el método save().

import com.aspose.font.*;
import java.nio.file.Files;
import java.nio.file.Paths;

public class SaveCffFontToDisk {
    public static void main(String[] args) throws Exception {
        String inputPath = "path/to/OpenSans-Regular.cff";
        String outputPath = "path/to/OpenSans-Regular_out.cff";

        // Step 1: Load font from byte array
        byte[] fontMemoryData = Files.readAllBytes(Paths.get(inputPath));
        FontDefinition fd = new FontDefinition(
            FontType.CFF, 
            new FontFileDefinition("cff", new ByteContentStreamSource(fontMemoryData))
        );
        CffFont font = (CffFont) Font.open(fd);

        System.out.println("Loaded CFF Font: " + font.getFontName());

        // Step 2: Work with font data (inspect metrics, glyphs, or update properties)

        // Step 3: Save CFF font back to disk
        font.save(outputPath);

        System.out.println("CFF Font successfully saved to: " + outputPath);
    }
}

Instalación y configuración

Incluya Aspose.Font for Java en su proyecto mediante Maven.

Package Manager Console Command

<repository>
    <id>AsposeJavaAPI</id>
    <name>Aspose Java API</name>
    <url>https://repository.aspose.com/repo/</url>
</repository>

<dependency>
    <groupId>com.aspose</groupId>
    <artifactId>aspose-font</artifactId>
    <version>Latest</version>
</dependency>

Próximos pasos

Preguntas frecuentes

1. ¿Cuál es la diferencia entre OpenType CFF (.otf) y CFF independiente (.cff)?

Un archivo .cff independiente contiene datos sin procesar del programa de fuentes PostScript sin envoltorios de tablas OpenType. Un archivo .otf con contornos CFF encapsula el flujo .cff dentro de estructuras de tablas OpenType estándar (CFF, cmap, head, etc.). Aspose.Font for Java admite tanto los formatos CFF independientes como OpenType CFF.

2. ¿Puedo convertir fuentes CFF a otros formatos de fuente, como TTF o WOFF, en Java?

Sí. Una vez cargada en una instancia de CffFont, Aspose.Font for Java proporciona funciones de renderizado y codificación que permiten convertir los datos de la fuente a otros formatos de destino, como TTF, WOFF o WOFF2.

3. ¿Puedo guardar un CffFont modificado directamente en un OutputStream?

Sí. Además de pasar una cadena con la ruta del archivo a font.save(fileName), puede pasar un java.io.OutputStream para escribir datos binarios de la fuente directamente en flujos de red o de memoria.