Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Erkennen von Text
Amazon Rekognition kann Text in Bildern und Videos erkennen. Sie kann anschließend den erkannten Text in maschinenlesbaren Text umwandeln. Sie können die maschinenlesbare Texterkennung in Bildern verwenden, um Lösungen zu implementieren wie:
+ Visuelle Suche. Beispielsweise können Sie Bilder abrufen und anzeigen, die denselben Text enthalten.
+ Content-Einblicke. Ein Beispiel ist die Bereitstellung von Einblicken in Themen, die in Text vorkommen, der in extrahierten Videobildern erkannt wird. Ihre Anwendung kann erkannten Text nach relevanten Inhalten wie Nachrichten, Sportergebnissen, Athletennummern und Bildunterschriften durchsuchen.
+ Navigation. Sie könnten zum Beispiel eine sprachgesteuerte, mobile App für sehbehinderte Menschen entwickeln, die Namen von Restaurants, Geschäften oder Straßenschildern erkennt.
+ Unterstützung der öffentlichen Sicherheit und des Verkehrs. Zum Beispiel die Erkennung von Kfz-Kennzeichen aus Verkehrskamerabildern.
+ Filtern. Zum Beispiel, Herausfiltern von persönlich identifizierbaren Informationen (PII) aus Bildern.
Für die Texterkennung in Videos können Sie Lösungen implementieren wie:
+ Suchen von Videos nach Clips, in denen bestimmte Textschlüsselwörter, z. B. der Name des Gastes auf einer Grafik in einer Nachrichtensendung, vorkommen
+ Moderation von Inhalten zur Einhaltung organisatorischer Standards durch Erkennung von versehentlichem Text, Schimpfwörtern oder Spam
+ Suchen aller Texteinblendungen auf der Videozeitleiste zur weiteren Verarbeitung, z. B. Ersetzen von Text durch Text in einer anderen Sprache für die Internationalisierung von Inhalten
+ Finden von Textstellen, damit andere Grafiken entsprechend angepasst werden können
Verwenden Sie den [DetectText](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectText.html)Vorgang, um Text in Bildern im JPEG- oder PNG-Format zu erkennen. Verwenden Sie die [GetTextDetection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_GetTextDetection.html)Operationen [StartTextDetection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartTextDetection.html)und, um Text in Videos asynchron zu erkennen. Sowohl Bild- als auch Videotexterkennungs-Operationen unterstützen die meisten Schriftarten, dazu zählen auch hochstilisierte Schriftarten. Wenn Text erkannt wird, erzeugt Amazon Rekognition eine Darstellung der erkannten Wörter und Textzeilen, zeigt die Beziehung zwischen ihnen an und zeigt Ihnen an, wo sich der Text auf einem Bild oder einem Video-Frame befindet.
Die `DetectText`- und `GetTextDetection`-Operationen erkennen Wörter und Zeilen. Ein *Wort* besteht aus einem oder mehreren Skriptzeichen, die nicht durch Leerzeichen getrennt sind. `DetectText` kann bis zu 100 Wörter in einem Bild erkennen. `GetTextDetection` kann auch bis zu 100 Wörter pro Video-Frame erkennen.
Ein Wort besteht aus einem oder mehreren Textzeichen, die nicht durch Leerzeichen getrennt sind. Amazon Rekognition wurde entwickelt, um Text in den Sprachen Englisch, Arabisch, Russisch, Deutsch, Französisch, Italienisch, Portugiesisch und Spanisch zu erkennen.
Eine *Zeile* besteht aus einer Folge von Wörtern mit gleichem Abstand. Eine Zeile ist nicht unbedingt ein vollständiger Satz (Punkte bedeuten nicht das Ende einer Zeile). Amazon Rekognition erkennt zum Beispiel die Nummer eines Führerscheins als Zeile. Eine Zeile endet, wenn hinter ihr kein ausgerichteter Text steht oder wenn zwischen den Wörtern ein großer Abstand besteht, der im Verhältnis zur Länge der Wörter besteht. Je nach Abstand zwischen den Wörtern erkennt Amazon Rekognition möglicherweise mehrere Textzeilen, die in dieselbe Richtung ausgerichtet sind. Wenn ein Satz über mehrere Zeilen geht, gibt die Operation mehrere Zeilen zurück.
Betrachten Sie das folgende Bild:
![\[Kaffeebecher mit einem Smiley und dem Text „It's Monday but keep smile“, mit Umrandungsfeldern und extrahiertem Text.\]](http://docs.aws.amazon.com/de_de/rekognition/latest/dg/images/text.png)
Die blauen Felder enthalten Informationen über den erkannten Text und die Position des Textes, der durch die `DetectText`-Operation zurückgegeben wird. In diesem Beispiel erkennt Amazon Rekognition „IT's“, „MONDAY“, „but“, „keep“, und „Smiling“ als Wörter. Amazon Rekognition erkennt „IT'S“, „MONDAY“, „but keep“ und „Smiling“ als Zeilen. Um erkannt zu werden, muss sich der Text innerhalb von \$1/- 90 Grad in der horizontalen Achse befinden.
Ein Beispiel finden Sie unter [Erkennen von Text in einem Bild](text-detecting-text-procedure.md).
**Topics**
+ [Erkennen von Text in einem Bild](text-detecting-text-procedure.md)
+ [Erkennen von Text in einem gespeicherten Video](text-detecting-video-procedure.md)
# 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)**
1. 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](setting-up.md#setting-up-iam).
1. Installieren und konfigurieren Sie das AWS Command Line Interface und das. AWS SDKs Weitere Informationen finden Sie unter [Schritt 2: Richten Sie das AWS CLI und ein AWS SDKs](setup-awscli-sdk.md).
1. Laden Sie das Bild, das Text enthält, in Ihren S3-Bucket hoch.
Weitere Anleitungen finden Sie unter [Upload eines Objekts in Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UploadingObjectsintoAmazonS3.html) im *Benutzerhandbuch für Amazon Simple Storage Service*.
1. 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 `amzn-s3-demo-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 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](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javav2/example_code/rekognition/src/main/java/com/example/rekognition/DetectText.java).
```
/**
* 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: " +
" \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 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 `amzn-s3-demo-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":"amzn-s3-demo-bucket","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. \$1), um eventuell auftretende Parserfehler zu beheben. Sehen Sie sich zum Beispiel Folgendes an:
```
aws rekognition detect-text --image "{\"S3Object\":{\"Bucket\":\"amzn-s3-demo-bucket\",\"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 `amzn-s3-demo-bucket` und `photo` durch die Namen des S3-Buckets und des Bildes, 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 = 'amzn-s3-demo-bucket'
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 `amzn-s3-demo-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 = "amzn-s3-demo-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 `amzn-s3-demo-bucket` und `photo` durch die Namen des S3-Buckets und des Bildes, 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": "amzn-s3-demo-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](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_DetectTextFilters.html)`.
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](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_TextDetection.html)`) 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 (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](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_Geometry.html)), den `DetectText` zurückgibt. Das `Geometry`-Objekt enthält zwei Arten von Informationen über Begrenzungsrahmen für erkannte Zeilen und Wörter:
+ Ein achsenausgerichteter grober rechteckiger Umriss in einem [BoundingBox](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_BoundingBox.html)-Objekt
+ Ein feingliedrigeres Polygon, bestehend aus mehreren X- und Y-Koordinaten in einem [Punkt](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_Point.html)-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](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_BoundingBox.html).
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.\]](http://docs.aws.amazon.com/de_de/rekognition/latest/dg/images/text.png)
```
{
'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'}
```
# Erkennen von Text in einem gespeicherten Video
Die Texterkennung von Amazon Rekognition Video in gespeicherten Videos ist eine asynchrone Operation. Rufen [StartTextDetection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_StartTextDetection.html)Sie an, um mit der Texterkennung zu beginnen. Amazon Rekognition Video veröffentlicht den Fertigstellungsfortschritt der Videoanalyse in einem Amazon-SNS-Thema. Wenn die Videoanalyse erfolgreich ist, rufen Sie [GetTextDetection](https://docs.aws.amazon.com/rekognition/latest/APIReference/API_GetTextDetection.html) auf, um die Analyseergebnisse abzurufen. Weitere Informationen zum Starten der Videoanalyse und zum Abrufen der Ergebnisse finden Sie unter [Amazon-Rekognition-Video-Operationen aufrufen](api-video.md).
Durch dieses Verfahren wird der Code in [Analysieren eines in einem Amazon S3-Bucket gespeicherten Videos mit Java oder Python (SDK)](video-analyzing-with-sqs.md) erweitert. Bei dem Verfahren wird eine Amazon-SQS-Warteschlange verwendet, um den Abschlussstatus einer Videoanalyseanforderung zu erhalten.
**So erkennen Sie Text in einem Video, das in einem Amazon-S3-Bucket gespeichert ist (SDK)**
1. Führen Sie die Schritte unter [Analysieren eines in einem Amazon S3-Bucket gespeicherten Videos mit Java oder Python (SDK)](video-analyzing-with-sqs.md) aus.
1. Fügen Sie in Schritt 1 den folgenden Code zur Klasse `VideoDetect` hinzu.
------
#### [ Java ]
```
//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.)
private static void StartTextDetection(String bucket, String video) throws Exception{
NotificationChannel channel= new NotificationChannel()
.withSNSTopicArn(snsTopicArn)
.withRoleArn(roleArn);
StartTextDetectionRequest req = new StartTextDetectionRequest()
.withVideo(new Video()
.withS3Object(new S3Object()
.withBucket(bucket)
.withName(video)))
.withNotificationChannel(channel);
StartTextDetectionResult startTextDetectionResult = rek.startTextDetection(req);
startJobId=startTextDetectionResult.getJobId();
}
private static void GetTextDetectionResults() throws Exception{
int maxResults=10;
String paginationToken=null;
GetTextDetectionResult textDetectionResult=null;
do{
if (textDetectionResult !=null){
paginationToken = textDetectionResult.getNextToken();
}
textDetectionResult = rek.getTextDetection(new GetTextDetectionRequest()
.withJobId(startJobId)
.withNextToken(paginationToken)
.withMaxResults(maxResults));
VideoMetadata videoMetaData=textDetectionResult.getVideoMetadata();
System.out.println("Format: " + videoMetaData.getFormat());
System.out.println("Codec: " + videoMetaData.getCodec());
System.out.println("Duration: " + videoMetaData.getDurationMillis());
System.out.println("FrameRate: " + videoMetaData.getFrameRate());
//Show text, confidence values
List textDetections = textDetectionResult.getTextDetections();
for (TextDetectionResult text: textDetections) {
long seconds=text.getTimestamp()/1000;
System.out.println("Sec: " + Long.toString(seconds) + " ");
TextDetection detectedText=text.getTextDetection();
System.out.println("Text Detected: " + detectedText.getDetectedText());
System.out.println("Confidence: " + detectedText.getConfidence().toString());
System.out.println("Id : " + detectedText.getId());
System.out.println("Parent Id: " + detectedText.getParentId());
System.out.println("Bounding Box" + detectedText.getGeometry().getBoundingBox().toString());
System.out.println("Type: " + detectedText.getType());
System.out.println();
}
} while (textDetectionResult !=null && textDetectionResult.getNextToken() != null);
}
```
Ersetzen Sie in der Funktion `main` die folgenden Zeilen:
```
StartLabelDetection(amzn-s3-demo-bucket, video);
if (GetSQSMessageSuccess()==true)
GetLabelDetectionResults();
```
mit:
```
StartTextDetection(amzn-s3-demo-bucket, video);
if (GetSQSMessageSuccess()==true)
GetTextDetectionResults();
```
------
#### [ Java V2 ]
Dieser Code stammt aus dem AWS Documentation SDK Examples GitHub Repository. Das vollständige Beispiel finden Sie [hier](https://github.com/awsdocs/aws-doc-sdk-examples/blob/master/javav2/example_code/rekognition/src/main/java/com/example/rekognition/VideoDetectText.java).
```
//snippet-start:[rekognition.java2.recognize_video_text.import]
import software.amazon.awssdk.auth.credentials.ProfileCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.rekognition.RekognitionClient;
import software.amazon.awssdk.services.rekognition.model.S3Object;
import software.amazon.awssdk.services.rekognition.model.NotificationChannel;
import software.amazon.awssdk.services.rekognition.model.Video;
import software.amazon.awssdk.services.rekognition.model.StartTextDetectionRequest;
import software.amazon.awssdk.services.rekognition.model.StartTextDetectionResponse;
import software.amazon.awssdk.services.rekognition.model.RekognitionException;
import software.amazon.awssdk.services.rekognition.model.GetTextDetectionResponse;
import software.amazon.awssdk.services.rekognition.model.GetTextDetectionRequest;
import software.amazon.awssdk.services.rekognition.model.VideoMetadata;
import software.amazon.awssdk.services.rekognition.model.TextDetectionResult;
import java.util.List;
//snippet-end:[rekognition.java2.recognize_video_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 DetectTextVideo {
private static String startJobId ="";
public static void main(String[] args) {
final String usage = "\n" +
"Usage: " +
"