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

Bilder aus PDF-Dokumenten in Java in 5 Schritten extrahieren

1. API-Anmeldeinformationen konfigurieren: Erstellen Sie ein Configuration-Objekt und setzen Sie Ihre Client-ID und Ihr Client-Secret.

Configuration config = new Configuration();
config.setClientId("YOUR_CLIENT_ID");
config.setClientSecret("YOUR_CLIENT_SECRET");

2. Initialisieren der Parser-API: Erstellen Sie einen ApiClient mit der Konfiguration und instanziieren Sie ParserApi.

ApiClient apiClient = new ApiClient(config);
ParserApi parserApi = new ParserApi(apiClient);

3. Erstellen Sie die Bild‑Extraktionsanforderung: Geben Sie den PDF‑Dateipfad mit FileInfo an und erstellen Sie ein ExtractImagesRequest.

   String inputFilePath = "input.pdf";
   ExtractImagesRequest request = new ExtractImagesRequest()
           .setFileInfo(new FileInfo().setFilePath(inputFilePath));
   

4. Extraktion ausführen und Bilder abrufen: Rufen Sie extractImages auf und erhalten Sie die Liste der Image-Objekte.

   ImagesResult imagesResult = parserApi.extractImages(request);
   List<Image> images = imagesResult.getImages();
   

5. Speichern Sie jedes Bild im lokalen Speicher: Durchlaufen Sie die Sammlung und schreiben Sie die Binärdaten in Dateien.

for (int i = 0; i < images.size(); i++) {
    Image img = images.get(i);
    String outputFileName = "extracted_image_" + (i + 1) + "_" + img.getFileName();
    try (FileOutputStream fos = new FileOutputStream(outputFileName)) {
        fos.write(img.getData());
    }
    System.out.println("Saved image: " + outputFileName);
}

Für weitere Details zu jeder Klasse siehe die offizielle API‑Referenz.

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

Das folgende Beispiel demonstriert den vollständigen Workflow von der Einrichtung der Anmeldeinformationen bis zum Speichern des Bildes.

import com.groupdocs.parser.cloud.ApiClient;
import com.groupdocs.parser.cloud.Configuration;
import com.groupdocs.parser.cloud.api.ParserApi;
import com.groupdocs.parser.cloud.model.FileInfo;
import com.groupdocs.parser.cloud.model.Image;
import com.groupdocs.parser.cloud.model.ImagesResult;
import com.groupdocs.parser.cloud.model.requests.ExtractImagesRequest;

import java.io.FileOutputStream;
import java.util.List;

