ファイル内のテキストを検出する(PDF / TIFF)

Vision API では、Cloud Storage に保存されている PDF ファイルと TIFF ファイルのテキストを検出して転写できます。

PDF と TIFF からのドキュメント テキスト検出は、files:asyncBatchAnnotate 関数を使用してリクエストする必要があります。これにより、オフライン(非同期)リクエストが行われ、operations リソースでそのステータスを確認できるようになります。

PDF / TIFF リクエストからの出力は、指定した Cloud Storage バケットに作成された JSON ファイルに書き込まれます。

制限事項

Vision API は、2,000 ページまでの PDF/TIFF ファイルを受け入れます。これよりファイルが大きくなるとエラーが返されます。

認証

API キーは、files:asyncBatchAnnotate リクエストではサポートされていません。サービス アカウントによる認証の手順については、サービス アカウントの使用をご覧ください。

認証に使用するアカウントは、出力のために指定する Cloud Storage バケットへのアクセス権(roles/editor または roles/storage.objectCreator 以上の役割)が付与されている必要があります。

API キーを使用してオペレーションのステータスをクエリできます。手順については、API キーの使用をご覧ください。

ドキュメント テキスト検出リクエスト

現在のところ、PDF や TIFF ドキュメントの検出は Cloud Storage バケットに保存されているファイルに対してのみ実行できます。レスポンスの JSON ファイルも Cloud Storage バケットに保存されます。

2010 年米国国勢調査の PDF ページ
gs://cloud-samples-data/vision/pdf_tiff/census2010.pdf, ソース: 米国国勢調査局

REST とコマンドライン

後述のリクエストのデータを使用する前に、次のように置き換えます。

gs://cloud-samples-data/vision/pdf_tiff/census2010.pdf
  • cloud-storage-bucket: 次の形式で出力ファイルを保存する Cloud Storage バケット/ディレクトリ。
    • gs://bucket/directory/
    リクエスト元のユーザーには、バケットへの書き込み権限が必要です。
  • cloud-storage-file-uri: Cloud Storage バケット内の有効なファイル(PDF/TIFF)へのパス。少なくとも、ファイルに対する読み取り権限が必要です。例:
  • feature-type: 有効な特徴タイプ。files:asyncBatchAnnotate リクエストには、次の特徴タイプを使用できます。
    • DOCUMENT_TEXT_DETECTION
    • TEXT_DETECTION

フィールド固有の考慮事項:

  • inputConfig は、他の Vision API リクエストで使用される image フィールドの代わりです。これには、次の 2 つの子フィールドが含まれます。
    • gcsSource.uri - PDF または TIFF ファイルの Google Cloud Storage URI(リクエストを行うユーザーまたはサービス アカウントがアクセス可能な URI)。
    • mimeType - 使用可能なファイルタイプのいずれか(application/pdf または image/tiff)。
  • outputConfig は、出力の詳細を指定します。これには、次の 2 つの子フィールドが含まれます。
    • gcsDestination.uri - 有効な Google Cloud Storage URI。バケットは、リクエストを行うユーザーまたはサービス アカウントによって書き込み可能である必要があります。ファイル名は output-x-to-y です。ここで、xy は出力ファイルに含まれる PDF / TIFF のページ番号です。ファイルが存在する場合、その内容は上書きされます。
    • batchSize - それぞれの JSON 出力ファイルに含める出力ページ数を指定します。

HTTP メソッドと URL:

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

JSON 本文のリクエスト:

{
  "requests":[
    {
      "inputConfig": {
        "gcsSource": {
          "uri": "cloud-storage-file-uri"
        },
        "mimeType": "application/pdf"
      },
      "features": [
        {
          "type": "feature-type"
        }
      ],
      "outputConfig": {
        "gcsDestination": {
          "uri": "cloud-storage-bucket"
        },
        "batchSize": 1
      }
    }
  ]
}

リクエストを送信するには、次のいずれかのオプションを選択します。

curl

リクエスト本文を request.json という名前のファイルに保存して、次のコマンドを実行します。

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

PowerShell

