Text in Dateien erkennen (PDF/TIFF)

Die Vision API kann Text aus PDF- und TIFF-Dateien, die in Cloud Storage gespeichert sind, erkennen und transkribieren.

Die Texterkennung in PDF-/TIFF-Dokumenten muss mit der Funktion files:asyncBatchAnnotate angefordert werden. Diese Funktion führt eine (asynchrone) Offlineanfrage durch und gibt mithilfe der Ressourcen operations den Status an.

Die Ausgabedaten aus einer PDF/TIFF-Anfrage werden in eine JSON-Datei geschrieben, die im angegebenen Cloud Storage-Bucket erstellt wurde.

Beschränkungen

Die Vision API akzeptiert PDF/TIFF-Dateien mit maximal 2.000 Seiten. Größere Dateien führen zu einem Fehler.

Authentifizierung

API-Schlüssel werden bei files:asyncBatchAnnotate-Anfragen nicht unterstützt. Weitere Informationen dazu, wie Sie sich mit einem Dienstkonto authentifizieren, finden Sie unter Dienstkonto verwenden.

Das für die Authentifizierung verwendete Konto muss Zugriff auf den Cloud Storage-Bucket haben, den Sie für die Ausgabe (roles/editor oder roles/storage.objectCreator oder höher) festgelegt haben.

Sie können einen API-Schlüssel verwenden, um den Status des Vorgangs abzufragen. Eine Anleitung dazu finden Sie unter API-Schlüssel verwenden.

Anfragen zur Erkennung von Dokumenttext

Derzeit ist die PDF/TIFF-Dokumenterkennung nur für Dateien verfügbar, die in Cloud Storage-Buckets gespeichert sind. JSON-Antwortdateien werden ebenso in einem Cloud Storage-Bucket gespeichert.

PDF-Seite zur US-Volkszählung 2010
gs://cloud-samples-data/vision/pdf_tiff/census2010.pdf, Quelle: Statistisches Bundesamt der USA.

REST

Ersetzen Sie diese Werte in den folgenden Anfragedaten:

  • CLOUD_STORAGE_BUCKET: ein Google Cloud Storage-Bucket/-Verzeichnis, in dem Ausgabedateien gespeichert werden. Dies wird in folgender Form angegeben:
    • gs://bucket/directory/
    Der anfragende Nutzer muss Schreibberechtigung für den Bucket haben.
  • CLOUD_STORAGE_FILE_URI: der Pfad zu einer gültigen Datei (PDF/TIFF) in einem Cloud Storage-Bucket. Sie müssen zumindest Leseberechtigungen für die Datei haben. Beispiel: 
    • gs://cloud-samples-data/vision/pdf_tiff/census2010.pdf
  • FEATURE_TYPE: ein gültiger Featuretyp. Für files:asyncBatchAnnotate-Anfragen können Sie die folgenden Featuretypen verwenden:
    • DOCUMENT_TEXT_DETECTION
    • TEXT_DETECTION
  • PROJECT_ID: Ihre Google Cloud-Projekt-ID.

Feldspezifische Hinweise:

  • inputConfig ersetzt das Feld image, das in anderen Vision API-Anfragen verwendet wird. Es enthält zwei untergeordnete Felder:
    • gcsSource.uri ist der Google Cloud Storage-URI der PDF- oder TIFF-Datei (zugänglich für den Nutzer oder das Dienstkonto, von dem die Anfrage stammt).
    • mimeType ist einer der akzeptierten Dateitypen: application/pdf oder image/tiff.
  • outputConfig gibt Ausgabedetails an. Es enthält zwei untergeordnete Felder:
    • gcsDestination.uri ist ein gültiger Google Cloud Storage-URI. Der Nutzer oder das Dienstkonto, von dem die Anfrage gesendet wird, muss Schreibrechte für den Bucket haben. Der Dateiname ist output-x-to-y, wobei x und y für die Anzahl der PDF/TIFF-Seiten stehen, die in dieser Ausgabedatei enthalten sind. Wenn die Datei vorhanden ist, wird ihr Inhalt überschrieben.
    • batchSize gibt an, wie viele Ausgabeseiten in jeder JSON-Ausgabedatei enthalten sein sollen.

