画像内のテキストを検出する

モデルの更新: TEXT_DETECTION モデルと DOCUMENT_TEXT_DETECTION モデルが新しいバージョンにアップグレードされました（2020 年 5 月 15 日に有効）。結果にレガシーモデルを使用するには、Feature オブジェクトの model フィールドに "builtin/legacy_20190601" を指定して、古いモデル結果を取得します。2020 年 11 月 15 日以降、古いモデルは提供されなくなります。詳細については、2020 年 5 月 15 日と2020 年 6 月 11 日のリリースノートをご覧ください。

光学式文字認識（OCR）

Vision API では、画像からテキストを検出、抽出できます。光学式文字認識（OCR）をサポートするアノテーション機能が 2 つあります。

TEXT_DETECTION は、任意の画像からテキストを検出、抽出します。たとえば、写真に道路名や交通標識が写っていれば、抽出された文字列全体、個々の単語、それらの境界ボックスが JSON レスポンスに含まれます。
DOCUMENT_TEXT_DETECTION も画像からテキストを抽出しますが、高密度のテキストやドキュメントに応じてレスポンスが最適化され、ページ、ブロック、段落、単語、改行の情報が JSON に含まれます。

手書き入力の抽出とファイル（PDF / TIFF）からのテキスト抽出については、DOCUMENT_TEXT_DETECTION をご覧ください。

ぜひお試しください。

Google Cloud を初めて使用される方は、アカウントを作成して、実際のシナリオでの Vision API のパフォーマンスを評価してください。新規のお客様には、ワークロードの実行、テスト、デプロイに使える無料クレジット $300 分も差し上げます。

Vision API の無料トライアル

テキスト検出のリクエスト

GCP プロジェクトと認証の設定

Google Cloud Platform（GCP）プロジェクトとサービスアカウント認証情報を作成していない場合は、ここで作成します。手順については、このセクションを展開してください。

Google アカウントにログインします。
Google アカウントをまだお持ちでない場合は、新しいアカウントを登録します。

Cloud Console プロジェクトを設定する
プロジェクトの設定
クリックして、以下を行います。
- プロジェクトを作成または選択します。
- プロジェクトに対して Vision API を有効にします。
- サービスアカウントを作成します。
- JSON として秘密鍵をダウンロードします。
これらのリソースは、いつでも Cloud Console で表示、管理できます。

環境変数 GOOGLE_APPLICATION_CREDENTIALS を、サービスアカウントキーが含まれる JSON ファイルのパスに設定します。この変数は現在のシェルセッションにのみ適用されるため、新しいセッションを開く場合は、変数を再度設定します。
例: Linux または macOS

[PATH] をサービスアカウントキーが含まれる JSON ファイルのパスに置き換えます。
```
export GOOGLE_APPLICATION_CREDENTIALS="[PATH]"
```
例:
```
export GOOGLE_APPLICATION_CREDENTIALS="/home/user/Downloads/service-account-file.json"
```
例: Windows

[PATH] をサービスアカウントキーが含まれる JSON ファイルのパスに置き換えます。

PowerShell を使用する場合:
```
$env:GOOGLE_APPLICATION_CREDENTIALS="[PATH]"
```
例:
```
$env:GOOGLE_APPLICATION_CREDENTIALS="C:\Users\username\Downloads\my-key.json"
```
コマンドプロンプトを使用する場合:
```
set GOOGLE_APPLICATION_CREDENTIALS=[PATH]
```

Cloud SDK をインストールして初期化します。

ローカル画像でテキストを検出する

Vision API は、リクエストの本文で画像ファイルのコンテンツを Base64 エンコードの文字列として送信し、ローカル画像ファイルの特徴検出を行います。

REST とコマンドライン

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

base64-encoded-image: バイナリ画像データの base64 表現（ASCII 文字列）。これは次のような文字列になります。
- /9j/4QAYRXhpZgAA...9tAVx/zDQDlGxn//2Q==
詳細については、base64 エンコードをご覧ください。