public class ExtractImagesFromPdf {
    public static void main(String[] args) {
        // Configure API credentials
        Configuration config = new Configuration();
        config.setClientId("YOUR_CLIENT_ID");
        config.setClientSecret("YOUR_CLIENT_SECRET");
        // config.setBaseUrl("https://api.groupdocs.cloud"); // optional, if needed

// Initialize API client and Parser API
        ApiClient apiClient = new ApiClient(config);
        ParserApi parserApi = new ParserApi(apiClient);

// Path to the PDF file stored in GroupDocs Cloud storage
        String inputFilePath = "input.pdf";

// Build request for image extraction
        ExtractImagesRequest request = new ExtractImagesRequest()
                .setFileInfo(new FileInfo().setFilePath(inputFilePath));

try {
            // Perform extraction
            ImagesResult imagesResult = parserApi.extractImages(request);
            List<Image> images = imagesResult.getImages();

// Save each extracted image to local disk
            for (int i = 0; i < images.size(); i++) {
                Image img = images.get(i);
                String outputFileName = "extracted_image_" + (i + 1) + "_" + img.getFileName();
                try (FileOutputStream fos = new FileOutputStream(outputFileName)) {
                    fos.write(img.getData());
                }
                System.out.println("Saved image: " + outputFileName);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

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, 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.

PDF-Bildextraktion über cURL und die REST-API

Sie können dasselbe Ergebnis erzielen, ohne Java‑Code zu schreiben, indem Sie die GroupDocs.Parser Cloud REST‑Endpunkte direkt aufrufen.

1. Ein Zugriffstoken erhalten

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

2. PDF-Datei hochladen

curl -X POST "https://api.groupdocs.cloud/v2.0/storage/file/upload?path=input.pdf" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -F "file=@/path/to/input.pdf"

3. Anforderung der Bildextraktion

curl -X POST "https://api.groupdocs.cloud/v2.0/parser/extractImages" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{"fileInfo": {"filePath": "input.pdf"}}'

4. Extrahierte Bilder herunterladen (die Antwort enthält Base64-Daten; Sie können sie lokal dekodieren)

Für eine vollständige Liste der Parameter siehe die offizielle API-Dokumentation.

Installation und Konfiguration GroupDocs.Parser Cloud SDK for Java

Fügen Sie die Maven‑Abhängigkeit zu Ihrer pom.xml hinzu (oder das entsprechende Gradle‑Snippet).

<dependency>
    <groupId>com.groupdocs</groupId>
    <artifactId>groupdocs-parser-cloud</artifactId>
    <version>26.2</version>
</dependency>

Das SDK wird als Cloud‑Bibliothek bereitgestellt; lokale Binärdateien sind nicht erforderlich. Laden Sie das neueste Paket von der release page herunter. Stellen Sie sicher, dass Sie Java 8 oder höher haben und ein gültiges GroupDocs Cloud‑Konto mit Client‑ID und Secret besitzen.

GroupDocs.Parser Cloud SDK for Java Funktionen zur Bildabfrage

• Vollständige PDF‑Bildextraktion – Ruft jedes Raster‑ und Vektorbild ab, das im Dokument eingebettet ist.
• Metadaten für jedes Bild – Gibt Dateiname, Größe, Format und Seitenzahl zurück.
• Unterstützung aller gängigen Bildformate – PNG, JPG, BMP, GIF, TIFF, und mehr.
• Cloud‑Speicherintegration – Arbeitet direkt mit Dateien, die in GroupDocs Cloud gespeichert sind, ohne sie zuerst herunterzuladen.
• Skalierbare REST‑basierte Verarbeitung – Bewältigt große PDFs und Workloads mit hohem Volumen über die Cloud‑API.

Feinabstimmung der Bildextraktionseinstellungen

Während die Grundanforderung sofort funktioniert, können Sie Optionen wie folgt anpassen:

• Passwortschutz - Setzen Sie die password-Eigenschaft bei FileInfo für verschlüsselte PDFs.
• Seitenbereich - Beschränken Sie die Extraktion auf bestimmte Seiten, indem Sie dem Anforderungs‑JSON ein pages‑Array hinzufügen.
• Bildformatkonvertierung - Fordern Sie die Konvertierung in ein anderes Format an, indem Sie den gewünschten Ausgabetyp in der Anforderung angeben (siehe die API‑Referenz für genaue Felder).

Beispiel für das Festlegen eines Passworts (aus dem Hauptcode entnommen):

FileInfo fileInfo = new FileInfo()
        .setFilePath("protected.pdf")
        .setPassword("mySecret");

Praktische Tipps für die effiziente PDF‑Bildextraktion

• Dateiexistenz prüfen bevor die Anfrage gesendet wird, um unnötige API‑Aufrufe zu vermeiden.
• Bilder in Streams verarbeiten bei großen Dateien, um den Speicherverbrauch zu reduzieren.
• Paginierung verwenden, wenn Sie nur Bilder bestimmter Seiten benötigen; das beschleunigt die Antwort.
• API‑Ratenlimits behandeln, indem Sie exponentielles Back‑off bei HTTP 429‑Antworten implementieren.
• Jeden gespeicherten Dateinamen protokollieren, um die Fehlersuche und Audits zu vereinfachen.

Fazit

Das Extrahieren von Bildern aus PDF‑Dokumenten in Java wird zu einer einfachen, zuverlässigen Aufgabe, wenn Sie die Leistungsfähigkeit des GroupDocs.Parser Cloud SDK for Java nutzen. Das SDK übernimmt die Verwaltung von Anmeldeinformationen, die Interaktion mit dem Cloud‑Speicher und die Bilddekodierung, sodass Sie sich auf die Logik Ihrer Anwendung konzentrieren können. Für den Produktionseinsatz erwerben Sie eine passende Lizenz auf der Preisübersichtsseite oder erhalten eine temporäre Lizenz zur Evaluierung. Mit dem Code‑Beispiel, der cURL‑Anleitung und den Best‑Practice‑Empfehlungen in diesem Artikel sind Sie bereit, die PDF‑Bilderextraktion in jede Java‑basierte Lösung zu integrieren.

FAQs

• Welche Formate können aus einem PDF extrahiert werden?
  Das SDK extrahiert Rasterformate wie PNG, JPG, BMP, GIF und TIFF sowie Vektorgrafiken, wenn sie als Bilder gespeichert sind.

• Muss ich das PDF herunterladen, bevor ich Bilder extrahiere?
  Nein. Das SDK arbeitet direkt mit Dateien, die im GroupDocs Cloud‑Speicher gespeichert sind, und eliminiert so die Notwendigkeit lokaler Downloads.

• Wie geht das SDK mit großen PDFs um?
  Die Extraktion wird serverseitig durchgeführt, sodass die Speichernutzung auf Ihrem Rechner gering bleibt. Sie können die Extraktion auch auf bestimmte Seiten beschränken, um die Leistung zu verbessern.

• Gibt es eine Möglichkeit, die Extraktion zu testen, ohne Code zu schreiben?
  Ja, Sie können die oben bereitgestellten cURL-Befehle verwenden oder die interaktive API-Konsole auf der Produktseite ausprobieren.

Read More

• Bilder aus PDF-Dateien in Java mithilfe der REST-API extrahieren
• Bilder aus Word-Dokumenten programmgesteuert in Java extrahieren
• Bilder aus PDF-Dokumenten mit Python extrahieren