DetectText demande d'opération DetectText réponse à l'opération

Détection de texte sur une image

Vous pouvez fournir une image d’entrée sous la forme d’un tableau d’octets d’image (octets d’image encodés en base64) ou en tant qu’objet Amazon S3. Dans cette procédure, vous chargez une image JPEG ou PNG dans votre compartiment S3 et vous spécifiez le nom du fichier.

Pour détecter du texte sur une image (API)

Remplissez les conditions préalables requises suivantes, si vous ne l’avez pas déjà fait.
1. Créez ou mettez à jour un utilisateur avec les autorisations AmazonRekognitionFullAccess et AmazonS3ReadOnlyAccess. Pour plus d’informations, consultez Étape 1 : configurer un compte AWS et créer un utilisateur.
2. Installez et configurez AWS Command Line Interface les AWS SDK. Pour plus d’informations, consultez Étape 2 : configurer les AWS SDK AWS CLI et.
Chargez l’image qui contient du texte dans votre compartiment S3.

Pour en savoir plus, consultez Chargement d’objets dans Amazon S3 dans le Guide de l’utilisateur Amazon Simple Storage Service.

Utilisez les exemples suivants pour appeler l’opération DetectText.

Java

L’exemple de code suivant affiche dans une image les lignes et les mots qui ont été détectés.

Remplacez la valeur de bucket et de photo par le nom du compartiment S3 et celui de l’image utilisés à l’étape 2.


//Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
//PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-developer-guide/blob/master/LICENSE-SAMPLECODE.)

package aws.example.rekognition.image;
import com.amazonaws.services.rekognition.AmazonRekognition;
import com.amazonaws.services.rekognition.AmazonRekognitionClientBuilder;
import com.amazonaws.services.rekognition.model.AmazonRekognitionException;
import com.amazonaws.services.rekognition.model.Image;
import com.amazonaws.services.rekognition.model.S3Object;
import com.amazonaws.services.rekognition.model.DetectTextRequest;
import com.amazonaws.services.rekognition.model.DetectTextResult;
import com.amazonaws.services.rekognition.model.TextDetection;
import java.util.List;



public class DetectText {

   public static void main(String[] args) throws Exception {
      
  
      String photo = "inputtext.jpg";
      String bucket = "bucket";

      AmazonRekognition rekognitionClient = AmazonRekognitionClientBuilder.defaultClient();

     
      
      DetectTextRequest request = new DetectTextRequest()
              .withImage(new Image()
              .withS3Object(new S3Object()
              .withName(photo)
              .withBucket(bucket)));
    

      try {
         DetectTextResult result = rekognitionClient.detectText(request);
         List<TextDetection> textDetections = result.getTextDetections();

         System.out.println("Detected lines and words for " + photo);
         for (TextDetection text: textDetections) {
      
                 System.out.println("Detected: " + text.getDetectedText());
                 System.out.println("Confidence: " + text.getConfidence().toString());
                 System.out.println("Id : " + text.getId());
                 System.out.println("Parent Id: " + text.getParentId());
                 System.out.println("Type: " + text.getType());
                 System.out.println();
         }
      } catch(AmazonRekognitionException e) {
         e.printStackTrace();
      }
   }
}

Java V2

Ce code est extrait du GitHub référentiel d'exemples du SDK de AWS documentation. Voir l’exemple complet ici.


/**
*  To run this code example, ensure that you perform the Prerequisites as stated in the Amazon Rekognition Guide:
*  https://docs.aws.amazon.com/rekognition/latest/dg/video-analyzing-with-sqs.html
*
* Also, ensure that set up your development environment, including your credentials.
*
* For information, see this documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/

//snippet-start:[rekognition.java2.detect_text.import]
import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
import software.amazon.awssdk.core.SdkBytes;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rekognition.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.DetectTextRequest;
import software.amazon.awssdk.services.rekognition.model.Image;
import software.amazon.awssdk.services.rekognition.model.DetectTextResponse;
import software.amazon.awssdk.services.rekognition.model.TextDetection;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.util.List;
//snippet-end:[rekognition.java2.detect_text.import]

/**
* Before running this Java V2 code example, set up your development environment, including your credentials.
*
* For more information, see the following documentation topic:
*
* https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/get-started.html
*/
public class DetectTextImage {

 public static void main(String[] args) {

     final String usage = "\n" +
         "Usage: " +
         "   <sourceImage>\n\n" +
         "Where:\n" +
         "   sourceImage - The path to the image that contains text (for example, C:\\AWS\\pic1.png). \n\n";

   if (args.length != 1) {
         System.out.println(usage);
         System.exit(1);
     }

     String sourceImage = args[0] ;
     Region region = Region.US_WEST_2;
     RekognitionClient rekClient = RekognitionClient.builder()
         .region(region)
         .credentialsProvider(ProfileCredentialsProvider.create("default"))
         .build();

     detectTextLabels(rekClient, sourceImage );
     rekClient.close();
 }