HTTP-Methode und URL:

POST https://vision.googleapis.com/v1/files:asyncBatchAnnotate

JSON-Text der Anfrage:

{
  "requests":[
    {
      "inputConfig": {
        "gcsSource": {
          "uri": "CLOUD_STORAGE_FILE_URI"
        },
        "mimeType": "application/pdf"
      },
      "features": [
        {
          "type": "FEATURE_TYPE"
        }
      ],
      "outputConfig": {
        "gcsDestination": {
          "uri": "CLOUD_STORAGE_BUCKET"
        },
        "batchSize": 1
      }
    }
  ]
}

Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

curl

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus: 

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "x-goog-user-project: PROJECT_ID" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://vision.googleapis.com/v1/files:asyncBatchAnnotate"

PowerShell

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus: 

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred"; "x-goog-user-project" = "PROJECT_ID" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://vision.googleapis.com/v1/files:asyncBatchAnnotate" | Select-Object -Expand Content
Antwort

Eine erfolgreiche asyncBatchAnnotate-Anfrage gibt als Antwort ein einzelnes Namensfeld zurück:

{
  "name": "projects/usable-auth-library/operations/1efec2285bd442df"
}

Dieser Name stellt einen Vorgang mit langer Ausführungszeit mit einer verknüpften ID dar (z. B. 1efec2285bd442df), die mit der v1.operations API abgefragt werden kann.

Sie können die Antwort mit den Vision-Annotationen abrufen. Dazu senden Sie eine GET-Anfrage an den Endpunkt v1.operations und übergeben in der URL die Vorgangs-ID:

GET https://vision.googleapis.com/v1/operations/operation-id

Beispiel:

curl -X GET -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
-H "Content-Type: application/json" \
https://vision.googleapis.com/v1/projects/project-id/locations/location-id/operations/1efec2285bd442df

Wenn der Vorgang läuft:

{
  "name": "operations/1efec2285bd442df",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.vision.v1.OperationMetadata",
    "state": "RUNNING",
    "createTime": "2019-05-15T21:10:08.401917049Z",
    "updateTime": "2019-05-15T21:10:33.700763554Z"
  }
}

Sobald der Vorgang abgeschlossen ist, wird der state als DONE angezeigt und Ihre Ergebnisse werden in die von Ihnen angegebene Google Cloud Storage-Datei geschrieben:

{
  "name": "operations/1efec2285bd442df",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.vision.v1.OperationMetadata",
    "state": "DONE",
    "createTime": "2019-05-15T20:56:30.622473785Z",
    "updateTime": "2019-05-15T20:56:41.666379749Z"
  },
  "done": true,
  "response": {
    "@type": "type.googleapis.com/google.cloud.vision.v1.AsyncBatchAnnotateFilesResponse",
    "responses": [
      {
        "outputConfig": {
          "gcsDestination": {
            "uri": "gs://your-bucket-name/folder/"
          },
          "batchSize": 1
        }
      }
    ]
  }
}

Die JSON-Datei in Ihrer Ausgabedatei ähnelt der [Anfrage zur Dokumenttexterkennung] für ein Bild (/vision/docs/ocr), wobei zusätzlich das Feld context vorhanden ist. Es gibt den Speicherort der angegebenen PDF- oder TIFF-Datei und die Anzahl der Seiten in der Datei an:

output-1-to-1.json

Go

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Go-Einrichtungsanleitung in der Vision-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Vision-Referenzdokumentation zur Go API.

Richten Sie zur Authentifizierung bei Vision die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 


