Rilevamento del testo nei file (PDF/TIFF)

REST

Prima di utilizzare i dati della richiesta, apporta le sostituzioni seguenti:

• CLOUD_STORAGE_BUCKET: un bucket/una directory Cloud Storage in cui salvare i file di output, espresso nel seguente formato:
  • gs://bucket/directory/
  L'utente che effettua la richiesta deve disporre dell'autorizzazione di scrittura per il bucket.
• CLOUD_STORAGE_FILE_URI: il percorso di un file valido (PDF/TIFF) in un bucket Cloud Storage. Devi disporre almeno dei privilegi di lettura per il file. Esempio:
  • gs://cloud-samples-data/vision/pdf_tiff/census2010.pdf

• FEATURE_TYPE: Un tipo di funzionalità valido. Per le richieste files:asyncBatchAnnotate puoi utilizzare i seguenti tipi di funzionalità:
  • DOCUMENT_TEXT_DETECTION
  • TEXT_DETECTION
• PROJECT_ID: l'ID progetto Google Cloud .

Considerazioni specifiche per i campi:

• inputConfig: sostituisce il campo image utilizzato in altre richieste dell'API Vision. Contiene due campi secondari:
  • gcsSource.uri: l'URI Google Cloud Storage del file PDF o TIFF (accessibile all'utente o al account di servizio che effettua la richiesta).
  • mimeType, uno dei tipi di file accettati: application/pdf o image/tiff.
• outputConfig: specifica i dettagli dell'output. Contiene due campi secondari:
  • gcsDestination.uri: un URI Google Cloud Storage valido. Il bucket deve essere scrivibile dall'utente o dal account di servizio che effettua la richiesta. Il nome file sarà output-x-to-y, dove x e y rappresentano i numeri di pagina PDF/TIFF inclusi nel file di output. Se il file esiste, i relativi contenuti verranno sovrascritti.
  • batchSize: specifica il numero di pagine di output da includere in ogni file JSON di output.

Metodo HTTP e URL:

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

Corpo JSON della richiesta:

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

Per inviare la richiesta, scegli una di queste opzioni:

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"

$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

Una richiesta asyncBatchAnnotate andata a buon fine restituisce una risposta con un singolo campo nome:

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

Questo nome rappresenta un'operazione a lunga esecuzione con un ID associato (ad esempio, 1efec2285bd442df), che può essere interrogata utilizzando l'API v1.operations.

Per recuperare la risposta dell'annotazione Vision, invia una richiesta GET all'endpoint v1.operations, passando l'ID operazione nell'URL:

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

Ad esempio:

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

Se l'operazione è in corso:

{
  "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"
  }
}

Una volta completata l'operazione, state viene visualizzato come DONE e i risultati vengono scritti nel file Google Cloud Storage specificato:

{
  "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
        }
      }
    ]
  }
}

Il JSON nel file di output è simile a quello di una richiesta di rilevamento del testo del documento di un'immagine, con l'aggiunta di un campo context che mostra la posizione del PDF o del TIFF specificato e il numero di pagine del file:

Go

Prima di provare questo esempio, segui le istruzioni di configurazione di Go nella guida rapida di Vision per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Vision Go.

Per eseguire l'autenticazione in Vision, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

// 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

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida dell'API Vision che utilizza le librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Vision per Java.

/**
 * 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)