1. Produtos
  2.   PDF
  3.   C++
  4.   PDFio
 
  

Biblioteca C++ PDF gratuita para leitura e escrita de arquivos PDF

Uma simples biblioteca PDF de código aberto baseada em C permite ler, escrever e manipular documentos PDF. Ela suporta conversão de imagem para PDF, extração de conteúdo, leitura de PDF baseada em stream e muito mais, dentro de aplicativos C.

O que é a Biblioteca PDFio?

PDFio é uma biblioteca C leve e de código aberto projetada especificamente para ler e escrever arquivos PDF sem a complexidade de renderização ou visualização. Criada por Michael R Sweet e licenciada sob a Licença Apache Versão 2.0, esta biblioteca oferece aos desenvolvedores uma abordagem direta para a manipulação de PDFs que se concentra na criação, extração e transformação de conteúdo, em vez da apresentação visual. A biblioteca é muito fácil de usar e fornece várias maneiras de manipular arquivos PDF, como extração e mesclagem de páginas, geração automática de relatórios a partir de bancos de dados, marca d'água e carimbos, criação de certificados e diplomas, incorporação de fontes para arquivamento, modificação de metadados e muito mais.

O PDFio concentra-se nas operações essenciais de I/O, tornando-o perfeito para aplicações que precisam extrair dados de PDFs ou criar novos sem a sobrecarga de bibliotecas mais complexas. A biblioteca oferece recursos poderosos de conversão e permite que desenvolvedores de software convertam markdown para PDF, imagem para PDF, HTML para PDF, bem como geração de códigos de barras em PDFs dentro de aplicações C. Seu foco na funcionalidade central, sem a sobrecarga de renderização, o torna ideal para aplicações server-side, ferramentas de linha de comando e sistemas embarcados onde a criação ou processamento de PDFs é necessário sem exibição visual. Seja construindo sistemas de gerenciamento de documentos, criando geradores automáticos de relatórios ou desenvolvendo ferramentas para análise de PDFs, o PDFio oferece a funcionalidade essencial necessária para o manuseio profissional de PDFs em aplicações C.

Previous Next

Começando com o PDFio

A forma recomendada de instalar o PDFio é usando o NuGet. Por favor, use o comando a seguir para uma instalação tranquila.

Instalar PDFio via NuGet

Install-Package pdfio_native

Instalar PDFio via GitHub

 git clone  https://github.com/michaelrsweet/pdfio.git

Você também pode instalá-lo manualmente; baixe os arquivos da versão mais recente diretamente do repositório GitHub.

Criando um PDF do zero via C

A biblioteca de código aberto PDFio incluiu suporte completo para criar novos documentos PDF do zero em aplicações C. Criar um novo documento PDF é igualmente simples e, com apenas algumas linhas de código C, os desenvolvedores de software podem adicionar novas páginas, desenhar texto e formas simples, adicionar imagens (formatos JPEG, PNG), aplicar cores e transformações, construir tabelas e layouts estruturados e muito mais. Aqui está um exemplo simples que demonstra como criar um novo documento PDF com tamanho de página personalizado e conteúdo usando código C.

Como Criar um Documento PDF Simples com Tamanho de Página Personalizado e Conteúdo via Biblioteca C?

#include 
#include 