リクエスト本文を request.json という名前のファイルに保存して、次のコマンドを実行します。

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

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
レスポンス:

asyncBatchAnnotate リクエストに成功すると、次のような name フィールドのみを含むレスポンスが返されます。

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

この name は関連 ID(例: 1efec2285bd442df)を持つ長時間実行オペレーションの名前です。この名前は、v1.operations API を使用してクエリできます。

Vision のアノテーション レスポンスを取得するには、v1.operations エンドポイントに GET リクエストを送信し、URL でオペレーション ID を渡します。

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

例:

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

オペレーションが進行中の場合:

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

オペレーションが完了すると、stateDONE となり、指定した Google Cloud Storage ファイルに結果が書き込まれます。

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

出力ファイル内の JSON は、画像の [ドキュメント テキスト検出リクエスト](/vision/docs/ocr) の JSON と似ていますが、指定された PDF または TIFF の場所とファイルのページ数を示す context フィールドが追加されています。

output-1-to-1.json

C#

このサンプルを試す前に、Vision クイックスタート: クライアント ライブラリの使用にある C# の設定手順を行ってください。詳細については、Vision C# API のリファレンス ドキュメントをご覧ください。

private static object DetectDocument(string gcsSourceUri,
    string gcsDestinationBucketName, string gcsDestinationPrefixName)
{
    var client = ImageAnnotatorClient.Create();

    var asyncRequest = new AsyncAnnotateFileRequest
    {
        InputConfig = new InputConfig
        {
            GcsSource = new GcsSource
            {
                Uri = gcsSourceUri
            },
            // Supported mime_types are: 'application/pdf' and 'image/tiff'
            MimeType = "application/pdf"
        },
        OutputConfig = new OutputConfig
        {
            // How many pages should be grouped into each json output file.
            BatchSize = 2,
            GcsDestination = new GcsDestination
            {
                Uri = $"gs://{gcsDestinationBucketName}/{gcsDestinationPrefixName}"
            }
        }
    };

    asyncRequest.Features.Add(new Feature
    {
        Type = Feature.Types.Type.DocumentTextDetection
    });

    List<AsyncAnnotateFileRequest> requests =
        new List<AsyncAnnotateFileRequest>();
    requests.Add(asyncRequest);

    var operation = client.AsyncBatchAnnotateFiles(requests);

    Console.WriteLine("Waiting for the operation to finish");

    operation.PollUntilCompleted();

    // Once the rquest has completed and the output has been
    // written to GCS, we can list all the output files.
    var storageClient = StorageClient.Create();

    // List objects with the given prefix.
    var blobList = storageClient.ListObjects(gcsDestinationBucketName,
        gcsDestinationPrefixName);
    Console.WriteLine("Output files:");
    foreach (var blob in blobList)
    {
        Console.WriteLine(blob.Name);
    }

    // Process the first output file from GCS.
    // Select the first JSON file from the objects in the list.
    var output = blobList.Where(x => x.Name.Contains(".json")).First();

    var jsonString = "";
    using (var stream = new MemoryStream())
    {
        storageClient.DownloadObject(output, stream);
        jsonString = System.Text.Encoding.UTF8.GetString(stream.ToArray());
    }

    var response = JsonParser.Default
                .Parse<AnnotateFileResponse>(jsonString);

    // The actual response for the first page of the input file.
    var firstPageResponses = response.Responses[0];
    var annotation = firstPageResponses.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
    Console.WriteLine($"Full text: \n {annotation.Text}");

    return 0;
}

Go

このサンプルを試す前に、Vision クイックスタート: クライアント ライブラリの使用にある Go の設定手順を行ってください。詳細については、Vision Go API のリファレンス ドキュメントをご覧ください。


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

このサンプルを試す前に、Vision API クイックスタート: クライアント ライブラリの使用の Java の設定手順に従ってください。詳細については、Vision API Java 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

このサンプルを試す前に、Vision クイックスタート: クライアント ライブラリの使用にある Node.js の設定手順を行ってください。詳細については、Vision Node.js API のリファレンス ドキュメントをご覧ください。


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

PHP

