DetectText solicitação de operação DetectText resposta da operação

Detectar texto em uma imagem

Você pode fornecer uma imagem de entrada como uma matriz de bytes de imagem (bytes de imagem codificados em base64) ou como um objeto do Amazon S3. Neste procedimento, você carrega uma imagem JPEG ou PNG no bucket do S3 e especifica o nome do arquivo.

Para detectar texto em uma imagem (API)

Se você ainda não o fez, preencha os seguintes pré-requisitos.
1. Crie ou atualize um usuário com permissões AmazonRekognitionFullAccess e AmazonS3ReadOnlyAccess. Para ter mais informações, consulte Etapa 1: Configure uma conta da AWS e crie um usuário.
2. Instale e configure o AWS Command Line Interface e os AWS SDKs. Para ter mais informações, consulte Etapa 2: configurar os AWS SDKs AWS CLI e.
Faça upload da imagem que contém texto para seu bucket do S3.

Para obter instruções, consulte Como fazer upload de objetos no Amazon S3 no Guia do usuário do Amazon Simple Storage Service.

Use os exemplos a seguir para chamar a operação DetectText.

Java

O código de exemplo a seguir exibe linhas e palavras que foram detectadas em uma imagem.

Substitua os valores de bucket e photo pelos nomes do bucket S3 e da imagem usados na etapa 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

Esse código foi retirado do GitHub repositório de exemplos do SDK de AWS documentação. Veja o exemplo completo aqui.


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

Esse AWS CLI comando exibe a saída JSON para a operação da detect-text CLI.

Substitua os valores de Bucket e Name pelos nomes do bucket S3 e da imagem usados na etapa 2.

Substitua o valor de profile_name com o nome do seu perfil de desenvolvedor.


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

Se você estiver acessando a CLI em um dispositivo Windows, use aspas duplas em vez de aspas simples e escape das aspas duplas internas com barra invertida (ou seja, \) para resolver quaisquer erros de analisador que você possa encontrar. Para obter um exemplo, veja o seguinte:


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

Python

O código de exemplo a seguir exibe linhas e palavras detectadas em uma imagem.

Substitua os valores de bucket e photo pelos nomes do bucket S3 e da imagem usados na etapa 2. Substitua o valor de profile_name na linha que cria a sessão do Rekognition pelo nome do seu perfil de desenvolvedor.


# 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

O código de exemplo a seguir exibe linhas e palavras detectadas em uma imagem.

Substitua os valores de bucket e photo pelos nomes do bucket S3 e da imagem usados na etapa 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

O código de exemplo a seguir exibe linhas e palavras detectadas em uma imagem.

Substitua os valores de bucket e photo pelos nomes do bucket S3 e da imagem usados na etapa 2. Substitua o valor de region pela região encontrada em suas credenciais .aws. Substitua o valor de profile_name na linha que cria a sessão do Rekognition pelo nome do seu perfil de desenvolvedor.


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 solicitação de operação

Na operação DetectText, você fornece uma imagem de entrada como uma matriz de bytes codificada em base64 ou como uma imagem armazenada em um bucket do Amazon S3. O exemplo de solicitação JSON a seguir mostra a imagem carregada de um bucket do Amazon S3.


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

Filtros

A filtragem do texto por região, tamanho e pontuação de confiança oferece flexibilidade adicional para controlar a saída de detecção de seu texto. Usando regiões de interesse, é possível limitar facilmente a detecção de texto para as regiões relevantes para você, por exemplo, a parte superior direita da foto de perfil ou um local fixo em relação a um ponto de referência ao ler números de peças da imagem de uma máquina. O filtro de tamanho da caixa delimitadora de palavras pode ser usado para evitar texto pequeno em segundo plano que pode ser ruído ou irrelevante. O filtro de confiança de palavra permite que você remova resultados que podem não ser confiáveis devido a estarem embaçados ou borrados.

Para obter informações sobre valores de filtro, consulte DetectTextFilters.

É possível usar os seguintes filtros:

MinConfidence—Define o nível de confiança da detecção de palavras. Palavras com confiança de detecção abaixo desse nível são excluídas do resultado. Os valores devem estar entre 0 e 100.
MinBoundingBoxWidth— Define a largura mínima da caixa delimitadora da palavra. Palavras com caixas delimitadoras menores que esse valor são excluídas do resultado. O valor é relativo à largura do quadro da imagem.
MinBoundingBoxHeight— Define a altura mínima da caixa delimitadora da palavra. Palavras com alturas de caixa delimitadora menores que este valor são excluídas do resultado. O valor é relativo à altura do quadro da imagem.
RegionsOfInterest— Limita a detecção a uma região específica do quadro da imagem. Os valores são relativos às dimensões do quadro. Para texto apenas parcialmente dentro de uma região, a resposta é indefinida.

DetectText resposta da operação

A DetectText operação analisa a imagem e retorna uma matriz TextDetections, em que cada elemento (TextDetection) representa uma linha ou palavra detectada na imagem. Para cada elemento, o DetectText retorna as seguintes informações:

O texto detectado (DetectedText)
As relações entre palavras e linhas (Id e ParentId)
A localização do texto na imagem (Geometry)
A confiança que o Amazon Rekognition tem na precisão do texto detectado e da caixa delimitadora (Confidence)
O tipo do texto detectado (Type)

Texto detectado

Cada elemento de TextDetection contém texto reconhecido (palavras ou linhas) no campo DetectedText. Uma palavra é um ou mais caracteres de script não separados por espaços. DetectText pode detectar até 100 palavras em uma imagem. O texto retornado pode incluir caracteres que tornam uma palavra irreconhecível. Por exemplo, G@to em vez de Gato. Para determinar se um elemento do TextDetection representa uma linha de texto ou uma palavra, use o campo Type.

Cada elemento TextDetection inclui um valor percentual que representa o grau de confiança que o Amazon Rekognition tem na precisão do texto detectado e da caixa delimitadora que envolve o texto.

Relações entre palavras e linhas

Cada elemento de TextDetection tem um identificador campo, Id. O Id mostra a posição da palavra em uma linha. Se o elemento for uma palavra, o campo do identificador pai, ParentId, identificará a linha onde a palavra foi detectada. O ParentId de uma linha é nulo. Por exemplo, a linha "mas continue" na imagem anterior tem os seguintes valores de Id e ParentId:

Texto	ID	ID do pai
but keep	3
but	8	3
keep	9	3

Localização do texto em uma imagem

Para determinar onde o texto reconhecido está em uma imagem, use as informações da caixa delimitadora (Geometria) que são retornadas por DetectText. O objeto Geometry contém dois tipos de informações de caixa delimitadora para linhas e palavras detectadas:

Um contorno retangular grosso alinhado ao eixo em um objeto BoundingBox
Um polígono mais refinado que é composto de várias coordenadas X e Y em uma matriz de pontos

As coordenadas da caixa delimitadora e do polígono mostram onde o texto está localizado na imagem de origem. Os valores das coordenadas são uma proporção do tamanho geral da imagem. Para obter mais informações, consulte BoundingBox.

A seguinte resposta do JSON da operação DetectText mostra as palavras e linhas detectadas na imagem a seguir.

Caneca de café sorridente ao lado do texto que diz “É segunda-feira, mas continue sorrindo” em um fundo de tijolo, com caixas delimitadoras de texto.


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

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Detectar texto

Detectar texto em um vídeo armazenado