Détecter l'écriture manuscrite dans les images

Détection de l'écriture manuscrite avec reconnaissance optique des caractères (OCR)

L'API Vision peut détecter et extraire du texte à partir d'images :

  • DOCUMENT_TEXT_DETECTION extrait le texte d'une image (ou d'un fichier). La réponse est optimisée pour les textes et les documents denses. Le JSON comprend des informations sur les pages, les blocs, les paragraphes, les mots et les blancs.

    Une utilisation spécifique de DOCUMENT_TEXT_DETECTION consiste à détecter l'écriture manuscrite dans une image.

    Image manuscrite

Requêtes de détection de document texte

Configurer votre authentification et votre projet GCP

quickstart,gcloud_init vision.googleapis.com Cloud Vision API SERVICE_ACCOUNT True env_var

Détecter le texte d'un document dans une image locale

L'API Vision peut détecter des fonctionnalités dans un fichier image local en envoyant le contenu du fichier image en tant que chaîne encodée en base64 dans le corps de votre requête.

API REST et ligne de commande

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • base64-encoded-image : représentation en base64 (chaîne ASCII) de vos données d'image binaire. Cette chaîne doit ressembler à la chaîne suivante :
    • /9j/4QAYRXhpZgAA...9tAVx/zDQDlGxn//2Q==
    Consultez la rubrique encodage en base64 pour en savoir plus.

Méthode HTTP et URL :

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

Corps JSON de la requête :

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

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

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

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$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

Si la requête aboutit, le serveur renvoie un code d'état HTTP 200 OK et la réponse au format JSON :

C#

Avant d'essayer cet exemple, suivez les instructions de configuration de C# dans le guide de démarrage rapide de l'API Vision à l'aide des bibliothèques clientes. Pour plus d'informations, consultez la documentation de référence de l'API Vision C#.

// Load an image from a local file.
    var image = Image.FromFile(filePath);
    var client = ImageAnnotatorClient.Create();
    var response = client.DetectDocumentText(image);
    foreach (var page in response.Pages)
    {
        foreach (var block in page.Blocks)
        {
            foreach (var paragraph in block.Paragraphs)
            {
                Console.WriteLine(string.Join("\n", paragraph.Words));
            }
        }
    }

Go

Avant d'essayer cet exemple, suivez les instructions de configuration de Go dans le guide de démarrage rapide de l'API Vision à l'aide des bibliothèques clientes. Pour plus d'informations, consultez la documentation de référence de l'API Vision Go.


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

Avant d'essayer cet exemple, suivez les instructions de configuration de Java dans le guide de démarrage rapide de l'API Vision à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vision Java.

public static void detectDocumentText(String filePath, PrintStream out) throws Exception,
         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);

      try (ImageAnnotatorClient client = ImageAnnotatorClient.create()) {
        BatchAnnotateImagesResponse response = client.batchAnnotateImages(requests);
        List<AnnotateImageResponse> responses = response.getResponsesList();
        client.close();

        for (AnnotateImageResponse res : responses) {
          if (res.hasError()) {
            out.printf("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();
                    out.format("Symbol text: %s (confidence: %f)\n", symbol.getText(),
                        symbol.getConfidence());
                  }
                  out.format("Word text: %s (confidence: %f)\n\n", wordText, word.getConfidence());
                  paraText = String.format("%s %s", paraText, wordText);
                }
                // Output Example using Paragraph:
                out.println("\nParagraph: \n" + paraText);
                out.format("Paragraph Confidence: %f\n", para.getConfidence());
                blockText = blockText + paraText;
              }
              pageText = pageText + blockText;
            }
          }
          out.println("\nComplete annotation:");
          out.println(annotation.getText());
        }
      }
    }

Node.js

Avant d'essayer cet exemple, suivez les instructions de configuration de Node.js dans le guide de démarrage rapide de l'API Vision à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vision Node.js.


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

PHP

Avant d'essayer cet exemple, suivez les instructions de configuration de PHP dans le guide de démarrage rapide de l'API Vision à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vision PHP.