// detectAsyncDocumentURI performs Optical Character Recognition (OCR) on a
// PDF file stored in GCS.
func detectAsyncDocumentURI(w io.Writer, gcsSourceURI, gcsDestinationURI string) error {
	ctx := context.Background()

	client, err := vision.NewImageAnnotatorClient(ctx)
	if err != nil {
		return err
	}

	request := &visionpb.AsyncBatchAnnotateFilesRequest{
		Requests: []*visionpb.AsyncAnnotateFileRequest{
			{
				Features: []*visionpb.Feature{
					{
						Type: visionpb.Feature_DOCUMENT_TEXT_DETECTION,
					},
				},
				InputConfig: &visionpb.InputConfig{
					GcsSource: &visionpb.GcsSource{Uri: gcsSourceURI},
					// Supported MimeTypes are: "application/pdf" and "image/tiff".
					MimeType: "application/pdf",
				},
				OutputConfig: &visionpb.OutputConfig{
					GcsDestination: &visionpb.GcsDestination{Uri: gcsDestinationURI},
					// How many pages should be grouped into each json output file.
					BatchSize: 2,
				},
			},
		},
	}

	operation, err := client.AsyncBatchAnnotateFiles(ctx, request)
	if err != nil {
		return err
	}

	fmt.Fprintf(w, "Waiting for the operation to finish.")

	resp, err := operation.Wait(ctx)
	if err != nil {
		return err
	}

	fmt.Fprintf(w, "%v", resp)

	return nil
}

Java

Bevor Sie dieses Beispiel anwenden, folgen Sie der Anleitung für die Einrichtung von Java in der Vision API-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Java-Referenzdokumentation zur Vision API.

/**
 * Performs document text OCR with PDF/TIFF as source files on Google Cloud Storage.
 *
 * @param gcsSourcePath The path to the remote file on Google Cloud Storage to detect document
 *     text on.
 * @param gcsDestinationPath The path to the remote file on Google Cloud Storage to store the
 *     results on.
 * @throws Exception on errors while closing the client.
 */