HTTP メソッドと URL:

POST https://vision.googleapis.com/v1/images:annotate

JSON 本文のリクエスト:

{
  "requests": [
    {
      "image": {
        "content": "base64-encoded-image"
      },
      "features": [
        {
          "type": "TEXT_DETECTION"
        }
      ]
    }
  ]
}

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

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/images:annotate

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/images:annotate" | Select-Object -Expand Content

リクエストが成功すると、サーバーは 200 OK HTTP ステータスコードと JSON 形式のレスポンスを返します。

TEXT_DETECTION レスポンスには、検出されたフレーズ、その境界ボックス、および個々の単語とその境界ボックスが含まれています。

レスポンス



    {
      "responses": [
        {
          "textAnnotations": [
            {
              "locale": "en",
              "description": "WAITING?\nPLEASE\nTURN OFF\nYOUR\nENGINE\n",
              "boundingPoly": {
                "vertices": [
                  {
                    "x": 341,
                    "y": 828
                  },
                  {
                    "x": 2249,
                    "y": 828
                  },
                  {
                    "x": 2249,
                    "y": 1993
                  },
                  {
                    "x": 341,
                    "y": 1993
                  }
                ]
              }
            },
            {
              "description": "WAITING?",
              "boundingPoly": {
                "vertices": [
                  {
                    "x": 352,
                    "y": 828
                  },
                  {
                    "x": 2248,
                    "y": 911
                  },
                  {
                    "x": 2238,
                    "y": 1148
                  },
                  {
                    "x": 342,
                    "y": 1065
                  }
                ]
              }
            },
            {
              "description": "PLEASE",
              "boundingPoly": {
                "vertices": [
                  {
                    "x": 1210,
                    "y": 1233
                  },
                  {
                    "x": 1907,
                    "y": 1263
                  },
                  {
                    "x": 1902,
                    "y": 1383
                  },
                  {
                    "x": 1205,
                    "y": 1353
                  }
                ]
              }
            },
            {
              "description": "TURN",
              "boundingPoly": {
                "vertices": [
                  {
                    "x": 1210,
                    "y": 1418
                  },
                  {
                    "x": 1730,
                    "y": 1441
                  },
                  {
                    "x": 1724,
                    "y": 1564
                  },
                  {
                    "x": 1205,
                    "y": 1541
                  }
                ]
              }
            },
            {
              "description": "OFF",
              "boundingPoly": {
                "vertices": [
                  {
                    "x": 1792,
                    "y": 1443
                  },
                  {
                    "x": 2128,
                    "y": 1458
                  },
                  {
                    "x": 2122,
                    "y": 1581
                  },
                  {
                    "x": 1787,
                    "y": 1566
                  }
                ]
              }
            },
            {
              "description": "YOUR",
              "boundingPoly": {
                "vertices": [
                  {
                    "x": 1219,
                    "y": 1603
                  },
                  {
                    "x": 1746,
                    "y": 1629
                  },
                  {
                    "x": 1740,
                    "y": 1759
                  },
                  {
                    "x": 1213,
                    "y": 1733
                  }
                ]
              }
            },
            {
              "description": "ENGINE",
              "boundingPoly": {
                "vertices": [
                  {
                    "x": 1222,
                    "y": 1771
                  },
                  {
                    "x": 1944,
                    "y": 1834
                  },
                  {
                    "x": 1930,
                    "y": 1992
                  },
                  {
                    "x": 1208,
                    "y": 1928
                  }
                ]
              }
            }
          ],
          "fullTextAnnotation": {
            "pages": [
                      ...
                      ]
                    },
                    "paragraphs": [
                          ...
                          ]
                        },
                        "words": [
                            ...
                            },
                            "symbols": [
                            ...
                          }
                        ]
                      }
                    ],
                    "blockType": "TEXT"
                  },
                  ...
                ]
              }
            ],
            "text": "WAITING?\nPLEASE\nTURN OFF\nYOUR\nENGINE\n"
          }
        }
      ]
    }