namespace Google\Cloud\Samples\Vision;

    use Google\Cloud\Vision\V1\ImageAnnotatorClient;

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

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

        # annotate the image
        $image = file_get_contents($path);
        $response = $imageAnnotator->documentTextDetection($image);
        $annotation = $response->getFullTextAnnotation();

        # print out detailed and structured information about document text
        if ($annotation) {
            foreach ($annotation->getPages() as $page) {
                foreach ($page->getBlocks() as $block) {
                    $block_text = '';
                    foreach ($block->getParagraphs() as $paragraph) {
                        foreach ($paragraph->getWords() as $word) {
                            foreach ($word->getSymbols() as $symbol) {
                                $block_text .= $symbol->getText();
                            }
                            $block_text .= ' ';
                        }
                        $block_text .= "\n";
                    }
                    printf('Block content: %s', $block_text);
                    printf('Block confidence: %f' . PHP_EOL,
                        $block->getConfidence());

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

        $imageAnnotator->close();
    }

Python

Avant d'essayer cet exemple, suivez les instructions de configuration de Python dans le guide de démarrage rapide de l'API Vision à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vision Python.

def detect_document(path):
        """Detects document features in an image."""
        from google.cloud import vision
        import io
        client = vision.ImageAnnotatorClient()

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

        image = vision.types.Image(content=content)

        response = client.document_text_detection(image=image)

        for page in response.full_text_annotation.pages:
            for block in page.blocks:
                print('\nBlock confidence: {}\n'.format(block.confidence))

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

Ruby

Avant d'essayer cet exemple, suivez les instructions de configuration de Ruby dans le guide de démarrage rapide de l'API Vision à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vision Ruby.

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

    require "google/cloud/vision"

    image_annotator = Google::Cloud::Vision::ImageAnnotator.new

    response = image_annotator.document_text_detection image: image_path

    text = ""
    response.responses.each do |res|
      res.text_annotations.each do |annotation|
        text << annotation.description
      end
    end

    puts text

Détecter le texte d'un document dans une image distante

Pour plus de facilité, l'API Vision peut directement détecter des fonctionnalités dans un fichier image de Google Cloud Storage ou sur le Web sans envoyer le contenu du fichier image dans le corps de votre requête.

API REST et ligne de commande

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • cloud-storage-image-uri : chemin d'accès à un fichier image valide dans un bucket Cloud Storage. Il faut au minimum disposer des droits en lecture sur le fichier. Exemple :
    • gs://vision-api-handwriting-ocr-bucket/handwriting_image.png

Méthode HTTP et URL :

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

Corps JSON de la requête :

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

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

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

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$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

Si la requête aboutit, le serveur renvoie un code d'état HTTP 200 OK et la réponse au format JSON :

C#

Avant d'essayer cet exemple, suivez les instructions de configuration de C# dans le guide de démarrage rapide de l'API Vision à l'aide des bibliothèques clientes. Pour plus d'informations, consultez la documentation de référence de l'API Vision C#.

// 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.DetectDocumentText(image);
    foreach (var page in response.Pages)
    {
        foreach (var block in page.Blocks)
        {
            foreach (var paragraph in block.Paragraphs)
            {
                Console.WriteLine(string.Join("\n", paragraph.Words));
            }
        }
    }

Go

Avant d'essayer cet exemple, suivez les instructions de configuration de Go dans le guide de démarrage rapide de l'API Vision à l'aide des bibliothèques clientes. Pour plus d'informations, consultez la documentation de référence de l'API Vision Go.


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

Avant d'essayer cet exemple, suivez les instructions de configuration de Java dans le guide de démarrage rapide de l'API Vision à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vision Java.

public static void detectDocumentTextGcs(String gcsPath, PrintStream out) throws Exception,
        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);

      try (ImageAnnotatorClient client = ImageAnnotatorClient.create()) {
        BatchAnnotateImagesResponse response = client.batchAnnotateImages(requests);
        List<AnnotateImageResponse> responses = response.getResponsesList();
        client.close();

        for (AnnotateImageResponse res : responses) {
          if (res.hasError()) {
            out.printf("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();
                    out.format("Symbol text: %s (confidence: %f)\n", symbol.getText(),
                        symbol.getConfidence());
                  }
                  out.format("Word text: %s (confidence: %f)\n\n", wordText, word.getConfidence());
                  paraText = String.format("%s %s", paraText, wordText);
                }
                // Output Example using Paragraph:
                out.println("\nParagraph: \n" + paraText);
                out.format("Paragraph Confidence: %f\n", para.getConfidence());
                blockText = blockText + paraText;
              }
              pageText = pageText + blockText;
            }
          }
          out.println("\nComplete annotation:");
          out.println(annotation.getText());
        }
      }
    }

