检测图片中的手写内容

注意：

• 需要在移动设备应用中使用此 API？请试用 Firebase 机器学习和机器学习套件，它们为使用 Cloud Vision 服务提供了特定于平台的 Android 和 iOS SDK，以及使用自定义机器学习模型的设备端 ML Vision API 和设备端推断。
• Vision API 现在支持将离线异步批量图片注释用于所有特征。此异步请求支持多达 2000 个图片文件，并返回存储在您的 Cloud Storage 存储桶中的响应 JSON 文件。如需详细了解此功能，请参阅离线批量图片注释。

文档文本检测的价格适用 DOCUMENT_TEXT_DETECTION 费率。如需了解详情，请参阅价格页面。

使用光学字符识别 (OCR) 进行手写内容检测

Vision API 可以检测并提取图片中的文本：

• DOCUMENT_TEXT_DETECTION 可提取图片（或文件）中的文本；其响应针对密集文本和文档进行了优化。JSON 包含页面、文本块、段落、字词和换行信息。

  

  DOCUMENT_TEXT_DETECTION 的一项特定用途是检测图片中的手写内容。

  

文档文本检测请求

设置您的 Google Cloud 项目和身份验证

如果您尚未创建 Google Cloud 项目，请立即创建。展开本部分可查看相关说明。

1. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Roles required to select or create a project

   • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
   • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.
   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

2. Verify that billing is enabled for your Google Cloud project.

3. Enable the Vision API.

   Roles required to enable APIs

   To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

   Enable the API

4. Install the Google Cloud CLI.

5. 配置 gcloud CLI 以使用您的联合身份。

   如需了解详情，请参阅使用联合身份登录 gcloud CLI。