C#

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

GitHub で表示フィードバック

// Load an image from a local file.
var image = Image.FromFile(filePath);
var client = ImageAnnotatorClient.Create();
var response = client.DetectText(image);
foreach (var annotation in response)
{
    if (annotation.Description != null)
        Console.WriteLine(annotation.Description);
}

Go

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

GitHub で表示フィードバック


// detectText gets text from the Vision API for an image at the given file path.
func detectText(w io.Writer, file string) error {
	ctx := context.Background()

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

	f, err := os.Open(file)
	if err != nil {
		return err
	}
	defer f.Close()

	image, err := vision.NewImageFromReader(f)
	if err != nil {
		return err
	}
	annotations, err := client.DetectTexts(ctx, image, nil, 10)
	if err != nil {
		return err
	}

	if len(annotations) == 0 {
		fmt.Fprintln(w, "No text found.")
	} else {
		fmt.Fprintln(w, "Text:")
		for _, annotation := range annotations {
			fmt.Fprintf(w, "%q\n", annotation.Description)
		}
	}

	return nil
}

Java

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

GitHub で表示フィードバック


import com.google.cloud.vision.v1.AnnotateImageRequest;
import com.google.cloud.vision.v1.AnnotateImageResponse;
import com.google.cloud.vision.v1.BatchAnnotateImagesResponse;
import com.google.cloud.vision.v1.EntityAnnotation;
import com.google.cloud.vision.v1.Feature;
import com.google.cloud.vision.v1.Image;
import com.google.cloud.vision.v1.ImageAnnotatorClient;
import com.google.protobuf.ByteString;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class DetectText {
  public static void detectText() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String filePath = "path/to/your/image/file.jpg";
    detectText(filePath);
  }

  // Detects text in the specified image.
  public static void detectText(String filePath) throws IOException {
    List<AnnotateImageRequest> requests = new ArrayList<>();

    ByteString imgBytes = ByteString.readFrom(new FileInputStream(filePath));

    Image img = Image.newBuilder().setContent(imgBytes).build();
    Feature feat = Feature.newBuilder().setType(Feature.Type.TEXT_DETECTION).build();
    AnnotateImageRequest request =
        AnnotateImageRequest.newBuilder().addFeatures(feat).setImage(img).build();
    requests.add(request);

    // 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()) {
      BatchAnnotateImagesResponse response = client.batchAnnotateImages(requests);
      List<AnnotateImageResponse> responses = response.getResponsesList();

      for (AnnotateImageResponse res : responses) {
        if (res.hasError()) {
          System.out.format("Error: %s%n", res.getError().getMessage());
          return;
        }

        // For full list of available annotations, see http://g.co/cloud/vision/docs
        for (EntityAnnotation annotation : res.getTextAnnotationsList()) {
          System.out.format("Text: %s%n", annotation.getDescription());
          System.out.format("Position : %s%n", annotation.getBoundingPoly());
        }
      }
    }
  }
}

Node.js

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

GitHub で表示フィードバック

const vision = require('@google-cloud/vision');

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

/**
 * TODO(developer): Uncomment the following line before running the sample.
 */
// const fileName = 'Local image file, e.g. /path/to/image.png';

// Performs text detection on the local file
const [result] = await client.textDetection(fileName);
const detections = result.textAnnotations;
console.log('Text:');
detections.forEach(text => console.log(text));

PHP

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

GitHub で表示フィードバック

namespace Google\Cloud\Samples\Vision;

use Google\Cloud\Vision\V1\ImageAnnotatorClient;

// $path = 'path/to/your/image.jpg';