Node.js

Avant d'essayer cet exemple, suivez les instructions de configuration de Node.js dans le guide de démarrage rapide de l'API Vision à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vision Node.js.


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

PHP

Avant d'essayer cet exemple, suivez les instructions de configuration de PHP dans le guide de démarrage rapide de l'API Vision à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vision PHP.

namespace Google\Cloud\Samples\Vision;

    use Google\Cloud\Vision\V1\ImageAnnotatorClient;

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

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

        # annotate the image
        $response = $imageAnnotator->documentTextDetection($path);
        $annotation = $response->getFullTextAnnotation();

        # print out detailed and structured information about document text
        if ($annotation) {
            foreach ($annotation->getPages() as $page) {
                foreach ($page->getBlocks() as $block) {
                    $block_text = '';
                    foreach ($block->getParagraphs() as $paragraph) {
                        foreach ($paragraph->getWords() as $word) {
                            foreach ($word->getSymbols() as $symbol) {
                                $block_text .= $symbol->getText();
                            }
                            $block_text .= ' ';
                        }
                        $block_text .= "\n";
                    }
                    printf('Block content: %s', $block_text);
                    printf('Block confidence: %f' . PHP_EOL,
                        $block->getConfidence());

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

                    print(PHP_EOL);
                }
            }
        } else {
            print('No text found' . PHP_EOL);
        }

        $imageAnnotator->close();
    }

Python

Avant d'essayer cet exemple, suivez les instructions de configuration de Python dans le guide de démarrage rapide de l'API Vision à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vision Python.

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.types.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('\nBlock confidence: {}\n'.format(block.confidence))

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

Ruby

Avant d'essayer cet exemple, suivez les instructions de configuration de Ruby dans le guide de démarrage rapide de l'API Vision à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vision Ruby.

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

    require "google/cloud/vision"

    image_annotator = Google::Cloud::Vision::ImageAnnotator.new

    response = image_annotator.document_text_detection image: image_path

    text = ""
    response.responses.each do |res|
      res.text_annotations.each do |annotation|
        text << annotation.description
      end
    end

    puts text

Commande gcloud

Pour effectuer la détection de l'écriture manuscrite, utilisez la commande gcloud ml vision detect-document comme indiqué dans l'exemple suivant :

    gcloud ml vision detect-document gs://vision-api-handwriting-ocr-bucket/handwriting_image.png
    

Spécifier la langue (facultatif)

Les deux types de requêtes OCR sont compatibles avec un ou plusieurs languageHints qui spécifient la langue du texte de l'image. Cependant, dans la plupart des cas, une valeur vide donne de meilleurs résultats, car elle active la détection automatique de la langue. Pour les langues basées sur l'alphabet latin, le paramètre languageHints n'est pas nécessaire. Dans de rares cas, lorsque la langue du texte de l'image est connue, le réglage de ce paramètre aide à obtenir de meilleurs résultats (bien que cela nuise fortement au fonctionnement du service si sa valeur est erronée). La détection de texte renvoie une erreur si une ou plusieurs des langues spécifiées ne font pas partie des langues compatibles.

