Darmowa biblioteka C++ PDF do odczytu i zapisu plików PDF

Zainstaluj PDFio przez NuGet

Install-Package pdfio_native 

Zainstaluj PDFio przez GitHub

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

Możesz również zainstalować go ręcznie; pobierz najnowsze pliki wydania bezpośrednio z repozytorium GitHub.

Jak stworzyć prosty dokument PDF z niestandardowym rozmiarem strony i zawartością przy użyciu biblioteki 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;
}

Jak przekonwertować pojedynczy obraz na PDF przy użyciu biblioteki 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;
}
 

Jak wyodrębnić prosty tekst z pliku PDF przy użyciu biblioteki 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;
}