Schritte zum Extrahieren von Bildern aus PDF-Dokumenten in C#

1. PDF zu GroupDocs Cloud-Speicher hochladen: Verwenden Sie StorageApi.UploadFile, um die Quell‑PDF in die Cloud zu legen.

var uploadRequest = new UploadFileRequest(remotePdfPath, File.ReadAllBytes(localPdfPath));
storageApi.UploadFile(uploadRequest);

Dieser Aufruf stellt sicher, dass die Datei für die Analyse zugänglich ist.

2. Dokumentbilder anfordern: Rufen Sie ParserApi.GetDocumentImages mit einer GetDocumentImagesRequest auf.

var imagesRequest = new GetDocumentImagesRequest(remotePdfPath);
ImagesResult imagesResult = parserApi.GetDocumentImages(imagesRequest);

Die Antwort enthält eine Sammlung von ImageInfo‑Objekten, von denen jedes Base64‑Daten und Metadaten enthält. Siehe die API‑Referenz für weitere Details.

3. Dekodieren und speichern Sie jedes Bild: Durchlaufen Sie imagesResult.Images, konvertieren Sie die Base64‑Zeichenfolge in ein Byte‑Array und schreiben Sie die Datei auf die Festplatte.

foreach (ImageInfo imgInfo in imagesResult.Images)
{
    byte[] imageBytes = Convert.FromBase64String(imgInfo.Base64Data);
    string extension = imgInfo.FileExtension?.TrimStart('.').ToLower() ?? "bin";
    string fileName = $"extracted_page{imgInfo.PageNumber}_img{imgInfo.ImageIndex}_{imageCounter}.{extension}";
    File.WriteAllBytes(fileName, imageBytes);
}

Die Konsole protokolliert den gespeicherten Dateinamen, die Abmessungen und die DPI zur Überprüfung.

4. (Optional) Entfernen der entfernten PDF: Nach der Extraktion können Sie die hochgeladene Datei löschen, um den Speicher ordentlich zu halten.

var deleteRequest = new DeleteFileRequest(remotePdfPath);
storageApi.DeleteFile(deleteRequest);

Dieser Schritt ist in einen try‑catch‑Block eingeschlossen, um etwaige Aufräumfehler zu ignorieren.

5. Ausgabe überprüfen: Die Konsole zeigt eine Zusammenfassung wie Total images extracted: 12, die die erfolgreiche Extraktion bestätigt.

Vollständiges Codebeispiel: Bilder aus PDF-Dokumenten extrahieren mit GroupDocs.Parser

Das folgende Beispiel demonstriert den oben beschriebenen vollständigen Workflow. Es beinhaltet Konfiguration, Upload, Bildextraktion, Speicherung und optionale Bereinigung.

using System;
using System.IO;
using System.Collections.Generic;
using GroupDocs.Parser.Cloud.Sdk.Api;
using GroupDocs.Parser.Cloud.Sdk.Client;
using GroupDocs.Parser.Cloud.Sdk.Model;
using GroupDocs.Parser.Cloud.Sdk.Model.Requests;