function detect_text($path)
{
    $imageAnnotator = new ImageAnnotatorClient();

    # annotate the image
    $image = file_get_contents($path);
    $response = $imageAnnotator->textDetection($image);
    $texts = $response->getTextAnnotations();

    printf('%d texts found:' . PHP_EOL, count($texts));
    foreach ($texts as $text) {
        print($text->getDescription() . PHP_EOL);

        # get bounds
        $vertices = $text->getBoundingPoly()->getVertices();
        $bounds = [];
        foreach ($vertices as $vertex) {
            $bounds[] = sprintf('(%d,%d)', $vertex->getX(), $vertex->getY());
        }
        print('Bounds: ' . join(', ', $bounds) . PHP_EOL);
    }

    $imageAnnotator->close();
}

Python

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

GitHub で表示フィードバック

def detect_text(path):
    """Detects text in the file."""
    from google.cloud import vision
    import io
    client = vision.ImageAnnotatorClient()

    with io.open(path, 'rb') as image_file:
        content = image_file.read()

    image = vision.Image(content=content)

    response = client.text_detection(image=image)
    texts = response.text_annotations
    print('Texts:')

    for text in texts:
        print('\n"{}"'.format(text.description))

        vertices = (['({},{})'.format(vertex.x, vertex.y)
                    for vertex in text.bounding_poly.vertices])

        print('bounds: {}'.format(','.join(vertices)))

    if response.error.message:
        raise Exception(
            '{}\nFor more info on error messages, check: '
            'https://cloud.google.com/apis/design/errors'.format(
                response.error.message))

Ruby

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

GitHub で表示フィードバック

# image_path = "Path to local image file, eg. './image.png'"

require "google/cloud/vision"

image_annotator = Google::Cloud::Vision.image_annotator

response = image_annotator.text_detection(
  image:       image_path,
  max_results: 1 # optional, defaults to 10
)

response.responses.each do |res|
  res.text_annotations.each do |text|
    puts text.description
  end
end

リモート画像でテキストを検出する

Vision API を使用すると、画像ファイルのコンテンツをリクエストの本文で送信することなく、Google Cloud Storage またはウェブ上にある画像ファイルに対して特徴検出を直接実行できます。

REST とコマンドライン

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

cloud-storage-image-uri: Cloud Storage バケット内の有効な画像ファイルへのパス。少なくとも、ファイルに対する読み取り権限が必要です。たとえば次のように指定します。
- ```
gs://cloud-samples-data/vision/ocr/sign.jpg
```

HTTP メソッドと URL:

POST https://vision.googleapis.com/v1/images:annotate

JSON 本文のリクエスト:

{
  "requests": [
    {
      "image": {
        "source": {
          "imageUri": "cloud-storage-image-uri"
        }
       },
       "features": [
         {
           "type": "TEXT_DETECTION"
         }
       ]
    }
  ]
}

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

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/images:annotate

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/images:annotate" | Select-Object -Expand Content

リクエストが成功すると、サーバーは 200 OK HTTP ステータスコードと JSON 形式のレスポンスを返します。

TEXT_DETECTION レスポンスには、検出されたフレーズ、その境界ボックス、および個々の単語とその境界ボックスが含まれています。