 // snippet-start:[rekognition.java2.detect_text.main]
 public static void detectTextLabels(RekognitionClient rekClient, String sourceImage) {

     try {
         InputStream sourceStream = new FileInputStream(sourceImage);
         SdkBytes sourceBytes = SdkBytes.fromInputStream(sourceStream);
         Image souImage = Image.builder()
             .bytes(sourceBytes)
             .build();

         DetectTextRequest textRequest = DetectTextRequest.builder()
             .image(souImage)
             .build();

         DetectTextResponse textResponse = rekClient.detectText(textRequest);
         List<TextDetection> textCollection = textResponse.textDetections();
         System.out.println("Detected lines and words");
         for (TextDetection text: textCollection) {
             System.out.println("Detected: " + text.detectedText());
             System.out.println("Confidence: " + text.confidence().toString());
             System.out.println("Id : " + text.id());
             System.out.println("Parent Id: " + text.parentId());
             System.out.println("Type: " + text.type());
             System.out.println();
         }

     } catch (RekognitionException | FileNotFoundException e) {
         System.out.println(e.getMessage());
         System.exit(1);
     }
 }
 // snippet-end:[rekognition.java2.detect_text.main]

AWS CLI

Cette AWS CLI commande affiche la sortie JSON pour l'opération detect-text CLI.

Remplacez la valeur de Bucket et de Name par le nom du compartiment S3 et le nom de l’image utilisés à l’étape 2.

Remplacez la valeur de profile_name par le nom de votre profil de développeur.


aws rekognition detect-text  --image "{"S3Object":{"Bucket":"bucket-name","Name":"image-name"}}" --profile default

Si vous accédez à la CLI sur un périphérique Windows, utilisez des guillemets doubles au lieu de guillemets simples et évitez les guillemets doubles internes par une barre oblique inverse (c’est-à-dire \) pour corriger les erreurs d’analyse que vous pourriez rencontrer. Pour un exemple, consultez ce qui suit :


aws rekognition detect-text  --image "{\"S3Object\":{\"Bucket\":\"bucket-name\",\"Name\":\"image-name\"}}" --profile default

Python

L’exemple de code suivant affiche les lignes et les mots détectés dans une image.

Remplacez la valeur de bucket et photo par le nom du compartiment S3 et le nom de l’image utilisés à l’étape 2. Remplacez la valeur de profile_name dans la ligne qui crée la session de Rekognition par le nom de votre profil de développeur.


# Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
# PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-developer-guide/blob/master/LICENSE-SAMPLECODE.)

import boto3

def detect_text(photo, bucket):

    session = boto3.Session(profile_name='default')
    client = session.client('rekognition')

    response = client.detect_text(Image={'S3Object': {'Bucket': bucket, 'Name': photo}})