namespace ExtractImagesFromPdf
{
    class Program
    {
        static void Main(string[] args)
        {
            // Configuration – replace with your actual credentials
            var config = new Configuration
            {
                ClientId = "YOUR_CLIENT_ID",
                ClientSecret = "YOUR_CLIENT_SECRET"
            };

// APIs
            var storageApi = new StorageApi(config);
            var parserApi = new ParserApi(config);

// Input PDF path (local) and remote name in storage
            const string localPdfPath = "input.pdf";
            const string remotePdfPath = "input.pdf";

try
            {
                // -------------------------------------------------
                // 1. Upload PDF to GroupDocs Cloud storage (if not already there)
                // -------------------------------------------------
                if (!File.Exists(localPdfPath))
                    throw new FileNotFoundException($"Local file not found: {localPdfPath}");

var uploadRequest = new UploadFileRequest(remotePdfPath, File.ReadAllBytes(localPdfPath));
                storageApi.UploadFile(uploadRequest);

// -------------------------------------------------
                // 2. Retrieve document images (all pages)
                // -------------------------------------------------
                var imagesRequest = new GetDocumentImagesRequest(remotePdfPath);
                ImagesResult imagesResult = parserApi.GetDocumentImages(imagesRequest);

// -------------------------------------------------
                // 3. Save each extracted image to disk
                // -------------------------------------------------
                int imageCounter = 0;
                foreach (ImageInfo imgInfo in imagesResult.Images)
                {
                    // Image data is returned as Base64 string
                    byte[] imageBytes = Convert.FromBase64String(imgInfo.Base64Data);

// Build a descriptive file name
                    string extension = imgInfo.FileExtension?.TrimStart('.').ToLower() ?? "bin";
                    string fileName = $"extracted_page{imgInfo.PageNumber}_img{imgInfo.ImageIndex}_{imageCounter}.{extension}";
                    File.WriteAllBytes(fileName, imageBytes);

Console.WriteLine($"Saved: {fileName} ({imgInfo.Width}x{imgInfo.Height} px, {imgInfo.Resolution} DPI)");
                    imageCounter++;
                }

Console.WriteLine($"Total images extracted: {imageCounter}");
            }
            catch (ApiException apiEx)
            {
                Console.Error.WriteLine($"GroupDocs API error: {apiEx.ErrorCode} - {apiEx.Message}");
            }
            catch (Exception ex)
            {
                Console.Error.WriteLine($"Unexpected error: {ex.Message}");
            }
            finally
            {
                // -------------------------------------------------
                // 4. Optional cleanup – delete the uploaded PDF from storage
                // -------------------------------------------------
                try
                {
                    var deleteRequest = new DeleteFileRequest(remotePdfPath);
                    storageApi.DeleteFile(deleteRequest);
                }
                catch
                {
                    // Ignored – cleanup is optional
                }
            }
        }
    }
}

Hinweis: Dieses Codebeispiel demonstriert die Kernfunktionalität. Bevor Sie es in Ihrem Projekt verwenden, stellen Sie sicher, dass Sie alle Dateipfade und Konfigurationswerte an Ihre tatsächliche Umgebung anpassen, überprüfen Sie, dass alle erforderlichen Abhängigkeiten ordnungsgemäß installiert sind, und testen Sie gründlich in Ihrer Entwicklungsumgebung. Wenn Sie auf Probleme stoßen, lesen Sie bitte die offizielle Dokumentation oder wenden Sie sich an das Support-Team für Unterstützung.

Bilder extrahieren über REST API mit cURL

Der gleiche Vorgang kann mit direkten REST‑Aufrufen durchgeführt werden. Unten ist ein minimaler cURL‑Workflow.

1. Ein Zugriffstoken erhalten (OAuth 2.0 client credentials grant).

curl -X POST "https://api.groupdocs.cloud/v2.0/oauth2/token" \
     -H "Content-Type: application/x-www-form-urlencoded" \
     -d "grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET"

Die Antwort enthält access_token.

2. PDF hochladen in den Cloud‑Speicher.

curl -X PUT "https://api.groupdocs.cloud/v2.0/storage/file/input.pdf" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -H "Content-Type: application/pdf" \
     --data-binary "@input.pdf"

3. Bilder anfordern für das hochgeladene Dokument.

curl -X GET "https://api.groupdocs.cloud/v2.0/parser/input.pdf/images" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

Die JSON Antwort enthält ein Array von Bildern mit base64Data, fileExtension, pageNumber usw.

4. Jedes Bild lokal speichern (Beispiel mit jq und base64).

curl -X GET "https://api.groupdocs.cloud/v2.0/parser/input.pdf/images" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" | \
     jq -r '.images[] | "\(.pageNumber)_\(.imageIndex).\(.fileExtension) \(.base64Data)"' | \
     while read filename b64; do
         echo "$b64" | base64 -d > "$filename"
     done

Weitere Details zu Endpunkten und Parametern finden Sie in der offiziellen API-Dokumentation.

Umgebung einrichten

1. Installieren Sie die .NET‑Clientbibliothek über NuGet:

dotnet add package GroupDocs.Parser-Cloud

Das Paket ist über die offizielle Download‑Seite verfügbar.

2. Stellen Sie sicher, dass .NET 6.0 oder höher installiert ist und Sie ein gültiges GroupDocs Cloud‑Konto mit Client‑Anmeldeinformationen besitzen.