レスポンス



    {
      "responses": [
        {
          "textAnnotations": [
            {
              "locale": "en",
              "description": "WAITING?\nPLEASE\nTURN OFF\nYOUR\nENGINE\n",
              "boundingPoly": {
                "vertices": [
                  {
                    "x": 341,
                    "y": 828
                  },
                  {
                    "x": 2249,
                    "y": 828
                  },
                  {
                    "x": 2249,
                    "y": 1993
                  },
                  {
                    "x": 341,
                    "y": 1993
                  }
                ]
              }
            },
            {
              "description": "WAITING?",
              "boundingPoly": {
                "vertices": [
                  {
                    "x": 352,
                    "y": 828
                  },
                  {
                    "x": 2248,
                    "y": 911
                  },
                  {
                    "x": 2238,
                    "y": 1148
                  },
                  {
                    "x": 342,
                    "y": 1065
                  }
                ]
              }
            },
            {
              "description": "PLEASE",
              "boundingPoly": {
                "vertices": [
                  {
                    "x": 1210,
                    "y": 1233
                  },
                  {
                    "x": 1907,
                    "y": 1263
                  },
                  {
                    "x": 1902,
                    "y": 1383
                  },
                  {
                    "x": 1205,
                    "y": 1353
                  }
                ]
              }
            },
            {
              "description": "TURN",
              "boundingPoly": {
                "vertices": [
                  {
                    "x": 1210,
                    "y": 1418
                  },
                  {
                    "x": 1730,
                    "y": 1441
                  },
                  {
                    "x": 1724,
                    "y": 1564
                  },
                  {
                    "x": 1205,
                    "y": 1541
                  }
                ]
              }
            },
            {
              "description": "OFF",
              "boundingPoly": {
                "vertices": [
                  {
                    "x": 1792,
                    "y": 1443
                  },
                  {
                    "x": 2128,
                    "y": 1458
                  },
                  {
                    "x": 2122,
                    "y": 1581
                  },
                  {
                    "x": 1787,
                    "y": 1566
                  }
                ]
              }
            },
            {
              "description": "YOUR",
              "boundingPoly": {
                "vertices": [
                  {
                    "x": 1219,
                    "y": 1603
                  },
                  {
                    "x": 1746,
                    "y": 1629
                  },
                  {
                    "x": 1740,
                    "y": 1759
                  },
                  {
                    "x": 1213,
                    "y": 1733
                  }
                ]
              }
            },
            {
              "description": "ENGINE",
              "boundingPoly": {
                "vertices": [
                  {
                    "x": 1222,
                    "y": 1771
                  },
                  {
                    "x": 1944,
                    "y": 1834
                  },
                  {
                    "x": 1930,
                    "y": 1992
                  },
                  {
                    "x": 1208,
                    "y": 1928
                  }
                ]
              }
            }
          ],
          "fullTextAnnotation": {
            "pages": [
                      ...
                      ]
                    },
                    "paragraphs": [
                          ...
                          ]
                        },
                        "words": [
                            ...
                            },
                            "symbols": [
                            ...
                          }
                        ]
                      }
                    ],
                    "blockType": "TEXT"
                  },
                  ...
                ]
              }
            ],
            "text": "WAITING?\nPLEASE\nTURN OFF\nYOUR\nENGINE\n"
          }
        }
      ]
    }

C#

GitHub で表示フィードバック

// Specify a Google Cloud Storage uri for the image
// or a publicly accessible HTTP or HTTPS uri.
var image = Image.FromUri(uri);
var client = ImageAnnotatorClient.Create();
var response = client.DetectText(image);
foreach (var annotation in response)
{
    if (annotation.Description != null)
        Console.WriteLine(annotation.Description);
}

Go

GitHub で表示フィードバック


// detectText gets text from the Vision API for an image at the given file path.
func detectTextURI(w io.Writer, file string) error {
	ctx := context.Background()

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

	image := vision.NewImageFromURI(file)
	annotations, err := client.DetectTexts(ctx, image, nil, 10)
	if err != nil {
		return err
	}

	if len(annotations) == 0 {
		fmt.Fprintln(w, "No text found.")
	} else {
		fmt.Fprintln(w, "Text:")
		for _, annotation := range annotations {
			fmt.Fprintf(w, "%q\n", annotation.Description)
		}
	}

	return nil
}

Java

GitHub で表示フィードバック