public static void detectDocumentsGcs(String gcsSourcePath, String gcsDestinationPath)
    throws Exception {

  // Initialize client that will be used to send requests. This client only needs to be created
  // once, and can be reused for multiple requests. After completing all of your requests, call
  // the "close" method on the client to safely clean up any remaining background resources.
  try (ImageAnnotatorClient client = ImageAnnotatorClient.create()) {
    List<AsyncAnnotateFileRequest> requests = new ArrayList<>();

    // Set the GCS source path for the remote file.
    GcsSource gcsSource = GcsSource.newBuilder().setUri(gcsSourcePath).build();

    // Create the configuration with the specified MIME (Multipurpose Internet Mail Extensions)
    // types
    InputConfig inputConfig =
        InputConfig.newBuilder()
            .setMimeType(
                "application/pdf") // Supported MimeTypes: "application/pdf", "image/tiff"
            .setGcsSource(gcsSource)
            .build();

    // Set the GCS destination path for where to save the results.
    GcsDestination gcsDestination =
        GcsDestination.newBuilder().setUri(gcsDestinationPath).build();

    // Create the configuration for the System.output with the batch size.
    // The batch size sets how many pages should be grouped into each json System.output file.
    OutputConfig outputConfig =
        OutputConfig.newBuilder().setBatchSize(2).setGcsDestination(gcsDestination).build();

    // Select the Feature required by the vision API
    Feature feature = Feature.newBuilder().setType(Feature.Type.DOCUMENT_TEXT_DETECTION).build();

    // Build the OCR request
    AsyncAnnotateFileRequest request =
        AsyncAnnotateFileRequest.newBuilder()
            .addFeatures(feature)
            .setInputConfig(inputConfig)
            .setOutputConfig(outputConfig)
            .build();

    requests.add(request);

    // Perform the OCR request
    OperationFuture<AsyncBatchAnnotateFilesResponse, OperationMetadata> response =
        client.asyncBatchAnnotateFilesAsync(requests);

    System.out.println("Waiting for the operation to finish.");

    // Wait for the request to finish. (The result is not used, since the API saves the result to
    // the specified location on GCS.)
    List<AsyncAnnotateFileResponse> result =
        response.get(180, TimeUnit.SECONDS).getResponsesList();

    // Once the request has completed and the System.output has been
    // written to GCS, we can list all the System.output files.
    Storage storage = StorageOptions.getDefaultInstance().getService();

    // Get the destination location from the gcsDestinationPath
    Pattern pattern = Pattern.compile("gs://([^/]+)/(.+)");
    Matcher matcher = pattern.matcher(gcsDestinationPath);

    if (matcher.find()) {
      String bucketName = matcher.group(1);
      String prefix = matcher.group(2);

      // Get the list of objects with the given prefix from the GCS bucket
      Bucket bucket = storage.get(bucketName);
      com.google.api.gax.paging.Page<Blob> pageList = bucket.list(BlobListOption.prefix(prefix));

      Blob firstOutputFile = null;

      // List objects with the given prefix.
      System.out.println("Output files:");
      for (Blob blob : pageList.iterateAll()) {
        System.out.println(blob.getName());

        // Process the first System.output file from GCS.
        // Since we specified batch size = 2, the first response contains
        // the first two pages of the input file.
        if (firstOutputFile == null) {
          firstOutputFile = blob;
        }
      }

      // Get the contents of the file and convert the JSON contents to an AnnotateFileResponse
      // object. If the Blob is small read all its content in one request
      // (Note: the file is a .json file)
      // Storage guide: https://cloud.google.com/storage/docs/downloading-objects
      String jsonContents = new String(firstOutputFile.getContent());
      Builder builder = AnnotateFileResponse.newBuilder();
      JsonFormat.parser().merge(jsonContents, builder);

      // Build the AnnotateFileResponse object
      AnnotateFileResponse annotateFileResponse = builder.build();

      // Parse through the object to get the actual response for the first page of the input file.
      AnnotateImageResponse annotateImageResponse = annotateFileResponse.getResponses(0);

      // Here we print the full text from the first page.
      // The response contains more information:
      // annotation/pages/blocks/paragraphs/words/symbols
      // including confidence score and bounding boxes
      System.out.format("%nText: %s%n", annotateImageResponse.getFullTextAnnotation().getText());
    } else {
      System.out.println("No MATCH");
    }
  }
}

Node.js

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Node.js-Einrichtungsanleitung in der Vision-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Vision-Referenzdokumentation zur Node.js API.

Richten Sie zur Authentifizierung bei Vision die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 


// Imports the Google Cloud client libraries
const vision = require('@google-cloud/vision').v1;

// Creates a client
const client = new vision.ImageAnnotatorClient();

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// Bucket where the file resides
// const bucketName = 'my-bucket';
// Path to PDF file within bucket
// const fileName = 'path/to/document.pdf';
// The folder to store the results
// const outputPrefix = 'results'

const gcsSourceUri = `gs://${bucketName}/${fileName}`;
const gcsDestinationUri = `gs://${bucketName}/${outputPrefix}/`;

const inputConfig = {
  // Supported mime_types are: 'application/pdf' and 'image/tiff'
  mimeType: 'application/pdf',
  gcsSource: {
    uri: gcsSourceUri,
  },
};
const outputConfig = {
  gcsDestination: {
    uri: gcsDestinationUri,
  },
};
const features = [{type: 'DOCUMENT_TEXT_DETECTION'}];
const request = {
  requests: [
    {
      inputConfig: inputConfig,
      features: features,
      outputConfig: outputConfig,
    },
  ],
};

const [operation] = await client.asyncBatchAnnotateFiles(request);
const [filesResponse] = await operation.promise();
const destinationUri =
  filesResponse.responses[0].outputConfig.gcsDestination.uri;