このサンプルを試す前に、Vision クイックスタート: クライアント ライブラリの使用にある PHP の設定手順を行ってください。詳細については、Vision PHP API のリファレンス ドキュメントをご覧ください。

namespace Google\Cloud\Samples\Vision;

use Google\Cloud\Storage\StorageClient;
use Google\Cloud\Vision\V1\AnnotateFileResponse;
use Google\Cloud\Vision\V1\AsyncAnnotateFileRequest;
use Google\Cloud\Vision\V1\Feature;
use Google\Cloud\Vision\V1\Feature\Type;
use Google\Cloud\Vision\V1\GcsDestination;
use Google\Cloud\Vision\V1\GcsSource;
use Google\Cloud\Vision\V1\ImageAnnotatorClient;
use Google\Cloud\Vision\V1\InputConfig;
use Google\Cloud\Vision\V1\OutputConfig;

// $path = 'gs://path/to/your/document.pdf'
// $output = 'gs://path/to/store/results/'

function detect_pdf_gcs($path, $output)
{
    # select ocr feature
    $feature = (new Feature())
        ->setType(Type::DOCUMENT_TEXT_DETECTION);

    # set $path (file to OCR) as source
    $gcsSource = (new GcsSource())
        ->setUri($path);
    # supported mime_types are: 'application/pdf' and 'image/tiff'
    $mimeType = 'application/pdf';
    $inputConfig = (new InputConfig())
        ->setGcsSource($gcsSource)
        ->setMimeType($mimeType);

    # set $output as destination
    $gcsDestination = (new GcsDestination())
        ->setUri($output);
    # how many pages should be grouped into each json output file.
    $batchSize = 2;
    $outputConfig = (new OutputConfig())
        ->setGcsDestination($gcsDestination)
        ->setBatchSize($batchSize);

    # prepare request using configs set above
    $request = (new AsyncAnnotateFileRequest())
        ->setFeatures([$feature])
        ->setInputConfig($inputConfig)
        ->setOutputConfig($outputConfig);
    $requests = [$request];

    # make request
    $imageAnnotator = new ImageAnnotatorClient();
    $operation = $imageAnnotator->asyncBatchAnnotateFiles($requests);
    print('Waiting for operation to finish.' . PHP_EOL);
    $operation->pollUntilComplete();

    # once the request has completed and the output has been
    # written to GCS, we can list all the output files.
    preg_match('/^gs:\/\/([a-zA-Z0-9\._\-]+)\/?(\S+)?$/', $output, $match);
    $bucketName = $match[1];
    $prefix = isset($match[2]) ? $match[2] : '';

    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $options = ['prefix' => $prefix];
    $objects = $bucket->objects($options);

    # save first object for sample below
    $objects->next();
    $firstObject = $objects->current();

    # list objects with the given prefix.
    print('Output files:' . PHP_EOL);
    foreach ($objects as $object) {
        print($object->name() . PHP_EOL);
    }

    # 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.
    $jsonString = $firstObject->downloadAsString();
    $firstBatch = new AnnotateFileResponse();
    $firstBatch->mergeFromJsonString($jsonString);

    # get annotation and print text
    foreach ($firstBatch->getResponses() as $response) {
        $annotation = $response->getFullTextAnnotation();
        print($annotation->getText());
    }

    $imageAnnotator->close();
}

Python

このサンプルを試す前に、Vision クイックスタート: クライアント ライブラリの使用にある Python の設定手順を行ってください。詳細については、Vision Python API のリファレンス ドキュメントをご覧ください。

def async_detect_document(gcs_source_uri, gcs_destination_uri):
    """OCR with PDF/TIFF as source files on GCS"""
    import re
    from google.cloud import vision
    from google.cloud import storage
    from google.protobuf import json_format
    # 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.types.Feature(
        type=vision.enums.Feature.Type.DOCUMENT_TEXT_DETECTION)

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

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

    async_request = vision.types.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.
    blob_list = list(bucket.list_blobs(prefix=prefix))
    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_string()
    response = json_format.Parse(
        json_string, vision.types.AnnotateFileResponse())

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

    # 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(u'Full text:\n{}'.format(
        annotation.text))