import com.google.cloud.vision.v1.AnnotateImageRequest;
import com.google.cloud.vision.v1.AnnotateImageResponse;
import com.google.cloud.vision.v1.BatchAnnotateImagesResponse;
import com.google.cloud.vision.v1.EntityAnnotation;
import com.google.cloud.vision.v1.Feature;
import com.google.cloud.vision.v1.Image;
import com.google.cloud.vision.v1.ImageAnnotatorClient;
import com.google.cloud.vision.v1.ImageSource;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class DetectTextGcs {

  public static void detectTextGcs() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String filePath = "gs://your-gcs-bucket/path/to/image/file.jpg";
    detectTextGcs(filePath);
  }

  // Detects text in the specified remote image on Google Cloud Storage.
  public static void detectTextGcs(String gcsPath) throws IOException {
    List<AnnotateImageRequest> requests = new ArrayList<>();

    ImageSource imgSource = ImageSource.newBuilder().setGcsImageUri(gcsPath).build();
    Image img = Image.newBuilder().setSource(imgSource).build();
    Feature feat = Feature.newBuilder().setType(Feature.Type.TEXT_DETECTION).build();
    AnnotateImageRequest request =
        AnnotateImageRequest.newBuilder().addFeatures(feat).setImage(img).build();
    requests.add(request);

    // 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()) {
      BatchAnnotateImagesResponse response = client.batchAnnotateImages(requests);
      List<AnnotateImageResponse> responses = response.getResponsesList();

      for (AnnotateImageResponse res : responses) {
        if (res.hasError()) {
          System.out.format("Error: %s%n", res.getError().getMessage());
          return;
        }

        // For full list of available annotations, see http://g.co/cloud/vision/docs
        for (EntityAnnotation annotation : res.getTextAnnotationsList()) {
          System.out.format("Text: %s%n", annotation.getDescription());
          System.out.format("Position : %s%n", annotation.getBoundingPoly());
        }
      }
    }
  }
}

Node.js

GitHub で表示フィードバック

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

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

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const bucketName = 'Bucket where the file resides, e.g. my-bucket';
// const fileName = 'Path to file within bucket, e.g. path/to/image.png';

// Performs text detection on the gcs file
const [result] = await client.textDetection(`gs://${bucketName}/${fileName}`);
const detections = result.textAnnotations;
console.log('Text:');
detections.forEach(text => console.log(text));

PHP

GitHub で表示フィードバック

namespace Google\Cloud\Samples\Vision;

use Google\Cloud\Vision\V1\ImageAnnotatorClient;

// $path = 'gs://path/to/your/image.jpg'

function detect_text_gcs($path)
{
    $imageAnnotator = new ImageAnnotatorClient();

    # annotate the image
    $response = $imageAnnotator->textDetection($path);
    $texts = $response->getTextAnnotations();

    printf('%d texts found:' . PHP_EOL, count($texts));
    foreach ($texts as $text) {
        print($text->getDescription() . PHP_EOL);

        # get bounds
        $vertices = $text->getBoundingPoly()->getVertices();
        $bounds = [];
        foreach ($vertices as $vertex) {
            $bounds[] = sprintf('(%d,%d)', $vertex->getX(), $vertex->getY());
        }
        print('Bounds: ' . join(', ', $bounds) . PHP_EOL);
    }

    if ($error = $response->getError()) {
        print('API Error: ' . $error->getMessage() . PHP_EOL);
    }

    $imageAnnotator->close();
}

Python

GitHub で表示フィードバック

def detect_text_uri(uri):
    """Detects text in the file located in Google Cloud Storage or on the Web.
    """
    from google.cloud import vision
    client = vision.ImageAnnotatorClient()
    image = vision.Image()
    image.source.image_uri = uri

    response = client.text_detection(image=image)
    texts = response.text_annotations
    print('Texts:')

    for text in texts:
        print('\n"{}"'.format(text.description))

        vertices = (['({},{})'.format(vertex.x, vertex.y)
                    for vertex in text.bounding_poly.vertices])

        print('bounds: {}'.format(','.join(vertices)))

    if response.error.message:
        raise Exception(
            '{}\nFor more info on error messages, check: '
            'https://cloud.google.com/apis/design/errors'.format(
                response.error.message))

Ruby

GitHub で表示フィードバック

# image_path = "Google Cloud Storage URI, eg. 'gs://my-bucket/image.png'"

require "google/cloud/vision"

image_annotator = Google::Cloud::Vision.image_annotator

response = image_annotator.text_detection(
  image:       image_path,
  max_results: 1 # optional, defaults to 10
)