console.log('Json saved to: ' + destinationUri);

Python

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Python-Einrichtungsanleitung in der Vision-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Vision-Referenzdokumentation zur Python API.

Richten Sie zur Authentifizierung bei Vision die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 

def async_detect_document(gcs_source_uri, gcs_destination_uri):
    """OCR with PDF/TIFF as source files on GCS"""
    import json
    import re
    from google.cloud import vision
    from google.cloud import storage

    # Supported mime_types are: 'application/pdf' and 'image/tiff'
    mime_type = "application/pdf"

    # How many pages should be grouped into each json output file.
    batch_size = 2

    client = vision.ImageAnnotatorClient()

    feature = vision.Feature(type_=vision.Feature.Type.DOCUMENT_TEXT_DETECTION)

    gcs_source = vision.GcsSource(uri=gcs_source_uri)
    input_config = vision.InputConfig(gcs_source=gcs_source, mime_type=mime_type)

    gcs_destination = vision.GcsDestination(uri=gcs_destination_uri)
    output_config = vision.OutputConfig(
        gcs_destination=gcs_destination, batch_size=batch_size
    )

    async_request = vision.AsyncAnnotateFileRequest(
        features=[feature], input_config=input_config, output_config=output_config
    )

    operation = client.async_batch_annotate_files(requests=[async_request])

    print("Waiting for the operation to finish.")
    operation.result(timeout=420)

    # Once the request has completed and the output has been
    # written to GCS, we can list all the output files.
    storage_client = storage.Client()

    match = re.match(r"gs://([^/]+)/(.+)", gcs_destination_uri)
    bucket_name = match.group(1)
    prefix = match.group(2)

    bucket = storage_client.get_bucket(bucket_name)

    # List objects with the given prefix, filtering out folders.
    blob_list = [
        blob
        for blob in list(bucket.list_blobs(prefix=prefix))
        if not blob.name.endswith("/")
    ]
    print("Output files:")
    for blob in blob_list:
        print(blob.name)

    # Process the first output file from GCS.
    # Since we specified batch_size=2, the first response contains
    # the first two pages of the input file.
    output = blob_list[0]

    json_string = output.download_as_bytes().decode("utf-8")
    response = json.loads(json_string)

    # The actual response for the first page of the input file.
    first_page_response = response["responses"][0]
    annotation = first_page_response["fullTextAnnotation"]

    # Here we print the full text from the first page.
    # The response contains more information:
    # annotation/pages/blocks/paragraphs/words/symbols
    # including confidence scores and bounding boxes
    print("Full text:\n")
    print(annotation["text"])

gcloud

Der verwendete gcloud-Befehl hängt vom Dateityp ab.

  • Verwenden Sie für die PDF-Texterkennung den Befehl gcloud ml vision detect-text-pdf, wie im folgenden Beispiel gezeigt:

    gcloud ml vision detect-text-pdf gs://my_bucket/input_file  gs://my_bucket/out_put_prefix

  • Verwenden Sie für die TIFF-Texterkennung den Befehl gcloud ml vision detect-text-tiff, wie im folgenden Beispiel gezeigt:

    gcloud ml vision detect-text-tiff gs://my_bucket/input_file  gs://my_bucket/out_put_prefix

Weitere Sprachen

C#: Folgen Sie der Anleitung zur Einrichtung von C# auf der Seite der Clientbibliotheken und rufen Sie dann die Vision-Referenzdokumentation für .NET auf.

PHP: Folgen Sie der Anleitung zur Einrichtung von PHP auf der Seite der Clientbibliotheken und rufen Sie dann die Vision-Referenzdokumentation für PHP auf.

Ruby: Folgen Sie der Anleitung zur Einrichtung von Ruby auf der Seite der Clientbibliotheken und rufen Sie dann die Vision-Referenzdokumentation für Ruby auf.

Unterstützung für mehrere Regionen