int main(void) {
    pdfio_file_t *pdf;
    pdfio_dict_t *dict;
    pdfio_stream_t *page;
    pdfio_obj_t *font;
    pdfio_rect_t media_box = {0.0, 0.0, 612.0, 792.0};  // US Letter
    pdfio_rect_t crop_box = {36.0, 36.0, 576.0, 756.0}; // 0.5\" margins
    
    // Create PDF file
    pdf = pdfioFileCreate(\"output.pdf\", \"2.0\", 
                          &media_box, &crop_box,
                          NULL, NULL);
    
    if (!pdf) {
        fprintf(stderr, \"Unable to create PDF\\n\");
        return 1;
    }
    
    // Create a font object (Helvetica)
    font = pdfioFileCreateFontObjFromBase(pdf, \"Helvetica\");
    
    // Create page dictionary
    dict = pdfioDictCreate(pdf);
    pdfioPageDictAddFont(dict, \"F1\", font);
    
    // Create the page
    page = pdfioFileCreatePage(pdf, dict);
    
    // Draw text
    pdfioContentSetFillColorDeviceGray(page, 0.0);  // Black color
    pdfioContentTextBegin(page);
    pdfioContentSetTextFont(page, \"F1\", 24.0);
    pdfioContentTextMoveTo(page, 100.0, 700.0);
    pdfioContentTextShow(page, false, \"Hello, PDFio!\");
    pdfioContentTextEnd(page);
    
    // Close page and file
    pdfioStreamClose(page);
    pdfioFileClose(pdf);
    
    printf(\"PDF created successfully!\\n\");
    return 0;
}

Conversão de Imagem para PDF via Biblioteca C

Converter imagens para o formato PDF é uma das tarefas de processamento de documentos mais comuns. A biblioteca PDFio torna isso simples, ao mesmo tempo em que fornece controle preciso sobre o tamanho da página, posicionamento da imagem, dimensionamento e metadados. Desenvolvedores de software podem criar um conversor completo de imagem para PDF que lida tanto com imagens individuais quanto com conversões em lote. O exemplo a seguir demonstra como os desenvolvedores podem converter uma imagem em PDF dentro de aplicativos C.

Como converter uma única imagem em PDF via biblioteca C?

#include 
#include 
#include 

bool create_pdf_from_image(const char *image_path, 
                           const char *pdf_path,
                           const char *title) {
    pdfio_file_t *pdf;
    pdfio_obj_t *image;
    pdfio_dict_t *page_dict;
    pdfio_stream_t *page_stream;
    pdfio_rect_t media_box;
    double img_width, img_height;
    double page_width, page_height;
    double scale_x, scale_y, scale;
    double x, y;
    
    // Create the image object first to get dimensions
    // We'll use a temporary PDF for this
    pdfio_rect_t temp_box = {0, 0, 612, 792};
    pdf = pdfioFileCreate(pdf_path, "2.0", &temp_box, NULL, NULL, NULL);
    
    if (!pdf) {
        fprintf(stderr, "Error: Cannot create PDF file\n");
        return false;
    }
    
    // Set PDF metadata
    if (title) {
        pdfioFileSetTitle(pdf, title);
    }
    pdfioFileSetAuthor(pdf, "PDFio Image Converter");
    pdfioFileSetCreator(pdf, "image2pdf v1.0");
    
    // Load and embed the image
    image = pdfioFileCreateImageObjFromFile(pdf, image_path, true);
    
    if (!image) {
        fprintf(stderr, "Error: Cannot load image file: %s\n", image_path);
        pdfioFileClose(pdf);
        return false;
    }
    
    // Get image dimensions in pixels
    img_width = pdfioImageGetWidth(image);
    img_height = pdfioImageGetHeight(image);
    
    printf("Image dimensions: %.0f x %.0f pixels\n", img_width, img_height);
    
    // Create page sized to image (assuming 72 DPI)
    // This creates a PDF page that exactly fits the image
    page_width = img_width;
    page_height = img_height;
    
    media_box.x1 = 0.0;
    media_box.y1 = 0.0;
    media_box.x2 = page_width;
    media_box.y2 = page_height;
    
    // Create page dictionary and add image resource
    page_dict = pdfioDictCreate(pdf);
    pdfioDictSetRect(page_dict, "MediaBox", &media_box);
    pdfioPageDictAddImage(page_dict, "IM1", image);
    
    // Create the page
    page_stream = pdfioFileCreatePage(pdf, page_dict);
    
    // Draw image at full size (no scaling)
    pdfioContentDrawImage(page_stream, "IM1", 0, 0, 
                         page_width, page_height);
    
    // Close and save
    pdfioStreamClose(page_stream);
    pdfioFileClose(pdf);
    
    printf("Successfully created PDF: %s\n", pdf_path);
    return true;
}

int main(int argc, char *argv[]) {
    if (argc < 3) {
        fprintf(stderr, "Usage: %s   [title]\n", 
                argv[0]);
        return 1;
    }
    
    const char *title = (argc > 3) ? argv[3] : NULL;
    
    if (!create_pdf_from_image(argv[1], argv[2], title)) {
        return 1;
    }
    
    return 0;
}

Ler PDF e Extrair Texto via Biblioteca C

Uma das tarefas mais comuns é ler e extrair texto de um arquivo PDF. A biblioteca de código aberto PDFio torna esse processo intuitivo ao permitir que os desenvolvedores percorram páginas e seus fluxos de conteúdo. A biblioteca oferece suporte total para extrair informações úteis de PDFs existentes, como texto simples, metadados, fontes incorporadas, números, imagens, uvas, nomes e muito mais. O exemplo a seguir demonstra como abrir um PDF existente e extrair informações básicas dele usando a biblioteca C.

Como extrair texto simples de um arquivo PDF via biblioteca C?

#include 
#include 
#include 

// Callback function to handle text objects
static bool text_cb(const pdfio_text_t *text, void *data) {
    // Simply print the text to stdout
    printf("%s", text->utf8);
    return true;
}

int main(void) {
    pdfio_file_t *pdf;
    pdfio_page_t *page;

    // Open the PDF file for reading
    pdf = pdfioFileOpen("example.pdf", NULL, NULL, NULL);
    if (!pdf) {
        fprintf(stderr, "Failed to open example.pdf\n");
        return 1;
    }

    printf("PDF has %d pages.\n", pdfioFileGetNumPages(pdf));

    // Read the first page (pages are 1-indexed)
    page = pdfioFileGetPage(pdf, 1);
    if (!page) {
        fprintf(stderr, "Failed to read page 1\n");
        pdfioFileClose(pdf);
        return 1;
    }

    // Parse the page content and call our text_cb for each text object
    if (!pdfioPageParseContents(page, text_cb, NULL, NULL, NULL)) {
        fprintf(stderr, "Failed to parse page contents\n");
    }

    // Clean up
    pdfioFileClose(pdf);
    return 0;
}

Leitura eficiente baseada em fluxo

PDFio foi projetado para eficiência. Ao ler, ele não carrega o arquivo inteiro na memória de uma só vez. Em vez disso, usa uma abordagem de análise pull, permitindo que você processe o arquivo em partes. Isso é crucial para lidar com PDFs muito grandes sem esgotar a memória do sistema. A função pdfioPageParseContents do primeiro exemplo é um exemplo clássico desse modelo baseado em fluxo. Ela lê o fluxo de conteúdo da página sequencialmente, emitindo eventos (como nosso callback de texto) à medida que avança.

 Português