response.responses.each do |res|
  res.text_annotations.each do |text|
    puts text.description
  end
end

gcloud

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

gcloud ml vision detect-text gs://cloud-samples-data/vision/ocr/sign.jpg

言語を指定する（省略可）

どちらのタイプの OCR リクエストも 1 つ以上の languageHints をサポートしています。これにより、画像内のテキストの言語を指定します。しかし、ほとんどの場合、値を空にして自動言語検出を有効にしておくことによって最善の結果が得られます。ラテンアルファベット系の言語の場合、languageHints の設定は不要です。画像中のテキストの言語がわかっている場合などに、ヒントを設定すると結果が少し良くなります（逆に、ヒントを間違えると大きな障害となります）。サポートされる言語以外の言語が 1 つでも指定されていると、テキスト検出でエラーが返されます。

言語のヒントを指定する場合は、リクエストの本文（request.json ファイル）を変更し、以下の imageContext.languageHints フィールドにサポート対象言語の文字列を指定します。

{
  "requests": [
    {
      "image": {
        "source": {
          "imageUri": "image-url"
        }
      },
      "features": [
        {
          "type": "DOCUMENT_TEXT_DETECTION"
        }
      ],
      "imageContext": {
        "languageHints": ["en-t-i0-handwrit"]
      }
    }
  ]
}

言語ヒントの仕組み

languageHint の形式は、BCP47 言語コード形式のガイドラインに準拠しています。BCP47 指定の形式は次のとおりです。

language ["-" script] ["-" region] *("-" variant) *("-" extension) ["-" privateuse]

たとえば、言語ヒント「en-t-i0-handwrit」は、英語（en）、変換拡張シングルトン（t）、入力方法エンジン変換の拡張コード（i0）、手書き入力変換コード（handwrit）を指定しています。簡単にまとめると、「手書き入力から変換された英語」ということになります。スクリプトコードの指定は必要ありません。Latn は en 言語に含まれています。

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

この機能は現在、OCR 機能（TEXT_DETECTION または DOCUMENT_TEXT_DETECTION タイプ）にのみ適用されます。

大陸レベルでデータストレージと 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 とコマンドライン

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

cloud-storage-image-uri: Cloud Storage バケット内の有効な画像ファイルへのパス。少なくとも、ファイルに対する読み取り権限が必要です。たとえば次のように指定します。
- ```
gs://cloud-samples-data/vision/ocr/sign.jpg
```

HTTP メソッドと URL:

POST https://eu-vision.googleapis.com/v1/images:annotate

JSON 本文のリクエスト:

{
  "requests": [
    {
      "image": {
        "source": {
          "imageUri": "cloud-storage-image-uri"
        }
       },
       "features": [
         {
           "type": "TEXT_DETECTION"
         }
       ]
    }
  ]
}

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

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/images:annotate

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/images:annotate" | Select-Object -Expand Content

リクエストが成功すると、サーバーは 200 OK HTTP ステータスコードと JSON 形式のレスポンスを返します。

TEXT_DETECTION レスポンスには、検出されたフレーズ、その境界ボックス、および個々の単語とその境界ボックスが含まれています。