6. 如需初始化 gcloud CLI，请运行以下命令：

   gcloud init

   检测本地图片中的文档文本

   您可以使用 Vision API 对本地图片文件执行特征检测。

   对于 REST 请求，请将图片文件的内容作为 base64 编码的字符串在请求正文中发送。

   对于 gcloud 和客户端库请求，请在请求中指定本地图片的路径。

   REST

   在使用任何请求数据之前，请先进行以下替换：

   • BASE64_ENCODED_IMAGE：二进制图片数据的 base64 表示（ASCII 字符串）。此字符串应类似于以下字符串：
     • /9j/4QAYRXhpZgAA...9tAVx/zDQDlGxn//2Q==
     如需了解详情，请参阅 base64 编码主题。
   • PROJECT_ID：您的 Google Cloud 项目 ID。

   HTTP 方法和网址：

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

   请求 JSON 正文：

   {
     "requests": [
       {
         "image": {
           "content": "BASE64_ENCODED_IMAGE"
         },
         "features": [
           {
             "type": "DOCUMENT_TEXT_DETECTION"
           }
         ]
       }
     ]
   }
   

   如需发送请求，请选择以下方式之一：

   curl

   注意：以下命令假定您已使用您的用户账号通过运行 gcloud init 或 gcloud auth login 登录 gcloud CLI，或者使用了 Cloud Shell，这会使您自动登录 gcloud CLI。您可以运行 gcloud auth list 来检查当前活跃的账号。

   将请求正文保存在名为 request.json 的文件中，然后执行以下命令：

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

   PowerShell

   注意：以下命令假定您已使用您的用户账号通过运行 gcloud init 或 gcloud auth login 登录 gcloud CLI。您可以运行 gcloud auth list 来检查当前活跃的账号。

   将请求正文保存在名为 request.json 的文件中，然后执行以下命令：

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

   如果请求成功，服务器将返回一个 200 OK HTTP 状态代码以及 JSON 格式的响应。

   Note: Zero coordinate values omitted. When the API detects a coordinate ("x" or "y") value of 0, that coordinate is omitted in the JSON response. Thus, a response with a bounding poly around the entire image would be
   [{},{"x": 100},{"x": 100,"y": 100},{"y": 100}] for an image that is 100 pixels by 100 pixels. For more information, see the API Reference documentation.

   响应

   {
     "responses": [
       {
         "textAnnotations": [
           {
             "locale": "en",
             "description": "O Google Cloud Platform\n",
             "boundingPoly": {
               "vertices": [
                 {
                   "x": 14,
                   "y": 11
                 },
                 {
                   "x": 279,
                   "y": 11
                 },
                 {
                   "x": 279,
                   "y": 37
                 },
                 {
                   "x": 14,
                   "y": 37
                 }
               ]
             }
           },
         ],
         "fullTextAnnotation": {
           "pages": [
             {
               "property": {
                 "detectedLanguages": [
                   {
                     "languageCode": "en"
                   }
                 ]
               },
               "width": 281,
               "height": 44,
               "blocks": [
                 {
                   "property": {
                     "detectedLanguages": [
                       {
                         "languageCode": "en"
                       }
                     ]
                   },
                   "boundingBox": {
                     "vertices": [
                       {
                         "x": 14, "y": 11
                       },
                       {
                         "x": 279, "y": 11
                       },
                       {
                         "x": 279, "y": 37
                       },
                       {
                         "x": 14, "y": 37
                       }
                     ]
                   },
                   "paragraphs": [
                     {
                       "property": {
                         "detectedLanguages": [
                           {
                             "languageCode": "en"
                           }
                         ]
                       },
                       "boundingBox": {
                         "vertices": [
                           {
                             "x": 14, "y": 11
                           },
                           {
                             "x": 279, "y": 11
                           },
                           {
                             "x": 279, "y": 37
                           },
                           {
                             "x": 14, "y": 37
                           }
                         ]
                       },
                       "words": [
                         {
                           "property": {
                             "detectedLanguages": [
                               {
                                 "languageCode": "en"
                               }
                             ]
                           },
                           "boundingBox": {
                             "vertices": [
                               {
                                 "x": 14, "y": 11
                               },
                               {
                                 "x": 23, "y": 11
                               },
                               {
                                 "x": 23, "y": 37
                               },
                               {
                                 "x": 14, "y": 37
                               }
                             ]
                           },
                           "symbols": [
                             {
                               "property": {
                                 "detectedLanguages": [
                                   {
                                     "languageCode": "en"
                                   }
                                 ],
                                 "detectedBreak": {
                                   "type": "SPACE"
                                 }
                               },
                               "boundingBox": {
                                 "vertices": [
                                   {
                                     "x": 14, "y": 11
                                   },
                                   {
                                     "x": 23, "y": 11
                                   },
                                   {
                                     "x": 23, "y": 37
                                   },
                                   {
                                     "x": 14, "y": 37
                                   }
                                 ]
                               },
                               "text": "O"
                             }
                           ]
                         },
                       ]
                     }
                   ],
                   "blockType": "TEXT"
                 }
               ]
             }
           ],
           "text": "Google Cloud Platform\n"
         }
       }
     ]
   }
   

   Go

   试用此示例之前，请按照《Vision 快速入门：使用客户端库》中的 Go 设置说明进行操作。 如需了解详情，请参阅 Vision Go API 参考文档。

   如需向 Vision 进行身份验证，请设置应用默认凭证。如需了解详情，请参阅为本地开发环境设置身份验证。

   
   // detectDocumentText gets the full document text from the Vision API for an image at the given file path.
   func detectDocumentText(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
   	}
   	annotation, err := client.DetectDocumentText(ctx, image, nil)
   	if err != nil {
   		return err
   	}
   
   	if annotation == nil {
   		fmt.Fprintln(w, "No text found.")
   	} else {
   		fmt.Fprintln(w, "Document Text:")
   		fmt.Fprintf(w, "%q\n", annotation.Text)
   
   		fmt.Fprintln(w, "Pages:")
   		for _, page := range annotation.Pages {
   			fmt.Fprintf(w, "\tConfidence: %f, Width: %d, Height: %d\n", page.Confidence, page.Width, page.Height)
   			fmt.Fprintln(w, "\tBlocks:")
   			for _, block := range page.Blocks {
   				fmt.Fprintf(w, "\t\tConfidence: %f, Block type: %v\n", block.Confidence, block.BlockType)
   				fmt.Fprintln(w, "\t\tParagraphs:")
   				for _, paragraph := range block.Paragraphs {
   					fmt.Fprintf(w, "\t\t\tConfidence: %f", paragraph.Confidence)
   					fmt.Fprintln(w, "\t\t\tWords:")
   					for _, word := range paragraph.Words {
   						symbols := make([]string, len(word.Symbols))
   						for i, s := range word.Symbols {
   							symbols[i] = s.Text
   						}
   						wordText := strings.Join(symbols, "")
   						fmt.Fprintf(w, "\t\t\t\tConfidence: %f, Symbols: %s\n", word.Confidence, wordText)
   					}
   				}
   			}
   		}
   	}
   
   	return nil
   }
   

   Java

   在试用此示例之前，请按照Vision API 快速入门：使用客户端库中的 Java 设置说明进行操作。如需了解详情，请参阅 Vision API Java 参考文档。

   注意：对于 Java Spring 框架用户，Spring Cloud Google Cloud 提供了一种身份验证设置和客户端对象的自动配置方法来使用 Vision API。

   public static void detectDocumentText(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(Type.DOCUMENT_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();
       client.close();
   
       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
         TextAnnotation annotation = res.getFullTextAnnotation();
         for (Page page : annotation.getPagesList()) {
           String pageText = "";
           for (Block block : page.getBlocksList()) {
             String blockText = "";
             for (Paragraph para : block.getParagraphsList()) {
               String paraText = "";
               for (Word word : para.getWordsList()) {
                 String wordText = "";
                 for (Symbol symbol : word.getSymbolsList()) {
                   wordText = wordText + symbol.getText();
                   System.out.format(
                       "Symbol text: %s (confidence: %f)%n",
                       symbol.getText(), symbol.getConfidence());
                 }
                 System.out.format(
                     "Word text: %s (confidence: %f)%n%n", wordText, word.getConfidence());
                 paraText = String.format("%s %s", paraText, wordText);
               }
               // Output Example using Paragraph:
               System.out.println("%nParagraph: %n" + paraText);
               System.out.format("Paragraph Confidence: %f%n", para.getConfidence());
               blockText = blockText + paraText;
             }
             pageText = pageText + blockText;
           }
         }
         System.out.println("%nComplete annotation:");
         System.out.println(annotation.getText());
       }
     }
   }

   Node.js

   试用此示例之前，请按照《Vision 快速入门：使用客户端库》中的 Node.js 设置说明进行操作。 如需了解详情，请参阅 Vision Node.js API 参考文档。

   如需向 Vision 进行身份验证，请设置应用默认凭证。如需了解详情，请参阅为本地开发环境设置身份验证。

   
   // Imports the Google Cloud client library
   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';
   
   // Read a local image as a text document
   const [result] = await client.documentTextDetection(fileName);
   const fullTextAnnotation = result.fullTextAnnotation;
   console.log(`Full text: ${fullTextAnnotation.text}`);
   fullTextAnnotation.pages.forEach(page => {
     page.blocks.forEach(block => {
       console.log(`Block confidence: ${block.confidence}`);
       block.paragraphs.forEach(paragraph => {
         console.log(`Paragraph confidence: ${paragraph.confidence}`);
         paragraph.words.forEach(word => {
           const wordText = word.symbols.map(s => s.text).join('');
           console.log(`Word text: ${wordText}`);
           console.log(`Word confidence: ${word.confidence}`);
           word.symbols.forEach(symbol => {
             console.log(`Symbol text: ${symbol.text}`);
             console.log(`Symbol confidence: ${symbol.confidence}`);
           });
         });
       });
     });
   });

   Python

   试用此示例之前，请按照《Vision 快速入门：使用客户端库》中的 Python 设置说明进行操作。 如需了解详情，请参阅 Vision Python API 参考文档。

   如需向 Vision 进行身份验证，请设置应用默认凭证。如需了解详情，请参阅为本地开发环境设置身份验证。

   def detect_document(path):
       """Detects document features in an image."""
       from google.cloud import vision
   
       client = vision.ImageAnnotatorClient()
   
       with open(path, "rb") as image_file:
           content = image_file.read()
   
       image = vision.Image(content=content)
   
       response = client.document_text_detection(image=image)
   
       for page in response.full_text_annotation.pages:
           for block in page.blocks:
               print(f"\nBlock confidence: {block.confidence}\n")
   
               for paragraph in block.paragraphs:
                   print("Paragraph confidence: {}".format(paragraph.confidence))
   
                   for word in paragraph.words:
                       word_text = "".join([symbol.text for symbol in word.symbols])
                       print(
                           "Word text: {} (confidence: {})".format(
                               word_text, word.confidence
                           )
                       )
   
                       for symbol in word.symbols:
                           print(
                               "\tSymbol: {} (confidence: {})".format(
                                   symbol.text, symbol.confidence
                               )
                           )
   
       if response.error.message:
           raise Exception(
               "{}\nFor more info on error messages, check: "
               "https://cloud.google.com/apis/design/errors".format(response.error.message)
           )
   
   

   其他语言

   C#： 请按照客户端库页面上的 C# 设置说明操作，然后访问 .NET 版 Vision 参考文档。

   PHP： 请按照客户端库页面上的 PHP 设置说明操作，然后访问 PHP 版 Vision 参考文档。

   Ruby 版： 请按照客户端库页面上的 Ruby 设置说明操作，然后访问 Ruby 版 Vision 参考文档。

   检测远程图片中的文档文本

   您可以使用 Vision API 对位于 Cloud Storage 或网络中的远程图片文件执行特征检测。如需发送远程文件请求，请在请求正文中指定文件的网址或 Cloud Storage URI。

   警告：从 HTTP/HTTPS 网址提取图片时，Google 无法保证请求会完成。如果指定的主机拒绝请求（例如，由于请求限制或 DoS 攻击防范），或者如果 Google 为了防止滥用而限制对网站的请求，则您的请求可能会失败。最佳实践是，对于生产应用不要依赖外部托管的图片。

   REST

   在使用任何请求数据之前，请先进行以下替换：

   • CLOUD_STORAGE_IMAGE_URI：Cloud Storage 存储桶中有效图片文件的路径。您必须至少拥有该文件的读取权限。 示例：
     • gs://cloud-samples-data/vision/handwriting_image.png

   • PROJECT_ID：您的 Google Cloud 项目 ID。

   HTTP 方法和网址：

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

   请求 JSON 正文：

   {
     "requests": [
       {
         "image": {
           "source": {
             "imageUri": "CLOUD_STORAGE_IMAGE_URI"
           }
          },
          "features": [
            {
              "type": "DOCUMENT_TEXT_DETECTION"
            }
          ]
       }
     ]
   }
   

   如需发送请求，请选择以下方式之一：

   curl

   注意：以下命令假定您已使用您的用户账号通过运行 gcloud init 或 gcloud auth login 登录 gcloud CLI，或者使用了 Cloud Shell，这会使您自动登录 gcloud CLI。您可以运行 gcloud auth list 来检查当前活跃的账号。

   将请求正文保存在名为 request.json 的文件中，然后执行以下命令：

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

   PowerShell

   注意：以下命令假定您已使用您的用户账号通过运行 gcloud init 或 gcloud auth login 登录 gcloud CLI。您可以运行 gcloud auth list 来检查当前活跃的账号。

   将请求正文保存在名为 request.json 的文件中，然后执行以下命令：

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

   如果请求成功，服务器将返回一个 200 OK HTTP 状态代码以及 JSON 格式的响应。

   Note: Zero coordinate values omitted. When the API detects a coordinate ("x" or "y") value of 0, that coordinate is omitted in the JSON response. Thus, a response with a bounding poly around the entire image would be
   [{},{"x": 100},{"x": 100,"y": 100},{"y": 100}] for an image that is 100 pixels by 100 pixels. For more information, see the API Reference documentation.

   响应

   {
     "responses": [
       {
         "textAnnotations": [
           {
             "locale": "en",
             "description": "O Google Cloud Platform\n",
             "boundingPoly": {
               "vertices": [
                 {
                   "x": 14,
                   "y": 11
                 },
                 {
                   "x": 279,
                   "y": 11
                 },
                 {
                   "x": 279,
                   "y": 37
                 },
                 {
                   "x": 14,
                   "y": 37
                 }
               ]
             }
           },
         ],
         "fullTextAnnotation": {
           "pages": [
             {
               "property": {
                 "detectedLanguages": [
                   {
                     "languageCode": "en"
                   }
                 ]
               },
               "width": 281,
               "height": 44,
               "blocks": [
                 {
                   "property": {
                     "detectedLanguages": [
                       {
                         "languageCode": "en"
                       }
                     ]
                   },
                   "boundingBox": {
                     "vertices": [
                       {
                         "x": 14, "y": 11
                       },
                       {
                         "x": 279, "y": 11
                       },
                       {
                         "x": 279, "y": 37
                       },
                       {
                         "x": 14, "y": 37
                       }
                     ]
                   },
                   "paragraphs": [
                     {
                       "property": {
                         "detectedLanguages": [
                           {
                             "languageCode": "en"
                           }
                         ]
                       },
                       "boundingBox": {
                         "vertices": [
                           {
                             "x": 14, "y": 11
                           },
                           {
                             "x": 279, "y": 11
                           },
                           {
                             "x": 279, "y": 37
                           },
                           {
                             "x": 14, "y": 37
                           }
                         ]
                       },
                       "words": [
                         {
                           "property": {
                             "detectedLanguages": [
                               {
                                 "languageCode": "en"
                               }
                             ]
                           },
                           "boundingBox": {
                             "vertices": [
                               {
                                 "x": 14, "y": 11
                               },
                               {
                                 "x": 23, "y": 11
                               },
                               {
                                 "x": 23, "y": 37
                               },
                               {
                                 "x": 14, "y": 37
                               }
                             ]
                           },
                           "symbols": [
                             {
                               "property": {
                                 "detectedLanguages": [
                                   {
                                     "languageCode": "en"
                                   }
                                 ],
                                 "detectedBreak": {
                                   "type": "SPACE"
                                 }
                               },
                               "boundingBox": {
                                 "vertices": [
                                   {
                                     "x": 14, "y": 11
                                   },
                                   {
                                     "x": 23, "y": 11
                                   },
                                   {
                                     "x": 23, "y": 37
                                   },
                                   {
                                     "x": 14, "y": 37
                                   }
                                 ]
                               },
                               "text": "O"
                             }
                           ]
                         },
                       ]
                     }
                   ],
                   "blockType": "TEXT"
                 }
               ]
             }
           ],
           "text": "Google Cloud Platform\n"
         }
       }
     ]
   }
   

   Go

   试用此示例之前，请按照《Vision 快速入门：使用客户端库》中的 Go 设置说明进行操作。 如需了解详情，请参阅 Vision Go API 参考文档。

   如需向 Vision 进行身份验证，请设置应用默认凭证。如需了解详情，请参阅为本地开发环境设置身份验证。

   
   // detectDocumentText gets the full document text from the Vision API for an image at the given file path.
   func detectDocumentTextURI(w io.Writer, file string) error {
   	ctx := context.Background()
   
   	client, err := vision.NewImageAnnotatorClient(ctx)
   	if err != nil {
   		return err
   	}
   
   	image := vision.NewImageFromURI(file)
   	annotation, err := client.DetectDocumentText(ctx, image, nil)
   	if err != nil {
   		return err
   	}
   
   	if annotation == nil {
   		fmt.Fprintln(w, "No text found.")
   	} else {
   		fmt.Fprintln(w, "Document Text:")
   		fmt.Fprintf(w, "%q\n", annotation.Text)
   
   		fmt.Fprintln(w, "Pages:")
   		for _, page := range annotation.Pages {
   			fmt.Fprintf(w, "\tConfidence: %f, Width: %d, Height: %d\n", page.Confidence, page.Width, page.Height)
   			fmt.Fprintln(w, "\tBlocks:")
   			for _, block := range page.Blocks {
   				fmt.Fprintf(w, "\t\tConfidence: %f, Block type: %v\n", block.Confidence, block.BlockType)
   				fmt.Fprintln(w, "\t\tParagraphs:")
   				for _, paragraph := range block.Paragraphs {
   					fmt.Fprintf(w, "\t\t\tConfidence: %f", paragraph.Confidence)
   					fmt.Fprintln(w, "\t\t\tWords:")
   					for _, word := range paragraph.Words {
   						symbols := make([]string, len(word.Symbols))
   						for i, s := range word.Symbols {
   							symbols[i] = s.Text
   						}
   						wordText := strings.Join(symbols, "")
   						fmt.Fprintf(w, "\t\t\t\tConfidence: %f, Symbols: %s\n", word.Confidence, wordText)
   					}
   				}
   			}
   		}
   	}
   
   	return nil
   }
   

   Java

   在试用此示例之前，请按照Vision API 快速入门：使用客户端库中的 Java 设置说明进行操作。如需了解详情，请参阅 Vision API Java 参考文档。

   注意：对于 Java Spring 框架用户，Spring Cloud Google Cloud 提供了一种身份验证设置和客户端对象的自动配置方法来使用 Vision API。

   public static void detectDocumentTextGcs(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(Type.DOCUMENT_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();
       client.close();
   
       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
         TextAnnotation annotation = res.getFullTextAnnotation();
         for (Page page : annotation.getPagesList()) {
           String pageText = "";
           for (Block block : page.getBlocksList()) {
             String blockText = "";
             for (Paragraph para : block.getParagraphsList()) {
               String paraText = "";
               for (Word word : para.getWordsList()) {
                 String wordText = "";
                 for (Symbol symbol : word.getSymbolsList()) {
                   wordText = wordText + symbol.getText();
                   System.out.format(
                       "Symbol text: %s (confidence: %f)%n",
                       symbol.getText(), symbol.getConfidence());
                 }
                 System.out.format(
                     "Word text: %s (confidence: %f)%n%n", wordText, word.getConfidence());
                 paraText = String.format("%s %s", paraText, wordText);
               }
               // Output Example using Paragraph:
               System.out.println("%nParagraph: %n" + paraText);
               System.out.format("Paragraph Confidence: %f%n", para.getConfidence());
               blockText = blockText + paraText;
             }
             pageText = pageText + blockText;
           }
         }
         System.out.println("%nComplete annotation:");
         System.out.println(annotation.getText());
       }
     }
   }

   Node.js

   试用此示例之前，请按照《Vision 快速入门：使用客户端库》中的 Node.js 设置说明进行操作。 如需了解详情，请参阅 Vision Node.js API 参考文档。

   如需向 Vision 进行身份验证，请设置应用默认凭证。如需了解详情，请参阅为本地开发环境设置身份验证。

   
   // 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';
   
   // Read a remote image as a text document
   const [result] = await client.documentTextDetection(
     `gs://${bucketName}/${fileName}`
   );
   const fullTextAnnotation = result.fullTextAnnotation;
   console.log(fullTextAnnotation.text);

   Python

   试用此示例之前，请按照《Vision 快速入门：使用客户端库》中的 Python 设置说明进行操作。 如需了解详情，请参阅 Vision Python API 参考文档。

   如需向 Vision 进行身份验证，请设置应用默认凭证。如需了解详情，请参阅为本地开发环境设置身份验证。

   def detect_document_uri(uri):
       """Detects document features in the file located in Google Cloud
       Storage."""
       from google.cloud import vision
   
       client = vision.ImageAnnotatorClient()
       image = vision.Image()
       image.source.image_uri = uri
   
       response = client.document_text_detection(image=image)
   
       for page in response.full_text_annotation.pages:
           for block in page.blocks:
               print(f"\nBlock confidence: {block.confidence}\n")
   
               for paragraph in block.paragraphs:
                   print("Paragraph confidence: {}".format(paragraph.confidence))
   
                   for word in paragraph.words:
                       word_text = "".join([symbol.text for symbol in word.symbols])
                       print(
                           "Word text: {} (confidence: {})".format(
                               word_text, word.confidence
                           )
                       )
   
                       for symbol in word.symbols:
                           print(
                               "\tSymbol: {} (confidence: {})".format(
                                   symbol.text, symbol.confidence
                               )
                           )
   
       if response.error.message:
           raise Exception(
               "{}\nFor more info on error messages, check: "
               "https://cloud.google.com/apis/design/errors".format(response.error.message)
           )
   
   

   gcloud

   如需执行手写内容检测，请使用 gcloud ml vision detect-document 命令，如以下示例所示：

   gcloud ml vision detect-document gs://cloud-samples-data/vision/handwriting_image.png
   

   其他语言

   C#： 请按照客户端库页面上的 C# 设置说明操作，然后访问 .NET 版 Vision 参考文档。

   PHP： 请按照客户端库页面上的 PHP 设置说明操作，然后访问 PHP 版 Vision 参考文档。

   Ruby 版： 请按照客户端库页面上的 Ruby 设置说明操作，然后访问 Ruby 版 Vision 参考文档。

   指定语言（可选）

   这两种类型的 OCR 请求均支持一个或多个 languageHints（用于指定图片中任何文本的语言）。但是，使用空值时效果最佳，因为省略值将启用自动语言检测。对于基于拉丁字母的语言，无需设置 languageHints。在极少数情况下，如果图片中文本的语言已知，设置提示有助于获得更好的结果（但是，如果提示错误，则会造成很大的阻碍）。如果已指定语言中有一种或多种不在支持的语言范围内，文本检测将返回错误。

   如果您选择提供语言提示，请修改请求正文（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)。此代码的含义是，语言为“转换自手写的英语内容”。您无需指定脚本代码，因为“en”语言隐含了 Latn。

   多区域支持

   此功能目前仅适用于 OCR 特征（TEXT_DETECTION 或 DOCUMENT_TEXT_DETECTION 类型）。

   现可指定洲级数据存储和 OCR 处理。目前支持以下区域：

   • us：仅限美国
   • eu：欧盟

   位置

   借助 Cloud Vision，您可以控制存储和处理项目资源的位置。具体来说，您可以将 Cloud Vision 配置为仅在欧盟地区存储和处理您的数据。

   默认情况下，Cloud Vision 会在全球位置存储和处理资源，这意味着 Cloud Vision 不保证您的资源将保留在特定位置或区域内。如果您选择欧盟位置，Google 只会在欧盟地区存储和处理您的数据。您和您的用户可以从任意位置访问该数据。

   使用 API 设置位置

   Vision API 支持全球 API 端点 (vision.googleapis.com) 以及两个基于区域的端点：欧盟端点 (eu-vision.googleapis.com) 和美国端点 (us-vision.googleapis.com)。使用这些端点进行特定于区域的处理。例如，要仅在欧盟地区存储和处理数据，请使用 URI eu-vision.googleapis.com 代替 vision.googleapis.com 进行 REST API 调用：

   • 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

   如需仅在美国存储和处理您的数据，请在上述方法中使用美国端点 (us-vision.googleapis.com)。

   使用客户端库设置位置

   默认情况下，Vision API 客户端库会访问全球 API 端点 (vision.googleapis.com)。如需仅在欧盟地区存储和处理您的数据，您需要明确设置端点 (eu-vision.googleapis.com)。以下代码示例展示了如何配置此设置。

   REST

   在使用任何请求数据之前，请先进行以下替换：

   • REGION_ID：有效的区域位置标识符之一：
     • us：仅限美国
     • eu：欧盟
   • CLOUD_STORAGE_IMAGE_URI：Cloud Storage 存储桶中有效图片文件的路径。您必须至少拥有该文件的读取权限。 示例：
     • gs://cloud-samples-data/vision/handwriting_image.png

   • PROJECT_ID：您的 Google Cloud 项目 ID。

   HTTP 方法和网址：

   POST https://REGION_ID-vision.googleapis.com/v1/projects/PROJECT_ID/locations/REGION_ID/images:annotate

   请求 JSON 正文：

   {
     "requests": [
       {
         "image": {
           "source": {
             "imageUri": "CLOUD_STORAGE_IMAGE_URI"
           }
          },
          "features": [
            {
              "type": "DOCUMENT_TEXT_DETECTION"
            }
          ]
       }
     ]
   }
   

   如需发送请求，请选择以下方式之一：

   curl

   注意：以下命令假定您已使用您的用户账号通过运行 gcloud init 或 gcloud auth login 登录 gcloud CLI，或者使用了 Cloud Shell，这会使您自动登录 gcloud CLI。您可以运行 gcloud auth list 来检查当前活跃的账号。

   将请求正文保存在名为 request.json 的文件中，然后执行以下命令：

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

   PowerShell

   注意：以下命令假定您已使用您的用户账号通过运行 gcloud init 或 gcloud auth login 登录 gcloud CLI。您可以运行 gcloud auth list 来检查当前活跃的账号。

   将请求正文保存在名为 request.json 的文件中，然后执行以下命令：

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

   如果请求成功，服务器将返回一个 200 OK HTTP 状态代码以及 JSON 格式的响应。

   Note: Zero coordinate values omitted. When the API detects a coordinate ("x" or "y") value of 0, that coordinate is omitted in the JSON response. Thus, a response with a bounding poly around the entire image would be
   [{},{"x": 100},{"x": 100,"y": 100},{"y": 100}] for an image that is 100 pixels by 100 pixels. For more information, see the API Reference documentation.

   响应

   {
     "responses": [
       {
         "textAnnotations": [
           {
             "locale": "en",
             "description": "O Google Cloud Platform\n",
             "boundingPoly": {
               "vertices": [
                 {
                   "x": 14,
                   "y": 11
                 },
                 {
                   "x": 279,
                   "y": 11
                 },
                 {
                   "x": 279,
                   "y": 37
                 },
                 {
                   "x": 14,
                   "y": 37
                 }
               ]
             }
           },
         ],
         "fullTextAnnotation": {
           "pages": [
             {
               "property": {
                 "detectedLanguages": [
                   {
                     "languageCode": "en"
                   }
                 ]
               },
               "width": 281,
               "height": 44,
               "blocks": [
                 {
                   "property": {
                     "detectedLanguages": [
                       {
                         "languageCode": "en"
                       }
                     ]
                   },
                   "boundingBox": {
                     "vertices": [
                       {
                         "x": 14, "y": 11
                       },
                       {
                         "x": 279, "y": 11
                       },
                       {
                         "x": 279, "y": 37
                       },
                       {
                         "x": 14, "y": 37
                       }
                     ]
                   },
                   "paragraphs": [
                     {
                       "property": {
                         "detectedLanguages": [
                           {
                             "languageCode": "en"
                           }
                         ]
                       },
                       "boundingBox": {
                         "vertices": [
                           {
                             "x": 14, "y": 11
                           },
                           {
                             "x": 279, "y": 11
                           },
                           {
                             "x": 279, "y": 37
                           },
                           {
                             "x": 14, "y": 37
                           }
                         ]
                       },
                       "words": [
                         {
                           "property": {
                             "detectedLanguages": [
                               {
                                 "languageCode": "en"
                               }
                             ]
                           },
                           "boundingBox": {
                             "vertices": [
                               {
                                 "x": 14, "y": 11
                               },
                               {
                                 "x": 23, "y": 11
                               },
                               {
                                 "x": 23, "y": 37
                               },
                               {
                                 "x": 14, "y": 37
                               }
                             ]
                           },
                           "symbols": [
                             {
                               "property": {
                                 "detectedLanguages": [
                                   {
                                     "languageCode": "en"
                                   }
                                 ],
                                 "detectedBreak": {
                                   "type": "SPACE"
                                 }
                               },
                               "boundingBox": {
                                 "vertices": [
                                   {
                                     "x": 14, "y": 11
                                   },
                                   {
                                     "x": 23, "y": 11
                                   },
                                   {
                                     "x": 23, "y": 37
                                   },
                                   {
                                     "x": 14, "y": 37
                                   }
                                 ]
                               },
                               "text": "O"
                             }
                           ]
                         },
                       ]
                     }
                   ],
                   "blockType": "TEXT"
                 }
               ]
             }
           ],
           "text": "Google Cloud Platform\n"
         }
       }
     ]
   }
   

   Go

   试用此示例之前，请按照《Vision 快速入门：使用客户端库》中的 Go 设置说明进行操作。 如需了解详情，请参阅 Vision Go API 参考文档。

   如需向 Vision 进行身份验证，请设置应用默认凭证。如需了解详情，请参阅为本地开发环境设置身份验证。

   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

   在试用此示例之前，请按照Vision API 快速入门：使用客户端库中的 Java 设置说明进行操作。如需了解详情，请参阅 Vision API Java 参考文档。

   注意：对于 Java Spring 框架用户，Spring Cloud Google Cloud 提供了一种身份验证设置和客户端对象的自动配置方法来使用 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

   试用此示例之前，请按照《Vision 快速入门：使用客户端库》中的 Node.js 设置说明进行操作。 如需了解详情，请参阅 Vision Node.js API 参考文档。

   如需向 Vision 进行身份验证，请设置应用默认凭证。如需了解详情，请参阅为本地开发环境设置身份验证。

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

   试用此示例之前，请按照《Vision 快速入门：使用客户端库》中的 Python 设置说明进行操作。 如需了解详情，请参阅 Vision Python API 参考文档。

   如需向 Vision 进行身份验证，请设置应用默认凭证。如需了解详情，请参阅为本地开发环境设置身份验证。

   from google.cloud import vision
   
   client_options = {"api_endpoint": "eu-vision.googleapis.com"}
   
   client = vision.ImageAnnotatorClient(client_options=client_options)

   试用

   尝试在以下工具中执行文本检测和文档文本检测。您可以点击执行来使用已指定的图片 (gs://cloud-samples-data/vision/handwriting_image.png)，也可以指定自己的图片。

   

   请求正文：

   {
     "requests": [
       {
         "features": [
           {
             "type": "DOCUMENT_TEXT_DETECTION"
           }
         ],
         "image": {
           "source": {
             "imageUri": "gs://cloud-samples-data/vision/handwriting_image.png"
           }
         }
       }
     ]
   }