Sie können jetzt Datenspeicher- und OCR-Verarbeitung auf Kontinentenebene festlegen. Folgende Regionen werden derzeit unterstützt:

  • us: Nur Festland-USA
  • eu: Die Europäischen Union

Orte

In Cloud Vision können Sie steuern, wo die Ressourcen für Ihr Projekt gespeichert und verarbeitet werden. Insbesondere können Sie Cloud Vision so konfigurieren, dass Ihre Daten nur in der Europäischen Union gespeichert und verarbeitet werden.

Standardmäßig speichert und verarbeitet Cloud Vision Ressourcen an einem globalen Standort. Das bedeutet, dass Cloud Vision nicht garantiert, dass Ihre Ressourcen an einem bestimmten Standort oder in einer bestimmten Region verbleiben. Wenn Sie den Standort Europäische Union auswählen, speichert Google Ihre Daten und verarbeitet sie nur in der Europäischen Union. Sie und Ihre Nutzer können von jedem Standort aus auf die Daten zugreifen.

Standort mithilfe der API festlegen

Die Vision API unterstützt einen globalen API-Endpunkt (vision.googleapis.com) sowie zwei regionsbasierte Endpunkte: einen EU-Endpunkt (eu-vision.googleapis.com) und einen US-Endpunkt (us-vision.googleapis.com). Verwenden Sie diese Endpunkte für die regionsspezifische Verarbeitung. Wenn Sie Ihre Daten beispielsweise nur in der Europäischen Union speichern und verarbeiten möchten, verwenden Sie für REST API-Aufrufe den URI eu-vision.googleapis.com anstelle von vision.googleapis.com:

  • https://eu-vision.googleapis.com/v1/projects/PROJECT_ID/locations/eu/images:annotate
  • https://eu-vision.googleapis.com/v1/projects/PROJECT_ID/locations/eu/images:asyncBatchAnnotate
  • https://eu-vision.googleapis.com/v1/projects/PROJECT_ID/locations/eu/files:annotate
  • https://eu-vision.googleapis.com/v1/projects/PROJECT_ID/locations/eu/files:asyncBatchAnnotate

Wenn Sie Ihre Daten nur in den USA speichern und verarbeiten möchten, verwenden Sie bei den vorherigen Methoden den US-Endpunkt (us-vision.googleapis.com).

Standort mithilfe von Clientbibliotheken festlegen

Die Vision API-Clientbibliotheken greifen standardmäßig auf den globalen API-Endpunkt (vision.googleapis.com) zu. Wenn Sie Ihre Daten nur in der Europäischen Union speichern und verarbeiten möchten, müssen Sie den Endpunkt (eu-vision.googleapis.com) explizit festlegen. Die folgenden Codebeispiele zeigen, wie diese Einstellung konfiguriert wird.

REST

Ersetzen Sie dabei folgende Werte für die Anfragedaten:

  • REGION_ID: eine der gültigen regionalen Standort-IDs:
    • us: Nur Festland-USA
    • eu: Die Europäischen Union
  • CLOUD_STORAGE_IMAGE_URI: Der Pfad zu einer gültigen Bilddatei in einem Cloud Storage-Bucket. Sie müssen zumindest Leseberechtigungen für die Datei haben. Beispiel: 
    • gs://cloud-samples-data/vision/pdf_tiff/census2010.pdf
  • CLOUD_STORAGE_BUCKET: ein Google Cloud Storage-Bucket/-Verzeichnis, in dem Ausgabedateien gespeichert werden. Dies wird in folgender Form angegeben:
    • gs://bucket/directory/
    Der anfragende Nutzer muss Schreibberechtigung für den Bucket haben.
  • FEATURE_TYPE: ein gültiger Featuretyp. Für files:asyncBatchAnnotate-Anfragen können Sie die folgenden Featuretypen verwenden:
    • DOCUMENT_TEXT_DETECTION
    • TEXT_DETECTION
  • PROJECT_ID: Ihre Google Cloud-Projekt-ID.

