Carregar e salvar fontes CFF em Java

Processe arquivos Compact Font Format (`.cff`) baseados em PostScript programaticamente com o Aspose.Font para Java. Abra binários de fontes CFF a partir de caminhos de arquivos locais ou arrays de bytes na memória, inspecione estruturas de fontes usando a classe `CffFont` e salve os dados de fontes modificados novamente no disco ou em streams sem dependências externas.

Compact Font Format (CFF) é uma representação compacta dos contornos de fontes PostScript Type 1, amplamente utilizada em documentos PDF, fontes OpenType CFF (.otf) e fluxos de trabalho de publicação digital. Com o Aspose.Font para Java, os desenvolvedores podem:

Processamento de fontes na memória: Carregar bytes de fontes CFF diretamente de BLOBs de banco de dados, streams PDF ou armazenamento em nuvem sem gravar arquivos temporários no disco.
Gerenciamento compacto de armazenamento: Manipular estruturas de fontes de contorno PostScript de baixo consumo de espaço para uma incorporação otimizada em documentos.
Operações de arquivos flexíveis: Ler arquivos de fontes CFF usando FileSystemStreamSource ou ByteContentStreamSource e exportá-los por meio de CffFont.save().

Fluxo de trabalho de processamento de fontes CFF

Carregar CFF do disco - usa (caminho do arquivo (.cff)) e FontDefinition + FileSystemStreamSource

Carregar CFF da memória - usa array de bytes binário (byte[]) e FontDefinition + ByteContentStreamSource

Inspecionar/editar dados CFF - usa o objeto CffFont e CffFont.getFontName(), CffFont.getNumGlyphs(), etc.

Salvar CFF no disco - usa o objeto CffFont e CffFont.getFontName(), CffFont.getNumGlyphs(), etc.

Como carregar um CFF de uma fonte no disco em Java?

Carregue um arquivo de fonte .cff definindo um FontDefinition com FontType.CFF e um 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.");
    }
}

Como carregar uma fonte CFF de um array de bytes (`byte[]`)?

Depois de carregar uma fonte na memória e realizar a extração ou modificação dos dados, você pode salvar a fonte novamente no armazenamento local em disco ou gravá-la em um stream de bytes de saída.

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

Como modificar e salvar fontes CFF no disco?

Depois de carregar e trabalhar com uma instância de CffFont, grave o arquivo da fonte em um novo local usando o 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);
    }
}

Instalação e configuração

Inclua o Aspose.Font para Java em seu projeto por meio do 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óximas etapas

FAQ

1. Qual é a diferença entre OpenType CFF (.otf) e CFF autônomo (.cff)?

Um arquivo .cff autônomo contém dados brutos do programa de fonte PostScript sem wrappers de tabela OpenType. Um arquivo .otf com contornos CFF envolve o fluxo .cff em estruturas de tabela OpenType padrão (CFF, cmap, head, etc.). O Aspose.Font for Java oferece suporte ao processamento dos formatos CFF autônomo e OpenType CFF.

2. Posso converter fontes CFF para outros formatos de fonte, como TTF ou WOFF, em Java?

Sim. Depois de carregadas em uma instância CffFont, o Aspose.Font for Java fornece recursos de renderização e codificação que permitem converter os dados da fonte para outros formatos de destino, como TTF, WOFF ou WOFF2.

3. Posso salvar um CffFont modificado diretamente em um OutputStream?

Sim. Além de passar uma string de caminho de arquivo para font.save(fileName), você pode passar um java.io.OutputStream para gravar dados binários de fonte diretamente em fluxos de rede ou de memória.