Caricare e salvare font CFF in Java

Elaborare programmaticamente file Compact Font Format (`.cff`) basati su PostScript con Aspose.Font per Java. Aprire file binari di font CFF da percorsi di file locali o array di byte in memoria, esaminare le strutture dei font utilizzando la classe `CffFont` e salvare i dati dei font modificati nuovamente su disco o stream senza dipendenze esterne.

Compact Font Format (CFF) è una rappresentazione compatta dei contorni dei font PostScript Type 1, ampiamente utilizzata nei documenti PDF, nei font OpenType CFF (.otf) e nei flussi di lavoro dell’editoria digitale. Con Aspose.Font per Java, gli sviluppatori possono:

Elaborazione dei font in memoria: Caricare i byte dei font CFF direttamente da BLOB di database, stream PDF o archiviazione cloud senza scrivere file temporanei su disco.
Gestione dello spazio di archiviazione compatto: Manipolare strutture di font con contorni PostScript a basso ingombro per un’incorporazione ottimizzata nei documenti.
Operazioni sui file flessibili: Leggere i file dei font CFF utilizzando FileSystemStreamSource o ByteContentStreamSource ed esportarli tramite CffFont.save().

Flusso di lavoro per l'elaborazione dei font CFF

Caricare CFF dal disco - utilizza (percorso del file (.cff)) e FontDefinition + FileSystemStreamSource

Caricare CFF dalla memoria - utilizza array di byte binari (byte[]) e FontDefinition + ByteContentStreamSource

Esaminare/modificare i dati CFF - utilizza l’oggetto CffFont e CffFont.getFontName(), CffFont.getNumGlyphs(), ecc.

Salvare CFF su disco - utilizza l’oggetto CffFont e CffFont.getFontName(), CffFont.getNumGlyphs(), ecc.

Come caricare un CFF da un font su disco in Java?

Caricare un file di font .cff definendo un FontDefinition con FontType.CFF e 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.");
    }
}

Come caricare un font CFF da un array di byte (`byte[]`)?

Dopo aver caricato un font in memoria ed eseguito l’estrazione o la modifica dei dati, è possibile salvare nuovamente il font nella memoria locale su disco o scriverlo in uno stream di byte di output.

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

Come modificare e salvare i font CFF su disco?

Dopo aver caricato e interagito con un’istanza CffFont, scrivere il file del font in una nuova posizione utilizzando il metodo 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);
    }
}

Installazione e configurazione

Includere Aspose.Font per Java nel progetto tramite 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>

Passaggi successivi

Domande frequenti

1. Qual è la differenza tra OpenType CFF (.otf) e CFF autonomo (.cff)?

Un file .cff autonomo contiene dati grezzi del programma del font PostScript senza wrapper delle tabelle OpenType. Un file .otf con contorni CFF racchiude il flusso .cff all’interno delle strutture delle tabelle OpenType standard (CFF, cmap, head, ecc.). Aspose.Font for Java supporta sia i formati CFF autonomi che OpenType CFF.

2. Posso convertire i font CFF in altri formati di font come TTF o WOFF in Java?

Sì. Una volta caricati in un’istanza CffFont, Aspose.Font for Java fornisce funzionalità di rendering e codifica che consentono di convertire i dati dei font in altri formati di destinazione come TTF, WOFF o WOFF2.

3. Posso salvare un CffFont modificato direttamente in un OutputStream?

Sì. Oltre a passare una stringa contenente il percorso del file a font.save(fileName), è possibile passare un java.io.OutputStream per scrivere direttamente i dati binari del font in flussi di rete o di memoria.