レスポンス



    {
      "responses": [
        {
          "textAnnotations": [
            {
              "locale": "en",
              "description": "WAITING?\nPLEASE\nTURN OFF\nYOUR\nENGINE\n",
              "boundingPoly": {
                "vertices": [
                  {
                    "x": 341,
                    "y": 828
                  },
                  {
                    "x": 2249,
                    "y": 828
                  },
                  {
                    "x": 2249,
                    "y": 1993
                  },
                  {
                    "x": 341,
                    "y": 1993
                  }
                ]
              }
            },
            {
              "description": "WAITING?",
              "boundingPoly": {
                "vertices": [
                  {
                    "x": 352,
                    "y": 828
                  },
                  {
                    "x": 2248,
                    "y": 911
                  },
                  {
                    "x": 2238,
                    "y": 1148
                  },
                  {
                    "x": 342,
                    "y": 1065
                  }
                ]
              }
            },
            {
              "description": "PLEASE",
              "boundingPoly": {
                "vertices": [
                  {
                    "x": 1210,
                    "y": 1233
                  },
                  {
                    "x": 1907,
                    "y": 1263
                  },
                  {
                    "x": 1902,
                    "y": 1383
                  },
                  {
                    "x": 1205,
                    "y": 1353
                  }
                ]
              }
            },
            {
              "description": "TURN",
              "boundingPoly": {
                "vertices": [
                  {
                    "x": 1210,
                    "y": 1418
                  },
                  {
                    "x": 1730,
                    "y": 1441
                  },
                  {
                    "x": 1724,
                    "y": 1564
                  },
                  {
                    "x": 1205,
                    "y": 1541
                  }
                ]
              }
            },
            {
              "description": "OFF",
              "boundingPoly": {
                "vertices": [
                  {
                    "x": 1792,
                    "y": 1443
                  },
                  {
                    "x": 2128,
                    "y": 1458
                  },
                  {
                    "x": 2122,
                    "y": 1581
                  },
                  {
                    "x": 1787,
                    "y": 1566
                  }
                ]
              }
            },
            {
              "description": "YOUR",
              "boundingPoly": {
                "vertices": [
                  {
                    "x": 1219,
                    "y": 1603
                  },
                  {
                    "x": 1746,
                    "y": 1629
                  },
                  {
                    "x": 1740,
                    "y": 1759
                  },
                  {
                    "x": 1213,
                    "y": 1733
                  }
                ]
              }
            },
            {
              "description": "ENGINE",
              "boundingPoly": {
                "vertices": [
                  {
                    "x": 1222,
                    "y": 1771
                  },
                  {
                    "x": 1944,
                    "y": 1834
                  },
                  {
                    "x": 1930,
                    "y": 1992
                  },
                  {
                    "x": 1208,
                    "y": 1928
                  }
                ]
              }
            }
          ],
          "fullTextAnnotation": {
            "pages": [
                      ...
                      ]
                    },
                    "paragraphs": [
                          ...
                          ]
                        },
                        "words": [
                            ...
                            },
                            "symbols": [
                            ...
                          }
                        ]
                      }
                    ],
                    "blockType": "TEXT"
                  },
                  ...
                ]
              }
            ],
            "text": "WAITING?\nPLEASE\nTURN OFF\nYOUR\nENGINE\n"
          }
        }
      ]
    }

C#

GitHub で表示

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

Go

GitHub で表示

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

GitHub で表示

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

GitHub で表示

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

PHP

GitHub で表示

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

$client = new ImageAnnotatorClient($options);

Python

GitHub で表示

from google.cloud import vision

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

client = vision.ImageAnnotatorClient(client_options=client_options)

Ruby

GitHub で表示

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

試してみる

以下のテキスト検出とドキュメントテキスト検出をお試しください。[Execute] をクリックして、すでに指定済みの画像（gs://cloud-samples-data/vision/ocr/sign.jpg）を使用することも、独自の画像を代わりに指定することもできます。

ドキュメント内のテキスト検出を試すには、type の値を DOCUMENT_TEXT_DETECTION に変更します。

道路標識の画像

画像内のテキストを検出する

光学式文字認識（OCR）

ぜひお試しください。

テキスト検出のリクエスト

GCP プロジェクトと認証の設定

ローカル画像でテキストを検出する

REST とコマンドライン

curl

PowerShell

レスポンス

C#

Go

Java

Node.js

PHP

Python

Ruby

リモート画像でテキストを検出する

REST とコマンドライン

curl

PowerShell

レスポンス

C#

Go

Java

Node.js

PHP

Python

Ruby

gcloud

言語を指定する（省略可）

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

ロケーション

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

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

REST とコマンドライン

curl

PowerShell

レスポンス

C#

Go

Java

Node.js

PHP

Python

Ruby

試してみる

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

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