Si vous choisissez de fournir un indicateur de langue, modifiez le corps de votre requête (fichier request.json) pour fournir la chaîne de l'une des langues compatibles dans le champ imageContext.languageHints, comme indiqué ci-dessous :

    {
      "requests": [
        {
          "image": {
            "source": {
              "imageUri": "image-url"
            }
          },
          "features": [
            {
              "type": "DOCUMENT_TEXT_DETECTION"
            }
          ],
          "imageContext": {
            "languageHints": ["en-t-i0-handwrit"]
          }
        }
      ]
    }
    
Comment les indicateurs de langue fonctionnent-ils ?

Le format languageHint respecte les consignes de mise en forme du code de langue BCP47. Le format BCP47 spécifié est le suivant :

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

Par exemple, l'indicateur de langue "en-t-i0-handwrit" spécifie la langue anglaise (en), le singleton d'extension transform (t), le code d'extension pour la transformation du moteur du mode de saisie (i0) et le code de transformation du texte manuscrit (handwrit). Cela indique grossièrement que la langue est de l'"anglais transformé à partir d'un texte manuscrit". Vous n'avez pas besoin de spécifier un code de script, car la langue "en" sous-entend Latn.

Stockage multirégional

Vous pouvez désormais spécifier le stockage de données et le traitement OCR au niveau du continent. Les régions actuellement compatibles sont les suivantes :

  • us : pays des États-Unis uniquement
  • eu : Union européenne

Zones

Cloud Vision vous permet de contrôler où les ressources de votre projet sont stockées et traitées. Vous pouvez notamment configurer Cloud Vision pour stocker vos données et ne procéder au traitement de vos données que dans l'Union européenne.

Dans Cloud Vision, les ressources sont stockées et traitées par défaut dans un emplacement global. Le maintien de vos ressources dans un emplacement ou une région spécifique n'est donc pas garanti. Pour que Google ne stocke et traite vos données que dans l'Union européenne, vous devez sélectionner la région Union européenne. Vous et vos utilisateurs pouvez accéder aux données depuis n'importe quel emplacement.

Définir l'emplacement à l'aide de l'API

Cloud Vision accepte à la fois un point de terminaison de l'API global (vision.googleapis.com) et un point de terminaison en Union européenne (eu-vision.googleapis.com). Pour ne stocker et traiter vos données que dans l'Union européenne, utilisez l'URI eu-vision.googleapis.com à la place de vision.googleapis.com pour vos appels d'API REST :

  • 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

Définir l'emplacement à l'aide des bibliothèques clientes

Par défaut, les bibliothèques clientes de l'API Vision accèdent au point de terminaison global de l'API (vision.googleapis.com). Pour ne stocker et traiter vos données que dans l'Union européenne, vous devez définir explicitement le point de terminaison (eu-vision.googleapis.com). Les exemples de code ci-dessous indiquent comment configurer ce paramètre.

API REST et ligne de commande

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • cloud-storage-image-uri : chemin d'accès à un fichier image valide dans un bucket Cloud Storage. Il faut au minimum disposer des droits en lecture sur le fichier. Exemple :
    • gs://vision-api-handwriting-ocr-bucket/handwriting_image.png

Méthode HTTP et URL :

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

Corps JSON de la requête :

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

Pour envoyer votre requête, choisissez l'une des options suivantes :

curl

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

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

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$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

Si la requête aboutit, le serveur renvoie un code d'état HTTP 200 OK et la réponse au format JSON :

C#

// Instantiate a client connected to the 'eu' location.
    var client = new ImageAnnotatorClientBuilder
    {
        Endpoint = new ServiceEndpoint("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

Avant d'essayer cet exemple, suivez les instructions de configuration de Java dans le guide de démarrage rapide de l'API Vision à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Vision Java.

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::ImageAnnotator.new service_address: "eu-vision.googleapis.com"

Essayer

Essayez la détection de texte et la détection de document texte. Vous pouvez utiliser l'image déjà spécifiée (gs://vision-api-handwriting-ocr-bucket/handwriting_image.png) en cliquant sur Exécuter ou spécifier votre propre image à la place.

Image manuscrite