3. (Optional) Klonen Sie das Beispiel-Repository zur Referenz:

git clone https://github.com/groupdocs-parser-cloud/groupdocs-parser-cloud-dotnet.git

Was macht GroupDocs.Parser für die Bildextraktion geeignet?

• Direkte Bildabruf: Der Aufruf GetDocumentImages gibt Bilder in ihrem Originalformat zurück, ohne zusätzliche Konvertierungsschritte.
• Base64‑Bereitstellung: Bilder werden als Base64‑Strings bereitgestellt, was das Dekodieren in jeder Sprache erleichtert.
• Seitenbezogene Metadaten: Jede ImageInfo enthält Seitenzahl, Abmessungen, Auflösung und Index, was die Organisation extrahierter Assets unterstützt.
• Unterstützung aller gängigen Rasterformate: PNG, JPEG, BMP, GIF, TIFF und weitere werden exakt so erhalten, wie sie im PDF gespeichert sind.
• Skalierbare Cloud‑Verarbeitung: Große PDFs werden auf GroupDocs‑Servern verarbeitet, wodurch der Speicherverbrauch Ihrer Anwendung reduziert wird.

Konfigurieren von Bildextraktionsoptionen

Während das Grundbeispiel sofort funktioniert, können Sie die Anfrage feinabstimmen:

• Seitenbereich angeben: Fügen Sie pages = "1-5" zu GetDocumentImagesRequest hinzu, um die Extraktion zu begrenzen.
• Bildqualität festlegen: Verwenden Sie den Parameter imageQuality (0‑100), wenn Sie eine komprimierte Ausgabe benötigen.
• Nach Format filtern: Geben Sie fileExtensions = ["png","jpeg"] an, um nur die ausgewählten Formate zu erhalten.

Diese Optionen sind in der API-Referenz dokumentiert.

Fazit

Das Extrahieren von Bildern aus PDF‑Dokumenten in C# wird zu einem einfachen, zuverlässigen Vorgang, wenn Sie das GroupDocs.Parser Cloud SDK for .NET nutzen. Das SDK übernimmt das Hochladen, Parsen und die Base64‑Konvertierung, sodass Sie sich auf das Speichern von Dateien und die Integration in Ihren Arbeitsablauf konzentrieren können. Denken Sie daran, Ihre Client‑Anmeldeinformationen zu sichern, die Lizenzbedingungen zu beachten und für die Evaluierung eine temporäre Lizenz auf der temporären Lizenzseite in Betracht zu ziehen. Mit dem bereitgestellten Code und den REST‑Beispielen sind Sie bereit, eine robuste PDF‑Bildextraktion in jede .NET‑Anwendung zu integrieren.

Häufig gestellte Fragen

Wie extrahiere ich Bilder aus PDF‑Dokumenten mit C#?
Verwenden Sie die GetDocumentImages‑Methode der Parser‑API, nachdem Sie die PDF mit StorageApi.UploadFile hochgeladen haben. Dekodieren Sie die zurückgegebenen Base64‑Zeichenfolgen und schreiben Sie sie auf die Festplatte, wie im Codebeispiel gezeigt.

Was ist, wenn das PDF passwortgeschützt ist?
Geben Sie das Passwort im Anforderungsmodell an. Das SDK entschlüsselt die Datei, bevor Bilder extrahiert werden. Siehe die Dokumentation für den genauen Eigenschaftsnamen.

Kann ich die Extraktion auf bestimmte Seiten beschränken?
Ja, setzen Sie die pages‑Eigenschaft von GetDocumentImagesRequest auf eine kommagetrennte Liste oder einen Bereich (z. B. "1-3,5"). Die API gibt nur Bilder von diesen Seiten zurück.

Gibt es Größenbeschränkungen für die extrahierten Bilder?
Das SDK gibt die Original‑Bilddaten ohne Größenänderung zurück. Wenn Sie kleinere Dateien benötigen, verarbeiten Sie die gespeicherten Bilder nachträglich mit einer beliebigen Bildverarbeitungsbibliothek.

Mehr lesen

• Bilder aus PDF in C# .NET extrahieren | PDF Image Extractor API
• Bilder aus PDF-Dokumenten in Java extrahieren
• Text aus PDF mit .NET REST API extrahieren | Document to Text Converter