Ruby

このサンプルを試す前に、Vision クイックスタート: クライアント ライブラリの使用にある Ruby の設定手順を行ってください。詳細については、Vision Ruby API のリファレンス ドキュメントをご覧ください。

# gcs_source_uri = "Google Cloud Storage URI, eg. 'gs://my-bucket/example.pdf'"
# gcs_destination_uri = "Google Cloud Storage URI, eg. 'gs://my-bucket/prefix_'"

require "google/cloud/vision"
require "google/cloud/storage"

image_annotator = Google::Cloud::Vision.image_annotator

operation = image_annotator.document_text_detection(
  image:       gcs_source_uri,
  mime_type:   "application/pdf",
  batch_size:  2,
  destination: gcs_destination_uri,
  async:       true
)

puts "Waiting for the operation to finish."
operation.wait_until_done!

# Once the request has completed and the output has been
# written to GCS, we can list all the output files.
storage = Google::Cloud::Storage.new

bucket_name, prefix = gcs_destination_uri.match("gs://([^/]+)/(.+)").captures
bucket              = storage.bucket bucket_name

# List objects with the given prefix.
puts "Output files:"
blob_list = bucket.files prefix: prefix
blob_list.each do |file|
  puts file.name
end

# Process the first output file from GCS.
# Since we specified a batch_size of 2, the first response contains
# the first two pages of the input file.
json_string = blob_list[0].download
response    = JSON.parse json_string.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
puts "Full text:\n#{annotation['text']}"

gcloud コマンド

使用する gcloud コマンドは、ファイル形式によって異なります。

  • PDF テキスト検出を行う場合は、次の例のように gcloud ml vision detect-text-pdf コマンドを実行します。

    gcloud ml vision detect-text-pdf gs://my_bucket/input_file  gs://my_bucket/out_put_prefix
    
  • TIFF テキスト検出を行うには、次の例のように gcloud ml vision detect-text-tiff コマンドを実行します。

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

マルチリージョンのサポート

大陸レベルでデータ ストレージと OCR 処理を指定できるようになりました。現在サポートされているリージョンは次のとおりです。

  • us: 米国のみ
  • eu: 欧州連合

ロケーション

Cloud Vision では、プロジェクトのリソースが保存、処理されるロケーションをある程度制御できます。特に、データを欧州連合でのみ保存して処理するように Cloud Vision を構成できます。

デフォルトでは、Cloud Vision はリソースをグローバル ロケーションに保存して処理します。つまり、Cloud Vision は、リソースが特定のロケーションやリージョンに留まることを保証しません。ロケーションとして欧州連合を選択した場合、欧州連合でのみデータが保存され、処理されます。ユーザーはどこからでもデータにアクセスできます。

API を使用してロケーションを設定する

Vision API は、グローバル API エンドポイント(vision.googleapis.com)と、2 つのリージョン ベースのエンドポイント(EU エンドポイント、eu-vision.googleapis.comと米国エンドポイント、us-vision.googleapis.com)をサポートしています。これらのエンドポイントはリージョン固有の処理に使用します。たとえば、EU でのみデータを保存して処理する場合は、REST API 呼び出しに vision.googleapis.com ではなく URI eu-vision.googleapis.com を使用します。

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

米国でのみデータを保存して処理する場合は、上記の方法で米国のエンドポイント(us-vision.googleapis.com)を使用します。

クライアント ライブラリを使用してロケーションを設定する

Vision API クライアント ライブラリは、デフォルトでグローバル API エンドポイント(vision.googleapis.com)にアクセスします。欧州連合でのみデータを保存して処理するには、エンドポイント(eu-vision.googleapis.com)を明示的に設定する必要があります。以下のサンプルコードは、この設定を構成する方法を示しています。

REST とコマンドライン

後述のリクエストのデータを使用する前に、次のように置き換えます。