    textDetections = response['TextDetections']
    print('Detected text\n----------')
    for text in textDetections:
        print('Detected text:' + text['DetectedText'])
        print('Confidence: ' + "{:.2f}".format(text['Confidence']) + "%")
        print('Id: {}'.format(text['Id']))
        if 'ParentId' in text:
            print('Parent Id: {}'.format(text['ParentId']))
        print('Type:' + text['Type'])
        print()
    return len(textDetections)

def main():
    bucket = 'bucket-name'
    photo = 'photo-name'
    text_count = detect_text(photo, bucket)
    print("Text detected: " + str(text_count))

if __name__ == "__main__":
    main()

.NET

L’exemple de code suivant affiche les lignes et les mots détectés dans une image.

Remplacez la valeur de bucket et de photo par le nom du compartiment S3; et le nom de l’image utilisés à l’étape 2.


//Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
//PDX-License-Identifier: MIT-0 (For details, see https://github.com/awsdocs/amazon-rekognition-developer-guide/blob/master/LICENSE-SAMPLECODE.)

using System;
using Amazon.Rekognition;
using Amazon.Rekognition.Model;

public class DetectText
{
    public static void Example()
    {
        String photo = "input.jpg";
        String bucket = "bucket";

        AmazonRekognitionClient rekognitionClient = new AmazonRekognitionClient();

        DetectTextRequest detectTextRequest = new DetectTextRequest()
        {
            Image = new Image()
            {
                S3Object = new S3Object()
                {
                    Name = photo,
                    Bucket = bucket
                }
            }
        };

        try
        {
            DetectTextResponse detectTextResponse = rekognitionClient.DetectText(detectTextRequest);
            Console.WriteLine("Detected lines and words for " + photo);
            foreach (TextDetection text in detectTextResponse.TextDetections)
            {
                Console.WriteLine("Detected: " + text.DetectedText);
                Console.WriteLine("Confidence: " + text.Confidence);
                Console.WriteLine("Id : " + text.Id);
                Console.WriteLine("Parent Id: " + text.ParentId);
                Console.WriteLine("Type: " + text.Type);
            }
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }
    }
}

Node.JS

L’exemple de code suivant affiche les lignes et les mots détectés dans une image.

Remplacez la valeur de bucket et de photo par le nom du compartiment S3 et le nom de l’image utilisés à l’étape 2. Remplacez la valeur de region par la région figurant dans vos informations d’identification .aws. Remplacez la valeur de profile_name dans la ligne qui crée la session de Rekognition par le nom de votre profil de développeur.


var AWS = require('aws-sdk');

const bucket = 'bucket' // the bucketname without s3://
const photo  = 'photo' // the name of file

const config = new AWS.Config({
  accessKeyId: process.env.AWS_ACCESS_KEY_ID,
  secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
}) 
AWS.config.update({region:'region'});
const client = new AWS.Rekognition();
const params = {
  Image: {
    S3Object: {
      Bucket: bucket,
      Name: photo
    },
  },
}
client.detectText(params, function(err, response) {
  if (err) {
    console.log(err, err.stack); // handle error if an error occurred
  } else {
    console.log(`Detected Text for: ${photo}`)
    console.log(response)
    response.TextDetections.forEach(label => {
      console.log(`Detected Text: ${label.DetectedText}`),
      console.log(`Type: ${label.Type}`),
      console.log(`ID: ${label.Id}`),
      console.log(`Parent ID: ${label.ParentId}`),
      console.log(`Confidence: ${label.Confidence}`),
      console.log(`Polygon: `)
      console.log(label.Geometry.Polygon)
    } 
    )
  } 
});

DetectText demande d'opération

Dans le cadre de l’opération DetectText, vous fournissez une image d’entrée sous la forme d’un tableau d’octets encodé en base64 ou en tant qu’image stockée dans un compartiment Amazon S3. L’exemple de demande JSON suivant présente l’image chargée à partir d’un compartiment Amazon S3.


{
    "Image": {
        "S3Object": {
            "Bucket": "bucket",
            "Name": "inputtext.jpg"
        }
    }
}

Filtres

Le filtrage par région, taille et score de fiabilité du texte vous offre encore plus de souplesse pour contrôler ce que donne la détection de votre texte. En utilisant les régions intéressantes, vous pouvez facilement limiter la détection de texte aux régions qui vous intéressent, par exemple en haut à droite de la photo de profil ou à un emplacement fixe par rapport à un point de référence lors de la lecture des numéros de pièces à partir d’une image d’une machine. Il est possible d’utiliser un filtre pour la taille du cadre de délimitation d’un mot, afin d’éviter l’apparition de texte de petite taille gênant ou non pertinent en arrière-plan. Le filtre de fiabilité des mots vous permet de supprimer les résultats non fiables car flous ou illisibles.

Pour plus d’informations sur les valeurs des filtres, consultez DetectTextFilters.

Vous pouvez utiliser les filtres suivants :

MinConfidence: définit le niveau de confiance de la détection des mots. Les mots dont la confiance de détection est inférieure à ce niveau sont exclus du résultat. Les valeurs doivent être comprises entre 0 et 100.
MinBoundingBoxWidth— Définit la largeur minimale du cadre de délimitation des mots. Les mots dont les zones de délimitation sont plus petites que cette valeur sont exclus du résultat. La valeur est relative à la largeur du cadre de l’image.
MinBoundingBoxHeight— Définit la hauteur minimale du cadre de délimitation des mots. Les mots dont les hauteurs de zone de délimitation sont inférieures à cette valeur sont exclus du résultat. La valeur est relative à la hauteur du cadre de l’image.
RegionsOfInterest— Limite la détection à une zone spécifique du cadre d'image. Les valeurs sont relatives aux dimensions du cadre. Pour du texte se trouvant seulement partiellement dans une région, la réponse n’est pas définie.

DetectText réponse à l'opération

L'DetectTextopération analyse l'image et renvoie un tableau TextDetections, où chaque élément (TextDetection) représente une ligne ou un mot détecté dans l'image. Pour chaque élément, DetectText renvoie les informations suivantes :

Le texte détecté (DetectedText)
Les relations entre les mots et les lignes (Id et ParentId)
L’emplacement du texte sur l’image (Geometry)
La confiance d’Amazon Rekognition dans l’exactitude du texte détecté et du cadre de délimitation (Confidence)
Le type de texte détecté (Type)

Texte détecté

Chaque élément TextDetection contient le texte reconnu (mots ou lignes) dans le champ DetectedText. Un mot est constitué d’un ou plusieurs caractères non séparés par des espaces. DetectText peut détecter jusqu’à 100 mots dans une image. Le texte renvoyé peut inclure des caractères qui rendent un mot méconnaissable. Par exemple, Ch@t au lieu de Chat. Pour déterminer si un TextDetection élément représente une ligne de texte ou un mot, utilisez le champ Type.

Chaque élément TextDetection comprend une valeur de pourcentage qui représente le degré de fiabilité déterminé par Amazon Rekognition en ce qui concerne la précision du texte détecté et du cadre de délimitation qui entoure le texte.

Relations entre les mots et les lignes

Chaque élément TextDetection possède un champ d’identifiant, Id. L’Id montre la position du mot dans une ligne. Si l’élément est un mot, le champ de l’identifiant parent, ParentId, identifie la ligne où le mot a été détecté. Le ParentId d’une ligne est null. Par exemple, la ligne « but keep » de l’exemple d’image a l’Id et les valeurs ParentId suivants :

Texte	ID	ID du parent
but keep	3
but	8	3
keep	9	3

Emplacement du texte sur une image

Pour déterminer l’emplacement du texte reconnu dans une image, utilisez les informations du cadre de délimitation (Géometrie) renvoyées par DetectText. L’objet Geometry contient deux types d’informations sur les cadres de délimitation pour les lignes et les mots détectés :

Contour rectangulaire grossier aligné sur un axe dans un objet BoundingBox
Un polygone plus fin composé de plusieurs coordonnées X et Y dans un tableau Point

Les coordonnées du cadre de sélection et du polygone montrent où le texte est situé sur l’image source. Les valeurs des coordonnées sont un ratio de la taille globale de l’image. Pour plus d'informations, consultez BoundingBox.

La réponse JSON suivante de l’opération DetectText indique les mots et les lignes qui ont été détectés dans l’image suivante.

Tasse à café souriante à côté du texte « It's Monday but keep Smiling » sur fond de brique, avec encadrés de texte.


{
 'TextDetections': [{'Confidence': 99.35693359375,
                     'DetectedText': "IT'S",
                     'Geometry': {'BoundingBox': {'Height': 0.09988046437501907,
                                                  'Left': 0.6684935688972473,
                                                  'Top': 0.18226495385169983,
                                                  'Width': 0.1461552083492279},
                                  'Polygon': [{'X': 0.6684935688972473,
                                               'Y': 0.1838926374912262},
                                              {'X': 0.8141663074493408,
                                               'Y': 0.18226495385169983},
                                              {'X': 0.8146487474441528,
                                               'Y': 0.28051772713661194},
                                              {'X': 0.6689760088920593,
                                               'Y': 0.2821454107761383}]},
                     'Id': 0,
                     'Type': 'LINE'},
                    {'Confidence': 99.6207275390625,
                     'DetectedText': 'MONDAY',
                     'Geometry': {'BoundingBox': {'Height': 0.11442459374666214,
                                                  'Left': 0.5566731691360474,
                                                  'Top': 0.3525116443634033,
                                                  'Width': 0.39574965834617615},
                                  'Polygon': [{'X': 0.5566731691360474,
                                               'Y': 0.353712260723114},
                                              {'X': 0.9522717595100403,
                                               'Y': 0.3525116443634033},
                                              {'X': 0.9524227976799011,
                                               'Y': 0.4657355844974518},
                                              {'X': 0.5568241477012634,
                                               'Y': 0.46693623065948486}]},
                     'Id': 1,
                     'Type': 'LINE'},
                    {'Confidence': 99.6160888671875,
                     'DetectedText': 'but keep',
                     'Geometry': {'BoundingBox': {'Height': 0.08314694464206696,
                                                  'Left': 0.6398131847381592,
                                                  'Top': 0.5267938375473022,
                                                  'Width': 0.2021435648202896},
                                  'Polygon': [{'X': 0.640289306640625,
                                               'Y': 0.5267938375473022},
                                              {'X': 0.8419567942619324,
                                               'Y': 0.5295097827911377},
                                              {'X': 0.8414806723594666,
                                               'Y': 0.609940767288208},
                                              {'X': 0.6398131847381592,
                                               'Y': 0.6072247624397278}]},
                     'Id': 2,
                     'Type': 'LINE'},
                    {'Confidence': 88.95134735107422,
                     'DetectedText': 'Smiling',
                     'Geometry': {'BoundingBox': {'Height': 0.4326171875,
                                                  'Left': 0.46289217472076416,
                                                  'Top': 0.5634765625,
                                                  'Width': 0.5371078252792358},
                                  'Polygon': [{'X': 0.46289217472076416,
                                               'Y': 0.5634765625},
                                              {'X': 1.0, 'Y': 0.5634765625},
                                              {'X': 1.0, 'Y': 0.99609375},
                                              {'X': 0.46289217472076416,
                                               'Y': 0.99609375}]},
                     'Id': 3,
                     'Type': 'LINE'},
                    {'Confidence': 99.35693359375,
                     'DetectedText': "IT'S",
                     'Geometry': {'BoundingBox': {'Height': 0.09988046437501907,
                                                  'Left': 0.6684935688972473,
                                                  'Top': 0.18226495385169983,
                                                  'Width': 0.1461552083492279},
                                  'Polygon': [{'X': 0.6684935688972473,
                                               'Y': 0.1838926374912262},
                                              {'X': 0.8141663074493408,
                                               'Y': 0.18226495385169983},
                                              {'X': 0.8146487474441528,
                                               'Y': 0.28051772713661194},
                                              {'X': 0.6689760088920593,
                                               'Y': 0.2821454107761383}]},
                     'Id': 4,
                     'ParentId': 0,
                     'Type': 'WORD'},
                    {'Confidence': 99.6207275390625,
                     'DetectedText': 'MONDAY',
                     'Geometry': {'BoundingBox': {'Height': 0.11442466825246811,
                                                  'Left': 0.5566731691360474,
                                                  'Top': 0.35251158475875854,
                                                  'Width': 0.39574965834617615},
                                  'Polygon': [{'X': 0.5566731691360474,
                                               'Y': 0.3537122905254364},
                                              {'X': 0.9522718787193298,
                                               'Y': 0.35251158475875854},
                                              {'X': 0.9524227976799011,
                                               'Y': 0.4657355546951294},
                                              {'X': 0.5568241477012634,
                                               'Y': 0.46693626046180725}]},
                     'Id': 5,
                     'ParentId': 1,
                     'Type': 'WORD'},
                    {'Confidence': 99.96778869628906,
                     'DetectedText': 'but',
                     'Geometry': {'BoundingBox': {'Height': 0.0625,
                                                  'Left': 0.6402802467346191,
                                                  'Top': 0.5283203125,
                                                  'Width': 0.08027780801057816},
                                  'Polygon': [{'X': 0.6402802467346191,
                                               'Y': 0.5283203125},
                                              {'X': 0.7205580472946167,
                                               'Y': 0.5283203125},
                                              {'X': 0.7205580472946167,
                                               'Y': 0.5908203125},
                                              {'X': 0.6402802467346191,
                                               'Y': 0.5908203125}]},
                     'Id': 6,
                     'ParentId': 2,
                     'Type': 'WORD'},
                    {'Confidence': 99.26438903808594,
                     'DetectedText': 'keep',
                     'Geometry': {'BoundingBox': {'Height': 0.0818721204996109,
                                                  'Left': 0.7344760298728943,
                                                  'Top': 0.5280686020851135,
                                                  'Width': 0.10748066753149033},
                                  'Polygon': [{'X': 0.7349520921707153,
                                               'Y': 0.5280686020851135},
                                              {'X': 0.8419566750526428,
                                               'Y': 0.5295097827911377},
                                              {'X': 0.8414806127548218,
                                               'Y': 0.6099407076835632},
                                              {'X': 0.7344760298728943,
                                               'Y': 0.6084995269775391}]},
                     'Id': 7,
                     'ParentId': 2,
                     'Type': 'WORD'},
                    {'Confidence': 88.95134735107422,
                     'DetectedText': 'Smiling',
                     'Geometry': {'BoundingBox': {'Height': 0.4326171875,
                                                  'Left': 0.46289217472076416,
                                                  'Top': 0.5634765625,
                                                  'Width': 0.5371078252792358},
                                  'Polygon': [{'X': 0.46289217472076416,
                                               'Y': 0.5634765625},
                                              {'X': 1.0, 'Y': 0.5634765625},
                                              {'X': 1.0, 'Y': 0.99609375},
                                              {'X': 0.46289217472076416,
                                               'Y': 0.99609375}]},
                     'Id': 8,
                     'ParentId': 3,
                     'Type': 'WORD'}],
 'TextModelVersion': '3.0'}

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Détection de texte

Détection de texte dans une vidéo stockée