DetectText Operationsanforderung DetectText Reaktion auf den Betrieb

Erkennen von Text in einem Bild

Sie können ein Eingabebild als Bild-Byte-Array (base64-verschlüsselte Bild-Bytes) oder als Amazon-S3-Objekt zur Verfügung stellen. Bei dieser Vorgehensweise laden Sie ein JPEG- oder PNG-Bild in Ihren S3-Bucket hoch und geben den Dateinamen an.

Um Text in einem Bild zu erkennen (API)

Falls Sie dies noch nicht getan haben, müssen Sie die folgenden Voraussetzungen erfüllen.
1. Erstellen oder aktualisieren Sie einen Benutzer mit AmazonRekognitionFullAccess- und AmazonS3ReadOnlyAccess-Berechtigungen. Weitere Informationen finden Sie unter Schritt 1: Einrichten eines AWS-Kontos und Erstellen eines Benutzers.
2. Installieren und konfigurieren Sie die AWS Command Line Interface und die SDKs AWS . Weitere Informationen finden Sie unter Schritt 2: Richten Sie die AWS CLI und AWS SDKs ein.
Laden Sie das Bild, das Text enthält, in Ihren S3-Bucket hoch.

Weitere Anleitungen finden Sie unter Upload eines Objekts in Amazon S3 im Benutzerhandbuch für Amazon Simple Storage Service.

Verwenden Sie die folgenden Beispiele zum Aufrufen der DetectText-Operation.

Java

Der folgende Beispielcode zeigt Zeilen und Wörter an, die in einem Bild erkannt wurden.

Ersetzen Sie die Werte von bucket und photo durch die Namen des S3-Buckets und des Bildes, das Sie in Schritt 2 verwendet haben.


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

Dieser Code stammt aus dem AWS Documentation SDK Examples GitHub Repository. Das vollständige Beispiel finden Sie hier.


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

Dieser AWS CLI Befehl zeigt die JSON-Ausgabe für den detect-text CLI-Vorgang an.

Ersetzen Sie die Werte von Bucket und Name durch die Namen des S3-Buckets und des Bildes, das Sie in Schritt 2 verwendet haben.

Ersetzen Sie den Wert von profile_name mit dem Namen Ihres Entwicklerprofils.


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

Wenn Sie auf einem Windows-Gerät auf die CLI zugreifen, verwenden Sie doppelte Anführungszeichen anstelle von einfachen Anführungszeichen und maskieren Sie die inneren doppelten Anführungszeichen durch einen Backslash (d. h. \), um eventuell auftretende Parserfehler zu beheben. Sehen Sie sich zum Beispiel Folgendes an:


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

Python

Der folgende Beispielcode zeigt erkannte Zeilen und Wörter an, die in einem Bild erkannt wurden.

Ersetzen Sie die Werte von bucket und photo durch die Namen des S3-Buckets und des Bilds, das Sie in Schritt 2 verwendet haben. Ersetzen Sie den Wert von profile_name in der Zeile, die die Rekognition-Sitzung erstellt, durch den Namen Ihres Entwicklerprofils.


# 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

Der folgende Beispielcode zeigt erkannte Zeilen und Wörter an, die in einem Bild erkannt wurden.

Ersetzen Sie die Werte von bucket und photo durch die Namen des S3-Buckets und des Bildes, das Sie in Schritt 2 verwendet haben.


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

Der folgende Beispielcode zeigt erkannte Zeilen und Wörter an, die in einem Bild erkannt wurden.

Ersetzen Sie die Werte von bucket und photo durch die Namen des S3-Buckets und des Bilds, das Sie in Schritt 2 verwendet haben. Ersetzen Sie den Wert von region durch die Region, die Sie in Ihren AWS-Anmeldeinformationen finden. Ersetzen Sie den Wert von profile_name in der Zeile, die die Rekognition-Sitzung erstellt, durch den Namen Ihres Entwicklerprofils.


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 Operationsanforderung

In der DetectText-Operation stellen Sie ein Eingabebild bereit, entweder als base64-codiertes Byte-Array oder als Bild, das in einem Amazon-S3-Bucket gespeichert ist. Das folgende Beispiel einer JSON-Anforderung zeigt das aus einem Amazon-S3-Bucket geladene Bild.


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

Filter

Die Filterung nach Textbereich, Größe und Zuverlässigkeitswert bietet Ihnen zusätzliche Flexibilität bei der Steuerung Ihrer Texterkennungsausgabe. Durch die Verwendung von „Bereiche von Interesse“ können Sie die Texterkennung bequem auf die für Sie relevanten Bereiche beschränken, z. B. auf die obere rechte Ecke eines Profilfotos oder auf eine feste Position in Bezug auf einen Referenzpunkt beim Lesen von Teilenummern aus einem Bild einer Maschine. Mithilfe eines Filters für die Größe von Wortbegrenzungsrahmen kann kleiner Hintergrundtext vermieden werden, der u. U. stört oder irrelevant ist. Der Wortzuverlässigkeitsfilter ermöglicht Ihnen das Entfernen von Ergebnissen, die aufgrund von Unschärfe möglicherweise unzuverlässig sind.