gs://cloud-samples-data/vision/pdf_tiff/census2010.pdf
  • cloud-storage-image-uri: Cloud Storage バケット内の有効な画像ファイルへのパス。少なくとも、ファイルに対する読み取り権限が必要です。例:
    • gs://storage-bucket/filename.jpg
  • cloud-storage-bucket: 次の形式で出力ファイルを保存する Cloud Storage バケット/ディレクトリ。
    • gs://bucket/directory/
    リクエスト元のユーザーには、バケットへの書き込み権限が必要です。
  • feature-type: 有効な特徴タイプ。files:asyncBatchAnnotate リクエストには、次の特徴タイプを使用できます。
    • DOCUMENT_TEXT_DETECTION
    • TEXT_DETECTION

フィールド固有の考慮事項:

  • inputConfig は、他の Vision API リクエストで使用される image フィールドの代わりです。これには、次の 2 つの子フィールドが含まれます。
    • gcsSource.uri - PDF または TIFF ファイルの Google Cloud Storage URI(リクエストを行うユーザーまたはサービス アカウントがアクセス可能な URI)。
    • mimeType - 使用可能なファイルタイプのいずれか(application/pdf または image/tiff)。
  • outputConfig は、出力の詳細を指定します。これには、次の 2 つの子フィールドが含まれます。
    • gcsDestination.uri - 有効な Google Cloud Storage URI。バケットは、リクエストを行うユーザーまたはサービス アカウントによって書き込み可能である必要があります。ファイル名は output-x-to-y です。ここで、xy は出力ファイルに含まれる PDF / TIFF のページ番号です。ファイルが存在する場合、その内容は上書きされます。
    • batchSize - それぞれの JSON 出力ファイルに含める出力ページ数を指定します。

HTTP メソッドと URL:

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

JSON 本文のリクエスト:

{
  "requests":[
    {
      "inputConfig": {
        "gcsSource": {
          "uri": "cloud-storage-image-uri"
        },
        "mimeType": "application/pdf"
      },
      "features": [
        {
          "type": "feature-type"
        }
      ],
      "outputConfig": {
        "gcsDestination": {
          "uri": "cloud-storage-bucket"
        },
        "batchSize": 1
      }
    }
  ]
}

リクエストを送信するには、次のいずれかのオプションを選択します。

curl

リクエスト本文を request.json という名前のファイルに保存して、次のコマンドを実行します。

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

PowerShell

リクエスト本文を request.json という名前のファイルに保存して、次のコマンドを実行します。

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

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

asyncBatchAnnotate リクエストに成功すると、次のような name フィールドのみを含むレスポンスが返されます。

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

この name は関連 ID(例: 1efec2285bd442df)を持つ長時間実行オペレーションの名前です。この名前は、v1.operations API を使用してクエリできます。

Vision のアノテーション レスポンスを取得するには、v1.operations エンドポイントに GET リクエストを送信し、URL でオペレーション ID を渡します。

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

例:

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

オペレーションが進行中の場合:

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

オペレーションが完了すると、stateDONE となり、指定した Google Cloud Storage ファイルに結果が書き込まれます。

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

DOCUMENT_TEXT_DETECTION 機能を使用した場合、出力ファイル内の JSON は画像のドキュメント テキスト検出レスポンスに似ています。TEXT_DETECTION 機能を使用した場合はテキスト検出レスポンスに似ています。出力には、指定された PDF または TIFF の場所とファイルのページ数を示す context フィールドが追加されています。

output-1-to-1.json

C#

// Instantiate a client connected to the 'eu' location.
var client = new ImageAnnotatorClientBuilder
{
    Endpoint = "eu-vision.googleapis.com"
}.Build();

Go

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: %v", err)
	}
	defer client.Close()

	return nil
}

Java

このサンプルを試す前に、Vision API クイックスタート: クライアント ライブラリの使用の Java の設定手順に従ってください。詳細については、Vision API Java 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

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

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

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

PHP

# set endpoint
$options = ['api_endpoint' => $endpoint];

$client = new ImageAnnotatorClient($options);

Python

from google.cloud import vision

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

client = vision.ImageAnnotatorClient(client_options=client_options)

Ruby

require "google/cloud/vision"

# Specifies the location of the api endpoint
image_annotator = Google::Cloud::Vision.image_annotator do |config|
  config.endpoint = "eu-vision.googleapis.com"
end