Feldspezifische Hinweise:

  • inputConfig ersetzt das Feld image, das in anderen Vision API-Anfragen verwendet wird. Es enthält zwei untergeordnete Felder:
    • gcsSource.uri ist der Google Cloud Storage-URI der PDF- oder TIFF-Datei (zugänglich für den Nutzer oder das Dienstkonto, von dem die Anfrage stammt).
    • mimeType ist einer der akzeptierten Dateitypen: application/pdf oder image/tiff.
  • outputConfig gibt Ausgabedetails an. Es enthält zwei untergeordnete Felder:
    • gcsDestination.uri ist ein gültiger Google Cloud Storage-URI. Der Nutzer oder das Dienstkonto, von dem die Anfrage gesendet wird, muss Schreibrechte für den Bucket haben. Der Dateiname ist output-x-to-y, wobei x und y für die Anzahl der PDF/TIFF-Seiten stehen, die in dieser Ausgabedatei enthalten sind. Wenn die Datei vorhanden ist, wird ihr Inhalt überschrieben.
    • batchSize gibt an, wie viele Ausgabeseiten in jeder JSON-Ausgabedatei enthalten sein sollen.

HTTP-Methode und URL:

POST https://REGION_ID-vision.googleapis.com/v1/projects/PROJECT_ID/locations/REGION_ID/files:asyncBatchAnnotate

JSON-Text der Anfrage:

{
  "requests":[
    {
      "inputConfig": {
        "gcsSource": {
          "uri": "CLOUD_STORAGE_IMAGE_URI"
        },
        "mimeType": "application/pdf"
      },
      "features": [
        {
          "type": "FEATURE_TYPE"
        }
      ],
      "outputConfig": {
        "gcsDestination": {
          "uri": "CLOUD_STORAGE_BUCKET"
        },
        "batchSize": 1
      }
    }
  ]
}

Wenn Sie die Anfrage senden möchten, wählen Sie eine der folgenden Optionen aus:

curl

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus: 

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "x-goog-user-project: PROJECT_ID" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://REGION_ID-vision.googleapis.com/v1/projects/PROJECT_ID/locations/REGION_ID/files:asyncBatchAnnotate"

PowerShell

Speichern Sie den Anfragetext in einer Datei mit dem Namen request.json und führen Sie den folgenden Befehl aus: 

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred"; "x-goog-user-project" = "PROJECT_ID" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://REGION_ID-vision.googleapis.com/v1/projects/PROJECT_ID/locations/REGION_ID/files:asyncBatchAnnotate" | Select-Object -Expand Content
Antwort

Eine erfolgreiche asyncBatchAnnotate-Anfrage gibt als Antwort ein einzelnes Namensfeld zurück:

{
  "name": "projects/usable-auth-library/operations/1efec2285bd442df"
}

Dieser Name stellt einen Vorgang mit langer Ausführungszeit mit einer verknüpften ID dar (z. B. 1efec2285bd442df), die mit der v1.operations API abgefragt werden kann.

Sie können die Antwort mit den Vision-Annotationen abrufen. Dazu senden Sie eine GET-Anfrage an den Endpunkt v1.operations und übergeben in der URL die Vorgangs-ID:

GET https://vision.googleapis.com/v1/operations/operation-id

Beispiel:

curl -X GET -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
-H "Content-Type: application/json" \
https://vision.googleapis.com/v1/projects/project-id/locations/location-id/operations/1efec2285bd442df

Wenn der Vorgang läuft:

{
  "name": "operations/1efec2285bd442df",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.vision.v1.OperationMetadata",
    "state": "RUNNING",
    "createTime": "2019-05-15T21:10:08.401917049Z",
    "updateTime": "2019-05-15T21:10:33.700763554Z"
  }
}