Hinweise zu Filterwerten finden Sie unter DetectTextFilters.

Sie können die folgenden Filter verwenden:

MinConfidence— Legt das Konfidenzniveau der Worterkennung fest. Wörter mit einer Erkennungszuverlässigkeit unterhalb dieses Niveaus werden vom Ergebnis ausgeschlossen. Die Werte sollten zwischen 0 und 100 liegen.
MinBoundingBoxWidth— Legt die Mindestbreite des Begrenzungsrahmens für Wörter fest. Wörter mit Begrenzungsrahmen, die kleiner als dieser Wert sind, werden aus dem Ergebnis ausgeschlossen. Der Wert ist relativ zur Bildbreite.
MinBoundingBoxHeight— Legt die Mindesthöhe des Begrenzungsrahmens für Wörter fest. Wörter mit einer Begrenzungsrahmenhöhe unter diesem Wert werden aus dem Ergebnis ausgeschlossen. Der Wert ist relativ zur Bildhöhe.
RegionsOfInterest— Beschränkt die Erkennung auf einen bestimmten Bereich des Bildrahmens. Die Werte sind relativ zur Bildgröße. Bei Text, der nur teilweise innerhalb eines Bereichs liegt, ist die Antwort undefiniert.

DetectText Reaktion auf den Betrieb

Die DetectText Operation analysiert das Bild und gibt ein Array zurück TextDetections, wobei jedes Element (TextDetection) für eine Zeile oder ein Wort steht, das im Bild erkannt wurde. Für jedes Element gibt DetectText die folgenden Informationen zurück:

Den erkannten Text (DetectedText)
Die Beziehungen zwischen Wörtern und Zeilen (Id und ParentId)
Die Position des Textes auf dem Bild (Geometry)
Das Vertrauen von Amazon Rekognition in die Genauigkeit des erkannten Textes und des Begrenzungsrahmens (Confidence)
Die Art des erkannten Textes (Type)

Erkannter Text

Jedes TextDetection-Element enthält erkannten Text (Wörter oder Zeilen) im Feld DetectedText. Ein Wort besteht aus einem oder mehreren Schriftzeichen, die nicht durch Leerzeichen getrennt sind. DetectText kann bis zu 100 Wörter in einem Bild erkennen. Der zurückgegebene Text kann Zeichen enthalten, die ein Wort unkenntlich machen. Beispiel: C@t anstelle von Cat. Um festzustellen, ob ein Element TextDetection eine Textzeile oder ein Wort repräsentiert, verwenden Sie das Feld Type.

Jedes TextDetection-Element enthält einen Prozentwert, der den Grad des Vertrauens repräsentiert, den Amazon Rekognition in die Genauigkeit des erkannten Texts und des den Text umgebenden Begrenzungsrahmens hat.

Wort- und Zeilen-Beziehungen

Jedes TextDetection-Element verfügt über ein ID-Feld, Id. Die Id zeigt die Position des Wortes in einer Zeile an. Wenn es sich einem Element um ein Wort handelt, identifiziert das Feld der übergeordneten ID, ParentId, die Zeile, in der das Wort erkannt wurde. Die ParentId für eine Zeile ist Null. Zum Beispiel hat die Zeile „but keep“ im Beispielbild folgende Id- und ParentId-Werte:

Text	ID	Parent ID
but keep	3
but	8	3
keep	9	3

Textposition auf einem Bild

Um zu ermitteln, wo sich der erkannte Text auf einem Bild befindet, verwenden Sie die Informationen des Begrenzungsrahmens (Geometrie), den DetectText zurückgibt. Das Geometry-Objekt enthält zwei Arten von Informationen über Begrenzungsrahmen für erkannte Zeilen und Wörter:

Ein nach der Achse ausgerichteter grober rechteckiger Umriss in einem Objekt BoundingBox
Ein feingliedrigeres Polygon, bestehend aus mehreren X- und Y-Koordinaten in einem Punkt-Array

Der Begrenzungsrahmen und die Koordinaten des Polygons zeigen die Position des Textes auf dem Quellbild an. Die Koordinatenwerte sind ein Verhältnis der gesamten Bildgröße. Weitere Informationen finden Sie unter. BoundingBox

Die folgende JSON-Antwort der DetectText-Operation zeigt die erkannten Wörter und Zeilen im nachfolgenden Bild.

Lächelnde Kaffeetasse neben dem Text „Es ist Montag, aber lächle weiter“ auf einem Backsteinhintergrund, mit Textbegrenzungsfeldern.


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

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Erkennen von Text

Erkennen von Text in einem gespeicherten Video