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

Ilmainen C++ PDF -kirjasto PDF-tiedostojen lukemiseen ja kirjoittamiseen

Yksinkertainen avoimen lähdekoodin C-pohjainen PDF-kirjasto mahdollistaa PDF-dokumenttien lukemisen, kirjoittamisen ja muokkaamisen. Se tukee kuvan muuntamista PDF:ksi, sisällön poimintaa, virta-pohjaista PDF-lukemista ja muuta C-sovelluksissa.

Mikä on PDFio-kirjasto?

PDFio on kevyt, avoimen lähdekoodin C-kirjasto, joka on suunniteltu erityisesti PDF-tiedostojen lukemiseen ja kirjoittamiseen ilman renderöinnin tai katselun monimutkaisuutta. Michael R Sweetin luoma ja Apache License Version 2.0 -lisenssin alainen, tämä kirjasto tarjoaa kehittäjille suoraviivaisen lähestymistavan PDF-manipulointiin, joka keskittyy sisällön luomiseen, poimintaan ja muuntamiseen sen sijaan, että keskityttäisiin visuaaliseen esitykseen. Kirjasto on erittäin helppokäyttöinen ja tarjoaa useita tapoja PDF-tiedostojen käsittelyyn, kuten PDF-sivujen poiminta ja yhdistäminen, automaattiset raportit tietokannoista, vesileimojen ja leimojen lisääminen, sertifikaatti- ja diplomien luominen, fonttien upottaminen arkistointia varten, metatietojen muokkaus ja monia muita.

PDFio keskittyy olennaisiin I/O-toimintoihin, mikä tekee siitä täydellisen sovelluksille, jotka tarvitsevat tietojen poimimista PDF-tiedostoista tai uusien luomista ilman monimutkaisempien kirjastojen ylimääräistä kuormitusta. Kirjasto tukee tehokkaita muunnostoimintoja ja mahdollistaa ohjelmistokehittäjille markdownin muuntamisen PDF:ksi, kuvan muuntamisen PDF:ksi, HTML:n muuntamisen PDF:ksi sekä viivakoodien luomisen PDF-tiedostoihin C-sovelluksissa. Sen keskittyminen ydintoiminnallisuuteen ilman renderöinnin kuormitusta tekee siitä ihanteellisen palvelinpuolen sovelluksiin, komentorivityökaluihin ja sulautettuihin järjestelmiin, joissa PDF:n luonti tai käsittely on tarpeen ilman visuaalista näyttöä. Olipa kyseessä asiakirjojen hallintajärjestelmien rakentaminen, automatisoitujen raporttigeneraattorien luominen tai PDF-analyysityökalujen kehittäminen, PDFio tarjoaa olennaisen toiminnallisuuden ammatilliseen PDF-käsittelyyn C-sovelluksissa.

Previous Next

PDFio:n käyttöönotto

Suositeltu tapa asentaa PDFio on käyttää NuGetia. Käytä seuraavaa komentoa sujuvan asennuksen varmistamiseksi.

Asenna PDFio NuGetin kautta

Install-Package pdfio_native

Asenna PDFio GitHubin kautta

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

Voit myös asentaa sen manuaalisesti; lataa uusimmat julkaisutiedostot suoraan GitHub-varastosta.

PDF:n luominen alusta alkaen C:n avulla

Avoimen lähdekoodin PDFio-kirjasto on sisällyttänyt täyden tuen uusien PDF-asiakirjojen luomiseen alusta alkaen C-sovelluksissa. Uuden PDF-asiakirjan luominen on yhtä helppoa, ja vain muutamalla C-koodirivillä ohjelmistokehittäjät voivat lisätä uusia sivuja, piirtää tekstiä ja yksinkertaisia muotoja, lisätä kuvia (JPEG-, PNG-muodot), soveltaa värejä ja muunnoksia, rakentaa taulukoita ja rakenteellisia asetteluja sekä paljon muuta. Tässä on yksinkertainen esimerkki, joka osoittaa, miten luodaan uusi PDF-asiakirja mukautetulla sivukoolla ja sisällöllä C-koodia käyttäen.

Kuinka luoda yksinkertainen PDF-asiakirja mukautetulla sivukoolla ja sisällöllä C-kirjaston avulla?

#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;
}

Kuvan muuntaminen PDF:ksi C-kirjaston avulla

Kuvien muuntaminen PDF-muotoon on yksi yleisimmistä asiakirjankäsittelyn tehtävistä. PDFio-kirjasto tekee tästä suoraviivaista samalla kun se tarjoaa tarkan hallinnan sivukoon, kuvan sijoittelun, skaalaamisen ja metatietojen suhteen. Ohjelmistokehittäjät voivat rakentaa täydellisen kuva-PDF-muuntimen, joka käsittelee sekä yksittäisiä kuvia että erämuunnoksia. Seuraava esimerkki osoittaa, miten kehittäjät voivat muuntaa yhden kuvan PDF:ksi C-sovelluksissa.

Kuinka muuntaa yksittäinen kuva PDF:ksi C-kirjaston avulla?

#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;
}

PDF:n lukeminen ja tekstin poiminta C-kirjaston avulla

Yksi yleisimmistä tehtävistä on PDF-tiedoston lukeminen ja tekstin poimiminen. Avoimen lähdekoodin PDFio-kirjasto tekee tästä prosessista intuitiivisen antamalla kehittäjien iteratoida sivuja ja niiden sisältövirtoja. Kirjasto tarjoaa täyden tuen hyödyllisen tiedon poimimiseen olemassa olevista PDF-tiedostoista, kuten yksinkertainen teksti, metatiedot, upotetut fontit, numerot, kuvat, rypäleet, nimet ja paljon muuta. Seuraava esimerkki näyttää, miten avata olemassa oleva PDF ja poimia siitä perusinformaatio C-kirjastoa käyttäen.

Kuinka poimia yksinkertaista tekstiä PDF-tiedostosta C-kirjaston avulla?

#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;
}

Tehokas, suoratoistopohjainen lukeminen

PDFio on suunniteltu tehokkuutta varten. Lukiessa se ei lataa koko tiedostoa muistiin kerralla. Sen sijaan se käyttää pull-parsing‑lähestymistapaa, jonka avulla voit käsitellä tiedostoa paloina. Tämä on ratkaisevaa erittäin suurten PDF-tiedostojen käsittelemiseksi kuluttamatta järjestelmämuistia. pdfioPageParseContents‑funktio ensimmäisestä esimerkistä on erinomainen esimerkki tästä virta‑pohjaisesta mallista. Se lukee sivun sisältövirran peräkkäin, lähettäen tapahtumia (kuten tekstikutsumme) matkan varrella.

 Suomen