Sobald der Vorgang abgeschlossen ist, wird der state als DONE angezeigt und Ihre Ergebnisse werden in die von Ihnen angegebene Google Cloud Storage-Datei geschrieben:

{
  "name": "operations/1efec2285bd442df",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.vision.v1.OperationMetadata",
    "state": "DONE",
    "createTime": "2019-05-15T20:56:30.622473785Z",
    "updateTime": "2019-05-15T20:56:41.666379749Z"
  },
  "done": true,
  "response": {
    "@type": "type.googleapis.com/google.cloud.vision.v1.AsyncBatchAnnotateFilesResponse",
    "responses": [
      {
        "outputConfig": {
          "gcsDestination": {
            "uri": "gs://your-bucket-name/folder/"
          },
          "batchSize": 1
        }
      }
    ]
  }
}

Die JSON-Datei in Ihrer Ausgabedatei ähnelt der Antwort zur Dokumenttexterkennung für ein Bild, wenn Sie die DOCUMENT_TEXT_DETECTION-Funktion verwendet haben oder der Antwort zur Texterkennung, wenn Sie die TEXT_DETECTION-Funktion verwendet haben. Die Ausgabe enthält ein zusätzliches context-Feld, das den Speicherort der angegebenen PDF- oder TIFF-Datei sowie die Anzahl der Seiten in der Datei angibt:

output-1-to-1.json

Go

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Go-Einrichtungsanleitung in der Vision-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Vision-Referenzdokumentation zur Go API.

Richten Sie zur Authentifizierung bei Vision die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 

import (
	"context"
	"fmt"

	vision "cloud.google.com/go/vision/apiv1"
	"google.golang.org/api/option"
)

// setEndpoint changes your endpoint.
func setEndpoint(endpoint string) error {
	// endpoint := "eu-vision.googleapis.com:443"

	ctx := context.Background()
	client, err := vision.NewImageAnnotatorClient(ctx, option.WithEndpoint(endpoint))
	if err != nil {
		return fmt.Errorf("NewImageAnnotatorClient: %w", err)
	}
	defer client.Close()

	return nil
}

Java

Bevor Sie dieses Beispiel anwenden, folgen Sie der Anleitung für die Einrichtung von Java in der Vision API-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Java-Referenzdokumentation zur Vision API.

ImageAnnotatorSettings settings =
    ImageAnnotatorSettings.newBuilder().setEndpoint("eu-vision.googleapis.com:443").build();

// Initialize client that will be used to send requests. This client only needs to be created
// once, and can be reused for multiple requests. After completing all of your requests, call
// the "close" method on the client to safely clean up any remaining background resources.
ImageAnnotatorClient client = ImageAnnotatorClient.create(settings);

Node.js

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Node.js-Einrichtungsanleitung in der Vision-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Vision-Referenzdokumentation zur Node.js API.

Richten Sie zur Authentifizierung bei Vision die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 

// Imports the Google Cloud client library
const vision = require('@google-cloud/vision');

async function setEndpoint() {
  // Specifies the location of the api endpoint
  const clientOptions = {apiEndpoint: 'eu-vision.googleapis.com'};

  // Creates a client
  const client = new vision.ImageAnnotatorClient(clientOptions);

  // Performs text detection on the image file
  const [result] = await client.textDetection('./resources/wakeupcat.jpg');
  const labels = result.textAnnotations;
  console.log('Text:');
  labels.forEach(label => console.log(label.description));
}
setEndpoint();

Python

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Python-Einrichtungsanleitung in der Vision-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Vision-Referenzdokumentation zur Python API.

Richten Sie zur Authentifizierung bei Vision die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 

from google.cloud import vision

client_options = {"api_endpoint": "eu-vision.googleapis.com"}

client = vision.ImageAnnotatorClient(client_options=client_options)

Überzeugen Sie sich selbst

Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie einfach ein Konto, um die Leistungsfähigkeit von Cloud Vision API in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.

Cloud Vision API kostenlos testen